Clone-class NPM

CLONE CLASS

Clone an ES6 Class as Another Class Name for Isolating Class Static Properties.

EXAMPLE

Run the following example by:

$ git clone git@github.com:zixia/clone-class.git
$ cd clone-class
$ npm install
$ npm run example

TypeScript

Example Source Code:

import * as assert from 'assert'

import {
  cloneClass,
  instanceToClass,
}                   from '../src/clone-class'

class Employee {
  public static company: string

  constructor(
    public name: string,
  ) {
  }

  public info() {
    console.log(`Employee ${this.name}, Company ${(this.constructor as any).company}`)
  }
}

/**
 * Example 1: `cloneClass()`
 */
const GoogleEmployee = cloneClass(Employee)
GoogleEmployee.company = 'Google'

const MicrosoftEmployee = cloneClass(Employee)
MicrosoftEmployee.company = 'Microsoft'

const employeeGg = new GoogleEmployee('Tom')
const employeeMs = new MicrosoftEmployee('Jerry')

employeeGg.info()
// Output: Employee Tom, Company Google
employeeMs.info()
// Output: Employee Jerry, Company Microsoft

/**
 * Example 2: `instanceToClass()`
 */
const RestoreGoogleEmployee = instanceToClass(employeeGg, Employee)
assert(RestoreGoogleEmployee === GoogleEmployee, 'Should get back the Class which instanciated the instance)
assert(RestoreGoogleEmployee !== Employee, 'Should be different with the parent Class')

const anotherEmployee = new RestoreGoogleEmployee('Mary')
anotherEmployee.info()
// Output: Employee Mary, Company Google

The most tricky part of this code is (this.constructor as any).company.

It will be very clear after we break down it as the following steps:

this.constructor is the constructor function of the class, which shuold be the class function itself.
company is a static properity defined in Employee class, which will be set as a property on the class function.
So this.constructor.company is equal to Employee.company, except that we will not need to know the exact name of the class, Employee in this case. We use this pattern is because we need to visit the class function even we do not know it's name.

API

We have two APIs for dealing with the classes:

cloneClass(OriginalClass): create a new Class that is extend from the OriginalClass which can isolate static properties for stored values, and return the new Class.
instanceToClass(instance, BaseClass): get the Class which had instanciated the instance, which is the BaseClass, or the child class of BaseClass, and return it.

`cloneClass()`

const AnotherClass = cloneClass(OrignalClass)
const instance = new AnotherClass()

`instanceToClass()`

const RestoredClass = instanceToClass(instance, OrignalClass)
assert(RestoredClass === AnotherClass, 'because `instance` was created by `new AnotherClass()`')

`Constructor<T>`

const NewableClass: typeof AbstractClass & Constructor<AbstractClass>
const instance = new NewableClass()

It seems useless at first, but if you want to use manage many Child Class for a Abstract Class with typings, then it will be a must have tool.

CHANGELOG

master v0.9 (Aug 26, 2021)

ESM Support
GitHub Action enabled

v0.6 (May 2018)

add new function: instanceToClass() for getting back the Class from an existing instance.
add new type: Constructor<T> for adding new (): T to abstract class declaration.