Classes Are Useful

It is very common to have the following structure:

  1. function foo() {
  2.     let someProperty;
  4.     // Some other initialization code
  6.     function someMethod() {
  7.         // Do some stuff with `someProperty`
  8.         // And potentially other things
  9.     }
  10.     // Maybe some other methods
  12.     return {
  13.         someMethod,
  14.         // Maybe some other methods
  15.     };
  16. }

This is known as the revealing module pattern and quite common in JavaScript (taking advantage of JavaScript closure).

If you use file modules (which you really should as global scope is bad) then your file is effectively the same. However there are too many cases where people will write code like the following:

  1. let someProperty;
  3. function foo() {
  4.    // Some initialization code
  5. }
  6. foo(); // some initialization code
  8. someProperty = 123; // some more initialization
  10. // Some utility function not exported
  12. // later
  13. export function someMethod() {
  15. }

Even though I am not a big fan of inheritance I do find that letting people use classes helps them organize their code better. The same developer would intuitively write the following:

  1. class Foo {
  2.     public someProperty;
  4.     constructor() {
  5.         // some initialization
  6.     }
  8.     public someMethod() {
  9.         // some code
  10.     }
  12.     private someUtility() {
  13.         // some code
  14.     }
  15. }
  17. export = new Foo();

And its not just developers, creating dev tools that provide great visualizations over classes are much more common, and there is one less pattern your team needs to understand and maintain.

PS: There is nothing wrong in my opinion with shallow class hierarchies if they provide significant reuse and reduction in boiler plate.