Nefarious Planetary Meddling

    TypeScript icon, indicating that this package has built-in type declarations

    2.0.11 • Public • Published


    Ergate is a npm package for better use ChildProcess and ThreadWorker in typescript. By using Ergate, you don't need to create childProcess or worker in trandition way:

    new Worker("xxxx/xxxx/xxxx.js")

    The simple example usage like this:

    const proc = await Process(TestProcessClass)
    const sum: number = await proc.testFunction(111, 222, 333)
    console.log('testFunction sum', sum)
    proc.testCallbackFunction(5, 6, (sum, timestamp) => {
    	console.log('testCallbackFunction sum and timestamp', sum, timestamp)
    proc.on('property-changed', (property, value) => {
    	console.log('Child process class property changed', property, value)
    	console.log('Current property value', proc.testProperty)
    	//Close the child process
    	proc.terminate().then(() => {
    		console.log('Child process closed')
    proc.testProperty = "this is assigned property"

    The TestProcessClass is a typescript class which exteneds ProcessClass

    export class TestProcessClass extends ProcessClass {
        public testProperty: string = "this is test property string"
        public testCallbackFunction(a: number, b: number, callback: (sum: number, timestamp: number) => void) {
    	    callback(a + b,
        public async testFunction(a: number, b: number, c: number) {
        	return a + b + c
    	protected async setup(): Promise<void> {
    		console.log('This is log from child process')

    Then run this example, you will get the following retults:

    This is log from child process
    testFunction sum 666
    testCallbackFunction sum and timestamp 11 1602350870867
    Child process class property changed testProperty this is assigned property
    Current property value this is assigned property
    Child process closed

    Both ChildProcess and WorkerThreads are created in similar way, the difference between create childProcess and workerThread is the base class your custom class have extended are differnet.

    The Base process class example

    export class YourProcessClass extends ProcessClass {
        protected async setup(): Promise<void> {
        	//the code will be executed while the childProcess initialized

    The Base thread class example

    export class YourThreadClass extends ThreadClass {
        protected async setup(): Promise<void> {
        	//the code will be executed while the thread worker initialized

    Create a process

    const yourProcessClassInstance = await Process(YourProcessClass)

    now you can use "yourProcessClassInstance" just like a local class instance

    Create a thread

    const yourThreadClassInstance = await Thread(YourThreadClass)

    now you can use "yourThreadClassInstance" just like a local class instance


    ProcessClass and ThreadClass are both extended ErgateBaseClass, therefore, you can invoke terminate() function for terminate process/worker

    Some common function will injected into your own class:

    async setup(): Promise

    async terminate(): Promise


    Following event like methods are designed for process/worker communication, so DO NOT abuse them

    on(event: string, handler: (...args: any[]) => void): void

    • error

    error event will be emitted while the process/worker error occurred

    • property-changed

    property changed event will be emitted while the in process/worker class property changed

    once(event: string, handler: (...args: any[]) => void): void

    emit(event: string, ...args: any[]): void

    off(event: string): void


    Just feel free to post issues or suggestions, this package is under MIT lisence


    npm i ergate

    DownloadsWeekly Downloads






    Unpacked Size

    86.1 kB

    Total Files


    Last publish


    • myq1991