wip: prototyping

[ci skip]

Author: tegefaulkes

src/WorkerManager.ts

@@ -1,9 +1,9 @@
-import type { WorkerFactory } from './types';
+import type { WorkerFactory } from './types.js';
 import Logger from '@matrixai/logger';
-import { CreateDestroy, ready } from '@matrixai/async-init/dist/CreateDestroy';
-import { WorkerTask } from './types';
-import * as errors from './errors';
-import WorkerPool from './WorkerPool';
+import { CreateDestroy, ready } from '@matrixai/async-init/CreateDestroy.js';
+import { WorkerTask } from './types.js';
+import * as errors from './errors.js';
+import WorkerPool from './WorkerPool.js';
 
 @CreateDestroy()
 class WorkerManager {

src/WorkerManagerInterface.ts renamed to src/WorkerManagerInterface.old

@@ -1,6 +1,6 @@
-import type { WorkerFactory, WorkerTask } from './types';
 import type { Worker } from 'node:worker_threads';
 import type { Subscription } from 'rxjs';
+import type { WorkerFactory, WorkerTask } from './types.js';
 import { Subject } from 'rxjs';
 
 const taskInfoSymbol = Symbol('Task Info Symbol');

src/WorkerPool.ts

@@ -0,0 +1,33 @@
+import type { WorkerTask, WorkerManifest } from '#types.js';
+import { isMainThread, parentPort, threadId } from 'node:worker_threads';
+
+/**
+ * Call inside a worker to set it up and expose the supported worker functions.
+ * Calling this within the main thread will do nothing
+ * @param workerManifest
+ */
+function expose(workerManifest: WorkerManifest) {
+  // We don't want to run this in the main thread since it's not acting as a worker
+  if (isMainThread) return;
+  const handleMessage = async (task: WorkerTask) => {
+    console.log(task);
+    const method = workerManifest[task.type];
+    if (method == null) {
+      const e = Error('TMP IMP missing handler');
+      console.error(e);
+      throw e;
+    }
+    const result = await method(task);
+    parentPort?.postMessage(result);
+  };
+  const handleMessageError = (e) => {
+    console.error(`Worker ${threadId} got error`, e);
+  };
+  parentPort!.once('close', () => {
+    console.log(`Worker ${threadId} closed!`);
+    parentPort!.off('message', handleMessage);
+    parentPort!.off('messageerror', handleMessageError);
+  });
+}
+
+export { expose };

src/expose.ts

@@ -1,7 +1,2 @@
 export { default as WorkerManager } from './WorkerManager.js';
-export { default as workerModule } from './workerModule.js';
 export * as errors from './errors.js';
-
-export type { default as WorkerManagerInterface } from './WorkerManagerInterface.js';
-// Export type { WorkerModule } from './workerModule.js';
-export type { ModuleMethods, ModuleThread, QueuedTask } from './types.js';

src/index.ts

@@ -7,4 +7,9 @@ type WorkerTask<T extends string = string, D extends any = any> = {
   data: D;
 };
 
-export type { WorkerFactory, WorkerTask };
+type WorkerFunction<I extends any = any, O extends any = any> = (
+  data: I,
+) => Promise<O>;
+type WorkerManifest = Record<string, WorkerFunction>;
+
+export type { WorkerFactory, WorkerTask, WorkerFunction, WorkerManifest };

src/oldworker.ts renamed to src/oldworker.old

@@ -0,0 +1,27 @@
+// This is an example worker script
+
+import type { WorkerManifest } from '#types.js';
+import { expose } from './expose.js';
+
+const worker = {
+  test: async (data: void) => {
+    return 'hello world!';
+  },
+  add: async (data: { a: number; b: number }): Promise<number> => {
+    return data.a + data.b;
+  },
+  sub: async (data: { a: number; b: number }): Promise<number> => {
+    return data.a - data.b;
+  },
+  fac: async (data: number): Promise<number> => {
+    let acc = 1;
+    for (let i = 1; i < data; i++) {
+      acc = acc * i;
+    }
+    return acc;
+  },
+} satisfies WorkerManifest;
+
+expose(worker);
+
+export default worker;