WorkerThread

Declare Worker Thread

const workerPath = path.join('<PATH_TO_WORKER_JS_FILE>');
const worker = new Worker(workerPath, { 
    workerData: {
        // Passing data to worker
    },
})

worker.on('message', message => {
    // Handle message from WORKER PROCESS
});

worker.on('error', error => {
    this.logger.error('[error] error: %s', error);
});

worker.on('online', async () => {
    this.logger.info('[online] online');
});

worker.on('messageerror', error => {
    this.logger.error('[messageerror] error: %s', error);
});

worker.on('exit', code => {
    this.logger.warn('[exit] code: %s', code);
});

Worker Class

export class WorkerClass extends BaseWorkerThreadHelper {
  constructor() {

    // Declare message handler
    const parentPortMessageHandler = new BaseWorkerMessageBusHandlerHelper({
      scope: ABSignalWorker.name,
      onMessage: opts => {
        // Handle message from parentPort
      },
    })
    
    // Binding message handler to worker thread bus, this will start to watch events from MessagePort
    this.bindWorkerBus<TMainToWorkerPayload, TWorkerToMainPayload>({
      key: 'worker-1',
      bus: new BaseWorkerBusHelper({
        scope: ABSignalWorker.name,
        port: parentPort!, // This could be any MessagePort 
        busHandler: parentPortMessageHandler,
      }),
    });
  }

  getWorkerToMainTunnel() {
    return this.getWorkerBus<TMainToWorkerPayload, TWorkerToMainPayload>({
      key: 'worker-1',
    });
  }

  exampleFunction() {
    const tunnelEmitter = this.getWorkerToMainTunnel();

    // Post message from WORKER PROCESS to MAIN PROCESS
    tunnelEmitter.postMessage({
      message: {
        type: 'MESSAGE_TYPE',
        payload: {}, // any payload here
      },
      transferList: undefined,
    })
  }

  // Some extra code
}