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:

1. this.constructor is the constructor function of the class, which shuold be the class function itself.
2. company is a static properity defined in Employee class, which will be set as a property on the class function.
3. 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:

1. 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.
2. instanceToClass(instance, BaseClass): get the Class which had instanciated the instance, which is the BaseClass, or the child class of BaseClass, and return it.

1. cloneClass()

const GoogleEmployee = cloneClass(Employee)
const instance = new GoogleEmployee()

assert(instance instanceof GoogleEmployee)
assert(instance instanceof Employee)
assert(GoogleEmployee.name === Employee.name, 'Should be the same class name')

2. instanceToClass()

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

3. Constructor<T>

class PrivateConstructorClass {
  private constructor() {
    console.info('private constructor called')
  }
}

const NewableClass = PrivateConstructorClass as any as Constructor<PrivateConstructorClass>
const instance = new NewableClass()
// Output: private constructor called

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.

4. looseInstanceOfClass(Klass)(target)

use it to check whether a class instance is:

1. instanceof the class Klass
2. instanceof the class Klass's child class
3. the constructor.name is the same as the class Klass

Usage:

looseInstanceOfClass = <C extends Constructor> (Klass: C) => (target: any): target is InstanceType<C>

5. interfaceOfClass(Klass)<Interface>()(target)

use it to check where a target object has all the same properties from class Klass

Usage:

interfaceOfClass = <C extends Constructor> (Klass: C) => <I extends {}> () => (target: any): target is I

CHANGELOG

master v1.0 (Oct 20, 2021)

1. Add interfaceOfClass() method to check whether a object satisfy a class interface.

v0.9 (Aug 26, 2021)

1. ESM Support
2. GitHub Action enabled
3. add looseInstanceOfClass() method to check whether two class has the same name (See (wechaty/wechaty#2090))

v0.6 (May 2018)

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

v0.4 (Apr 2018)

First publish version.

1. cloneClass() work as expected.

v0.0.1 (Apr 23, 2018)

Initial version, code comes from Project Wechaty.

Learn more about the full story at Chatie blog: New Feature: Multi-Instance Support for Wechaty v0.16(WIP)

SEE ALSO

An UseCase of clone-class can be found in an article writen by me from Chatie blog, it's also the place where this module comes from. It's Worth to spent some time to have a look if you are interested.

• New Feature: Multi-Instance Support for Wechaty v0.16(WIP)
• TypeScript 2.1 keyof and Lookup Types
• TypeScript Evolution
• TypeScript Advanced Types

AUTHOR

Huan LI <zixia@zixia.net>

COPYRIGHT & LICENSE

• Code & Docs © 2018 Huan LI <zixia@zixia.net>
• Code released under the Apache-2.0 License
• Docs released under Creative Commons