vovk 3.0.0-draft.48 → 3.0.0-draft.50

package/src/utils/shim.ts

@@ -0,0 +1,17 @@
+if (typeof Symbol.dispose !== 'symbol') {
+  Object.defineProperty(Symbol, 'dispose', {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: Symbol.for('dispose'),
+  });
+}
+
+if (typeof Symbol.asyncDispose !== 'symbol') {
+  Object.defineProperty(Symbol, 'asyncDispose', {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: Symbol.for('asyncDispose'),
+  });
+}

package/src/worker/createWPC.ts

@@ -0,0 +1,156 @@
+import type { VovkWorkerSchema } from '../types';
+import type { WorkerInput, WorkerOutput, WorkerPromiseInstance } from './types';
+
+export function createWPC<T extends object>(
+  currentWorker: Worker | null,
+  workerSchema: object
+): WorkerPromiseInstance<T> {
+  if (!workerSchema) throw new Error('Worker schema is not provided');
+  const schema = workerSchema as T & VovkWorkerSchema;
+  const instance = {
+    worker: currentWorker,
+  } as WorkerPromiseInstance<T>;
+  let callsKey = 0;
+
+  instance.terminate = () => {
+    if (instance._isTerminated) return;
+    instance._isTerminated = true;
+    instance.worker?.terminate();
+    instance.worker = null;
+  };
+
+  instance.employ = (worker: Worker) => {
+    if (instance._isTerminated) return instance;
+    instance._isTerminated = true;
+    instance.worker = worker;
+    return instance;
+  };
+
+  instance.fork = (worker: Worker) => createWPC<T>(worker, schema);
+
+  for (const methodName of Object.keys(schema.handlers) as (keyof T & string)[]) {
+    const { isGenerator } = schema.handlers[methodName];
+
+    if (isGenerator) {
+      const method = (...args: unknown[]) => {
+        const key = callsKey;
+        callsKey += 1;
+        return {
+          async *[Symbol.asyncIterator]() {
+            if (!instance.worker) {
+              throw new Error('Worker is not provided or terminated');
+            }
+            const w = instance.worker;
+            const messageQueue: WorkerOutput[] = [];
+            let messageResolver: ((message: WorkerOutput) => void) | null = null;
+
+            const onMessage = (e: MessageEvent<WorkerOutput>) => {
+              const { methodName: m, key: k } = e.data;
+              if (k !== key || m !== methodName) {
+                return;
+              }
+              if (messageResolver) {
+                messageResolver(e.data);
+                messageResolver = null;
+              } else {
+                messageQueue.push(e.data);
+              }
+            };
+
+            const onError = (e: ErrorEvent) => {
+              if (messageResolver) {
+                messageResolver({ error: e.error } as WorkerOutput);
+                messageResolver = null;
+              } else {
+                messageQueue.push({ error: e.error } as WorkerOutput);
+              }
+
+              w.removeEventListener('message', onMessage);
+              w.removeEventListener('error', onError);
+              throw e.error;
+            };
+
+            w.addEventListener('message', onMessage);
+            w.addEventListener('error', onError);
+
+            w.postMessage({ key, args, methodName } satisfies WorkerInput);
+
+            try {
+              while (true) {
+                let message: WorkerOutput | null = null;
+                if (messageQueue.length > 0) {
+                  message = messageQueue.shift()!;
+                } else {
+                  message = await new Promise<WorkerOutput>((resolve) => {
+                    messageResolver = resolve;
+                  });
+                }
+
+                const { result, error, done } = message;
+
+                if (error) {
+                  throw error;
+                }
+
+                if (done) {
+                  break;
+                }
+
+                yield result;
+              }
+
+              w.removeEventListener('message', onMessage);
+              w.removeEventListener('error', onError);
+            } catch (e) {
+              w.removeEventListener('message', onMessage);
+              w.removeEventListener('error', onError);
+              throw e;
+            }
+          },
+        };
+      };
+
+      // @ts-expect-error TODO
+      instance[methodName] = method;
+    } else {
+      const method = (...args: unknown[]) => {
+        if (!instance.worker) {
+          throw new Error('Worker is not provided or terminated');
+        }
+        const w = instance.worker;
+        return new Promise((resolve, reject) => {
+          const key = callsKey;
+          callsKey += 1;
+
+          const onError = (e: ErrorEvent) => {
+            w.removeEventListener('message', onMessage);
+            w.removeEventListener('error', onError);
+            reject(e);
+          };
+
+          const onMessage = (e: MessageEvent<WorkerOutput>) => {
+            const { result, error, key: k, methodName: m } = e.data;
+            if (k !== key || m !== methodName) {
+              return;
+            }
+            w.removeEventListener('message', onMessage);
+            w.removeEventListener('error', onError);
+            if (error) {
+              reject(error);
+            } else {
+              resolve(result);
+            }
+          };
+
+          w.addEventListener('message', onMessage);
+          w.addEventListener('error', onError);
+          w.postMessage({ key, args, methodName } satisfies WorkerInput);
+        });
+      };
+
+      // @ts-expect-error TODO
+      instance[methodName] = method;
+    }
+  }
+  return instance;
+}

package/src/worker/index.ts

@@ -0,0 +1,4 @@
+import { worker } from './worker';
+import { createWPC } from './createWPC';
+
+export { worker, createWPC };

package/src/worker/types.ts

@@ -0,0 +1,45 @@
+import type { KnownAny } from '../types';
+
+type ToPromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
+type ToAsyncGenerator<T> =
+  T extends AsyncGenerator<unknown, unknown, unknown>
+    ? T
+    : T extends Generator<infer U, unknown, unknown>
+      ? AsyncGenerator<U, unknown, unknown>
+      : AsyncGenerator<T, unknown, unknown>;
+type ToProperReturnType<T> = T extends Generator<unknown, unknown, unknown> | AsyncGenerator<unknown, unknown, unknown>
+  ? ToAsyncGenerator<T>
+  : ToPromise<T>;
+
+type OmitNever<T> = {
+  [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+
+export type WorkerPromiseInstanceWithNever<T> = {
+  [K in keyof T]: T[K] extends (...args: KnownAny[]) => KnownAny
+    ? (...args: Parameters<T[K]>) => ToProperReturnType<ReturnType<T[K]>>
+    : never;
+};
+
+export type WorkerPromiseInstance<T> = OmitNever<WorkerPromiseInstanceWithNever<T>> & {
+  terminate: () => void;
+  employ: (w: Worker) => WorkerPromiseInstance<T>;
+  fork: (w: Worker) => WorkerPromiseInstance<T>;
+  worker: Worker | null;
+  _isTerminated?: true;
+  [Symbol.dispose]: () => void;
+};
+
+export interface WorkerInput {
+  methodName: string;
+  args: unknown[];
+  key: number;
+}
+
+export interface WorkerOutput {
+  methodName: string;
+  result?: unknown;
+  error?: unknown;
+  done?: true;
+  key: number;
+}

package/src/worker/worker.ts

@@ -0,0 +1,53 @@
+import type { VovkWorker } from '../types';
+import type { WorkerInput, WorkerOutput } from './types';
+
+export function worker() {
+  return (t: object) => {
+    const target = t as Record<
+      string,
+      (
+        ...args: unknown[]
+      ) => Iterable<unknown> | AsyncIterable<unknown> | Promise<Iterable<unknown> | AsyncIterable<unknown>>
+    > &
+      VovkWorker;
+    target._handlers = {};
+
+    for (const key of Object.getOwnPropertyNames(target)) {
+      const member = target[key];
+      if (typeof member === 'function') {
+        const prototype = Object.getPrototypeOf(member) as unknown;
+        const isGenerator =
+          prototype === Object.getPrototypeOf(function* () {}) ||
+          prototype === Object.getPrototypeOf(async function* () {});
+        target._handlers[key] = {};
+
+        if (isGenerator) {
+          target._handlers[key].isGenerator = true;
+        }
+      }
+    }
+
+    if (typeof self === 'undefined') return; // no-op in non-worker environment
+
+    const w = self as unknown as Worker;
+
+    w.onmessage = async (evt: MessageEvent<WorkerInput>) => {
+      const { methodName, args, key } = evt.data;
+      try {
+        const result = await target[methodName](...args);
+
+        if (result && typeof result === 'object' && 'next' in result && typeof result.next === 'function') {
+          const iterable = result as Iterable<unknown> | AsyncIterable<unknown>;
+          for await (const result of iterable) {
+            w.postMessage({ result, key, methodName } satisfies WorkerOutput);
+          }
+          w.postMessage({ done: true, key, methodName } satisfies WorkerOutput);
+        } else {
+          w.postMessage({ result, key, methodName } satisfies WorkerOutput);
+        }
+      } catch (e) {
+        w.postMessage({ error: e, key, methodName } satisfies WorkerOutput);
+      }
+    };
+  };
+}

package/client/clientizeController.d.ts

@@ -1,4 +0,0 @@
-import { type VovkControllerSchema, type KnownAny } from '../types';
-import { type VovkClientOptions, type VovkClient, type VovkDefaultFetcherOptions } from './types';
-export declare const ARRAY_QUERY_KEY = "_vovkarr";
-export declare const clientizeController: <T, OPTS extends Record<string, KnownAny> = VovkDefaultFetcherOptions>(controllerSchema: VovkControllerSchema, segmentName?: string, options?: VovkClientOptions<OPTS>) => VovkClient<T, OPTS>;

package/client/index.d.ts

@@ -1,4 +0,0 @@
-import { clientizeController } from './clientizeController';
-import type { VovkClientFetcher, VovkClientOptions, VovkDefaultFetcherOptions } from './types';
-export { clientizeController };
-export type { VovkClientFetcher, VovkClientOptions, VovkDefaultFetcherOptions };

package/client/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clientizeController = void 0;
-const clientizeController_1 = require("./clientizeController");
-Object.defineProperty(exports, "clientizeController", { enumerable: true, get: function () { return clientizeController_1.clientizeController; } });

package/utils/setClientValidatorsForHandler.d.ts

@@ -1,5 +0,0 @@
-import { KnownAny as KnownAny } from '../types';
-export default function setClientValidatorsForHandler(h: (...args: KnownAny[]) => KnownAny, validation: {
-    body: unknown;
-    query: unknown;
-}): Promise<void>;

package/worker/index.d.ts

@@ -1,3 +0,0 @@
-import { worker } from './worker';
-import { promisifyWorker } from './promisifyWorker';
-export { worker, promisifyWorker };

package/worker/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promisifyWorker = exports.worker = void 0;
-const worker_1 = require("./worker");
-Object.defineProperty(exports, "worker", { enumerable: true, get: function () { return worker_1.worker; } });
-const promisifyWorker_1 = require("./promisifyWorker");
-Object.defineProperty(exports, "promisifyWorker", { enumerable: true, get: function () { return promisifyWorker_1.promisifyWorker; } });

package/worker/promisifyWorker.d.ts

@@ -1,2 +0,0 @@
-import type { WorkerPromiseInstance } from './types';
-export declare function promisifyWorker<T extends object>(currentWorker: Worker | null, workerSchema: object): WorkerPromiseInstance<T>;