wip: adding methods proxy

Author: tegefaulkes

src/WorkerManager.ts

@@ -1,12 +1,12 @@
-import type { WorkerFactory } from './types.js';
+import type { WorkerFactory, WorkerManifest } from './types.js';
 import Logger from '@matrixai/logger';
 import { CreateDestroy, ready } from '@matrixai/async-init/CreateDestroy.js';
 import { type WorkerTaskInput } from './types.js';
 import * as errors from './errors.js';
 import WorkerPool from './WorkerPool.js';
 
 @CreateDestroy()
-class WorkerManager {
+class WorkerManager<T extends WorkerManifest> {
   /**
    * Creates the WorkerManager
    * The workerFactory needs to be a callback:
@@ -19,18 +19,21 @@ class WorkerManager {
    * If `cores` is set to 0, this creates a useless worker pool
    * Use `undefined` to mean using all cores
    */
-  public static async createWorkerManager({
+  public static async createWorkerManager<T extends WorkerManifest>({
     workerFactory,
+    manifest,
     cores = 1,
     logger = new Logger(this.name),
   }: {
     workerFactory: WorkerFactory;
+    manifest: T;
     cores?: number;
     logger?: Logger;
-  }): Promise<WorkerManager> {
+  }): Promise<WorkerManager<T>> {
     logger.info('Creating WorkerManager');
-    const workerManager = new this({
+    const workerManager = new this<T>({
       workerFactory,
+      manifest,
       cores,
       logger,
     });
@@ -39,19 +42,36 @@ class WorkerManager {
   }
 
   protected pool: WorkerPool;
+  protected manifest: T;
+  public proxy: T;
   protected logger: Logger;
 
   public constructor({
     workerFactory,
+    manifest,
     cores,
     logger,
   }: {
     workerFactory: WorkerFactory;
+    manifest: T;
     cores: number;
     logger: Logger;
   }) {
     this.logger = logger;
+    this.manifest = manifest;
     this.pool = new WorkerPool(cores, workerFactory);
+    this.proxy = new Proxy(this.manifest, {
+      apply: () => {
+        throw Error('TMP IMP NEVER');
+      },
+      get: (target: T, prop) => {
+        if (typeof prop === 'symbol') return;
+        return (data, transferList) => {
+          console.log(`${prop} called with `, data, transferList);
+          return this.call({ type: prop, data, transferList });
+        };
+      },
+    });
   }
 
   public async destroy({

src/types.ts

@@ -13,6 +13,7 @@ type WorkerTaskInput = WorkerTaskInformation & {
 
 type WorkerFunction<I = unknown, O = unknown> = (
   data: I,
+  transferList?: Array<TransferListItem>,
 ) => Promise<WorkerResult<O>>;
 type WorkerResult<O = unknown> = { data: O };
 type WorkerResultInternal<O = unknown> = WorkerResult<O> & {

src/worker.ts

@@ -28,7 +28,7 @@ const worker = {
     });
     return { data: undefined };
   },
-  transferBuffer: async (data: ArrayBuffer) => {
+  transferBuffer: async (data: ArrayBuffer, _transferList?: [ArrayBuffer]) => {
     const buffer = Buffer.from(data, 0, data.byteLength);
     buffer.fill(0xf);
     return { data, transferList: [data] };

tests/WorkerManager.test.ts

@@ -6,6 +6,7 @@ import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
 import { destroyed } from '@matrixai/async-init';
 import WorkerManager from '#WorkerManager.js';
 import * as errors from '#errors.js';
+import workerManifest from '#worker.js';
 
 const dirname = url.fileURLToPath(new URL('.', import.meta.url));
 
@@ -133,4 +134,21 @@ describe('WorkerManager', () => {
 
     await workerManager.destroy();
   });
+
+  test('proxy', async () => {
+    const workerManager = await WorkerManager.createWorkerManager<
+      typeof workerManifest
+    >({
+      workerFactory,
+      cores: 1,
+      manifest: workerManifest,
+      logger,
+    });
+    const arrayBuffer = new ArrayBuffer(100);
+    const result = await workerManager.proxy.transferBuffer(arrayBuffer, [
+      arrayBuffer,
+    ]);
+    console.log(result);
+    await workerManager.destroy();
+  });
 });