ES-Class Utility

Common errors

• ReferenceError: Class is not defined

  cause The `es-class` utility was not correctly imported or required into the current scope, or the browser script tag was not loaded.
  fix In CommonJS (Node.js), ensure `const Class = require('es-class');` is at the top of your file. In a browser, verify that the `<script>` tag for `es-class.js` is correctly placed and loaded before its usage.

• TypeError: super must be called with 'new'

  cause This error can occur if you attempt to call `super()` directly within an `es-class` constructor instead of `this.super()`, or if the context of `this` is lost.
  fix Ensure that within an `es-class` constructor, you invoke the parent constructor via `this.super(arguments)` or `this.super(param1, param2)`. Also, be mindful of `this` context when passing methods around.

• Uncaught TypeError: Class(...) is not a constructor

  cause This error typically occurs if `es-class`'s `Class` function is treated like a native ES6 class (e.g., `new Class(...)`) when it's not set up that way, or if the `Class` function itself hasn't been properly invoked to define the class structure.
  fix Ensure you are using `Class({...})` to define a class, then `new MyClass()` to create an instance. The error might also suggest an incorrect import/require that doesn't yield the `Class` function itself.

Warnings

• breaking The `es-class` library introduces its own `Class` function and internal concepts like `extends` (as a property) and `super` (as a method). This can lead to significant confusion and potential conflicts when integrated into modern JavaScript codebases that use native ES6 `class` syntax, which has its own keywords and semantics for inheritance and `super` calls.
  Fix: For new projects, prefer native ES6 `class` syntax. If integrating with existing `es-class` code, be extremely cautious about namespace collisions and semantic differences. Consider refactoring old code to native classes if possible.
• deprecated The `es-class` library is largely superseded by native ES6 `class` syntax, which offers standard, performant, and well-supported object-oriented patterns directly in the language. The library's approach to mimicking class features is no longer necessary or recommended for new development.
  Fix: Modernize your codebase by migrating away from `es-class` to native JavaScript `class` definitions. This improves maintainability, tooling support, and leverages contemporary language features.
• gotcha This project appears to be abandoned, with no updates or maintenance for many years. This means it is unlikely to receive security patches, bug fixes, or compatibility updates for newer JavaScript runtimes or browser versions. Using abandoned dependencies introduces security and stability risks.
  Fix: Avoid using `es-class` in new projects. For existing projects, plan for migration to native ES6 classes to mitigate risks associated with unmaintained software.
• gotcha The `implements` feature in `es-class` provides only 'light checks' (runtime warnings if a method is missing) and does not offer true compile-time type safety or interface enforcement like TypeScript interfaces. This can create a false sense of security regarding type contracts.
  Fix: If strong type safety and interface enforcement are required, integrate with TypeScript and use its `implements` keyword for class interfaces. Do not rely on `es-class` for robust type checking.

Install

• npm install es-class npm
• yarn add es-class yarn
• pnpm add es-class pnpm

Imports

• Class
  wrong:

  import { Class } from 'es-class';

  correct:

  const Class = require('es-class');

  Primarily designed for CommonJS environments in Node.js. Avoid named imports as it typically exports a default function.
• Class
  wrong:

  const Class = require('es-class');

  correct:

  // After <script src="//cdnjs.cloudflare.com/ajax/libs/es-class/2.1.1/es-class.js"></script>
  // Class is available globally.

  In browser environments, `es-class` exposes `Class` as a global variable after the script is loaded. Do not use Node.js `require` in the browser.
• Class
  wrong:

  import { Class } from 'es-class';

  correct:

  import Class from 'es-class';

  When used in an ESM context via a bundler, it's typically imported as a default export, assuming the bundler correctly handles CommonJS interoperability. Avoid named imports.

Quickstart

Demonstrates defining a base `Person` class, an interface `iWorker`, and an `Engineer` class that `extends` `Person` and `implements` `iWorker`, using `static` properties and `super`.

const Class = require('es-class');

const Person = Class({
  constructor: function(name, age) {
    this.name = name;
    this.age = age;
  },
  greet: function() {
    return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
  }
});

const iWorker = {
  work: function() { throw new Error('Not implemented'); }
};

const Engineer = Class({
  extends: Person,
  implements: [iWorker],
  static: {
    SOFTWARE: 0,
    CONSTRUCTIONS: 1
  },
  constructor: function (name, age, type) {
    this.super(name, age);
    this.type = type;
  },
  work: function() {
    return `Engineer ${this.name} is working on type ${this.type}.`;
  }
});

const me = new Engineer(
  'Mr. Andrea Giammarchi',
  36,
  Engineer.SOFTWARE
);

console.log(me instanceof Person); // true
console.log(me.type);              // 0 (Engineer.SOFTWARE)
console.log(me.greet());
console.log(me.work());