@zk-tech/bedrock 0.0.1

package/src/worker/promise-worker-main-thread.ts

@@ -0,0 +1,76 @@
+/**
+ * worker 包装函数，允许将事件处理成 promise 形式.
+ */
+import { uuid } from '@/uuid';
+import type { Deferred } from '@/promise';
+import { defer } from '@/promise';
+import { lvAssert } from '@/assert';
+import { makeError, makeOk, makeOkWith, type ILvErrorOr } from '@/error';
+import type { PromiseWorkerRawRequest, PromiseWorkerRequest, PromiseWorkerResponse } from './promise-worker.interface';
+
+export class PromiseWorkerMainThread {
+  private readonly _deferMap: Map<string, Deferred<any>> = new Map();
+
+  constructor(private readonly _worker: Worker) {
+    const preMessageHandler = _worker.onmessage?.bind(_worker);
+    this._worker.onmessage = (event) => {
+      // 如果 worker 在传递进来之前已经绑定过 onmessage.
+      // 那么做一层代理确保原本的监听函数不会失效丢失
+      preMessageHandler?.(event);
+
+      this._receiveWorkerMsgHandler(event?.data);
+    };
+  }
+
+  /**
+   * 将任务下派给 worker 并等待其返回
+   * - 由于 worker 本身运行在独立线程中，所以没必要专门为其设计任务执行队列.
+   * */
+  public sendTaskToWorker<ReqT, ResT>(req: Omit<PromiseWorkerRequest<ReqT> | PromiseWorkerRawRequest, 'pid'> = {}): Promise<ILvErrorOr<ResT>> {
+    const taskDefer = defer<ILvErrorOr<ResT>>();
+    const worker = this._worker;
+    const id = uuid();
+
+    this._deferMap.set(id, taskDefer);
+    worker.postMessage({
+      pid: id,
+      ...req,
+    } as PromiseWorkerRequest<ReqT>);
+    return taskDefer.promise;
+  }
+
+  private _receiveWorkerMsgHandler<ResT>(res?: PromiseWorkerResponse<ResT>) {
+    if (!res) {
+      return;
+    }
+    if (!this._check(res)) {
+      return;
+    }
+
+    const { pid, code, msg, data } = res;
+    const task = this._deferMap.get(pid) as Deferred<ILvErrorOr<ResT>>;
+    lvAssert(task, `task-${pid} is not defined`);
+
+    if (code === 0) {
+      if (!data) {
+        task.resolve(makeOk());
+      } else {
+        task.resolve(makeOkWith<ResT>(data));
+      }
+    } else {
+      task.resolve(makeError(code, msg ?? 'no message error.'));
+    }
+    this._deferMap.delete(pid);
+  }
+
+  private _check<ResT>(res?: PromiseWorkerResponse<ResT>): res is PromiseWorkerResponse<ResT> {
+    if (!res) {
+      return false;
+    }
+    const keyMap = ['pid'];
+    if (keyMap.map((key) => key in res).includes(false)) {
+      return false;
+    }
+    return true;
+  }
+}

package/src/worker/promise-worker-worker-thread.ts

@@ -0,0 +1,64 @@
+/**
+ * worker 包装函数，允许将事件处理成 promise 形式.
+ */
+import type { PromiseWorkerRawRequest, PromiseWorkerRequest, PromiseWorkerResponse } from './promise-worker.interface';
+
+export abstract class PromiseWorkerWorkerThread {
+  constructor() {
+    self.onmessage = (event) => {
+      this._receiveMainThreadMsgHandler(event?.data);
+    };
+  }
+
+  /**
+   * 将任务下派给 worker 并等待其返回
+   * - 由于 worker 本身运行在独立线程中，所以没必要专门为其设计任务执行队列.
+   * */
+  protected _sendSuccessToMainThread<ReqT, ResT>(
+    req: PromiseWorkerRequest<ReqT> | PromiseWorkerRawRequest,
+    result?: ResT,
+  ): void {
+    self.postMessage({
+      pid: req.pid,
+      code: 0,
+      data: result,
+    } as PromiseWorkerResponse<ResT>);
+  }
+
+  protected _sendFailToMainThread<ReqT>(
+    req: PromiseWorkerRequest<ReqT> | PromiseWorkerRawRequest,
+    errCode: number,
+    message?: string,
+  ): void {
+    self.postMessage({
+      pid: req.pid,
+      code: errCode,
+      msg: message,
+    } as PromiseWorkerResponse<any>);
+  }
+
+  protected abstract _messageHandler(req: PromiseWorkerRequest<any> | PromiseWorkerRawRequest): void;
+
+  private _receiveMainThreadMsgHandler<ReqT>(req?: PromiseWorkerRequest<ReqT>) {
+    if (!req) {
+      return;
+    }
+    if (!this._check(req)) {
+      return;
+    }
+
+    try {
+      this._messageHandler(req);
+    } catch (err) {
+      this._sendFailToMainThread(req, -1, (err as Error).message ?? 'unknown error.');
+    }
+  }
+
+  private _check<ReqT>(req: PromiseWorkerRequest<ReqT>): req is PromiseWorkerRequest<ReqT> {
+    const keyMap = ['pid'];
+    if (keyMap.map((key) => key in req).includes(false)) {
+      return false;
+    }
+    return true;
+  }
+}

package/src/worker/promise-worker.interface.ts

@@ -0,0 +1,15 @@
+export interface PromiseWorkerRequest<Req> {
+  pid: string;
+  data: Req;
+}
+
+export interface PromiseWorkerRawRequest {
+  pid: string;
+}
+
+export interface PromiseWorkerResponse<Res> {
+  pid: string;
+  code: number;
+  msg?: string;
+  data?: Res;
+}