npm - vovk - Versions diffs - 3.0.0-draft.5 → 3.0.0-draft.50 - Mend

vovk 3.0.0-draft.5 → 3.0.0-draft.50

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (97) hide show

package/.DS_Store +0 -0
package/.npmignore +2 -1
package/.turbo/turbo-build.log +6 -0
package/.turbo/turbo-ncu.log +9 -0
package/.turbo/turbo-tsc.log +6 -0
package/README.md +1 -111
package/{HttpException.d.ts → dist/HttpException.d.ts} +2 -2
package/{HttpException.js → dist/HttpException.js} +3 -3
package/{StreamResponse.d.ts → dist/StreamJSONResponse.d.ts} +4 -3
package/{StreamResponse.js → dist/StreamJSONResponse.js} +6 -5
package/{Segment.d.ts → dist/VovkApp.d.ts} +3 -3
package/{Segment.js → dist/VovkApp.js} +26 -23
package/dist/client/createRPC.d.ts +4 -0
package/{client/clientizeController.js → dist/client/createRPC.js} +17 -17
package/dist/client/defaultFetcher.d.ts +4 -0
package/{client → dist/client}/defaultFetcher.js +7 -7
package/{client → dist/client}/defaultHandler.d.ts +1 -1
package/dist/client/defaultHandler.js +22 -0
package/dist/client/defaultStreamHandler.d.ts +4 -0
package/{client → dist/client}/defaultStreamHandler.js +5 -5
package/dist/client/index.d.ts +4 -0
package/dist/client/index.js +5 -0
package/dist/client/types.d.ts +100 -0
package/dist/createDecorator.d.ts +4 -0
package/{createDecorator.js → dist/createDecorator.js} +4 -4
package/{createSegment.d.ts → dist/createVovkApp.d.ts} +2 -2
package/{createSegment.js → dist/createVovkApp.js} +25 -25
package/dist/index.d.ts +61 -0
package/dist/index.js +25 -0
package/dist/types.d.ts +157 -0
package/dist/types.js +65 -0
package/dist/utils/generateStaticAPI.d.ts +4 -0
package/{generateStaticAPI.js → dist/utils/generateStaticAPI.js} +3 -3
package/{utils → dist/utils}/getSchema.d.ts +1 -1
package/{utils → dist/utils}/getSchema.js +9 -9
package/dist/utils/reqForm.d.ts +2 -0
package/dist/utils/reqForm.js +13 -0
package/{utils → dist/utils}/reqMeta.d.ts +1 -2
package/{utils → dist/utils}/reqQuery.d.ts +1 -2
package/{utils → dist/utils}/reqQuery.js +3 -3
package/dist/utils/setClientValidatorsForHandler.d.ts +5 -0
package/{utils → dist/utils}/setClientValidatorsForHandler.js +4 -6
package/dist/worker/createWPC.d.ts +2 -0
package/{worker/promisifyWorker.js → dist/worker/createWPC.js} +7 -9
package/dist/worker/index.d.ts +3 -0
package/dist/worker/index.js +7 -0
package/{worker → dist/worker}/types.d.ts +7 -7
package/dist/worker/worker.d.ts +1 -0
package/{worker → dist/worker}/worker.js +2 -3
package/package.json +5 -2
package/src/HttpException.ts +16 -0
package/src/StreamJSONResponse.ts +62 -0
package/src/VovkApp.ts +242 -0
package/src/client/createRPC.ts +133 -0
package/src/client/defaultFetcher.ts +57 -0
package/src/client/defaultHandler.ts +23 -0
package/src/client/defaultStreamHandler.ts +88 -0
package/src/client/index.ts +5 -0
package/src/client/types.ts +115 -0
package/src/createDecorator.ts +60 -0
package/src/createVovkApp.ts +167 -0
package/src/index.ts +66 -0
package/src/types.ts +215 -0
package/src/utils/generateStaticAPI.ts +18 -0
package/src/utils/getSchema.ts +48 -0
package/src/utils/reqForm.ts +16 -0
package/src/utils/reqMeta.ts +16 -0
package/src/utils/reqQuery.ts +26 -0
package/src/utils/setClientValidatorsForHandler.ts +45 -0
package/src/utils/shim.ts +17 -0
package/src/worker/createWPC.ts +156 -0
package/src/worker/index.ts +4 -0
package/src/worker/types.ts +45 -0
package/src/worker/worker.ts +53 -0
package/client/clientizeController.d.ts +0 -4
package/client/defaultFetcher.d.ts +0 -4
package/client/defaultHandler.js +0 -21
package/client/defaultStreamHandler.d.ts +0 -4
package/client/index.d.ts +0 -4
package/client/index.js +0 -5
package/client/types.d.ts +0 -102
package/createDecorator.d.ts +0 -4
package/generateStaticAPI.d.ts +0 -4
package/index.d.ts +0 -60
package/index.js +0 -20
package/types.d.ts +0 -191
package/types.js +0 -65
package/utils/setClientValidatorsForHandler.d.ts +0 -5
package/worker/index.d.ts +0 -3
package/worker/index.js +0 -7
package/worker/promisifyWorker.d.ts +0 -2
package/worker/worker.d.ts +0 -1
/package/{client → dist/client}/types.js +0 -0
/package/{utils → dist/utils}/reqMeta.js +0 -0
/package/{utils → dist/utils}/shim.d.ts +0 -0
/package/{utils → dist/utils}/shim.js +0 -0
/package/{worker → dist/worker}/types.js +0 -0

package/src/types.ts ADDED Viewed

@@ -0,0 +1,215 @@
+import type { NextRequest } from 'next/server';
+import type { StreamJSONResponse } from './StreamJSONResponse';
+import { StreamAsyncIterator } from './client/types';
+export type KnownAny = any; // eslint-disable-line @typescript-eslint/no-explicit-any
+export type StaticClass = Function; // eslint-disable-line @typescript-eslint/no-unsafe-function-type
+export type HandlerSchema = {
+  path: string;
+  httpMethod: HttpMethod;
+  validation?: { query?: KnownAny; body?: KnownAny };
+  custom?: Record<string, KnownAny>;
+};
+export type VovkControllerSchema = {
+  controllerName: string;
+  originalControllerName: string;
+  prefix?: string;
+  handlers: Record<string, HandlerSchema>;
+};
+export type VovkWorkerSchema = {
+  workerName: string;
+  originalWorkerName: string;
+  handlers: Record<
+    string,
+    {
+      isGenerator?: true;
+    }
+  >;
+};
+export type VovkSchema = {
+  emitSchema: boolean;
+  segmentName: string;
+  workers: Record<string, VovkWorkerSchema>;
+  controllers: Record<string, VovkControllerSchema>;
+};
+export type VovkErrorResponse = {
+  cause?: unknown;
+  statusCode: HttpStatus;
+  message: string;
+  isError: true;
+};
+export type VovkControllerInternal = {
+  _controllerName?: VovkControllerSchema['controllerName'];
+  _prefix?: VovkControllerSchema['prefix'];
+  _handlers: VovkControllerSchema['handlers'];
+  _activated?: true;
+  _onError?: (err: Error, req: VovkRequest) => void | Promise<void>;
+};
+export type VovkController = StaticClass &
+  VovkControllerInternal & {
+    [key: string]: unknown;
+  };
+export type VovkWorker = StaticClass & {
+  _handlers: VovkWorkerSchema['handlers'];
+  [key: string]: unknown;
+};
+export type DecoratorOptions = {
+  cors?: boolean;
+  headers?: Record<string, string>;
+};
+export type RouteHandler = ((
+  req: VovkRequest,
+  params: Record<string, string>
+) => Response | Promise<Response> | Iterable<unknown> | AsyncIterable<unknown>) & {
+  _options?: DecoratorOptions;
+};
+export interface VovkRequest<BODY = undefined, QUERY extends object | undefined = undefined>
+  extends Omit<NextRequest, 'json' | 'nextUrl'> {
+  json: () => Promise<BODY>;
+  nextUrl: Omit<NextRequest['nextUrl'], 'searchParams'> & {
+    searchParams: Omit<
+      NextRequest['nextUrl']['searchParams'],
+      'get' | 'getAll' | 'entries' | 'forEach' | 'keys' | 'values'
+    > & {
+      get: <KEY extends keyof QUERY>(key: KEY) => QUERY[KEY] extends readonly (infer ITEM)[] ? ITEM : QUERY[KEY];
+      getAll: <KEY extends keyof QUERY>(key: KEY) => QUERY[KEY] extends KnownAny[] ? QUERY[KEY] : QUERY[KEY][];
+      entries: () => IterableIterator<[keyof QUERY, QUERY[keyof QUERY]]>;
+      forEach: (
+        callbackfn: (
+          value: QUERY[keyof QUERY],
+          key: keyof QUERY,
+          searchParams: NextRequest['nextUrl']['searchParams'] // original searchParams
+        ) => void
+      ) => void;
+      keys: () => IterableIterator<keyof QUERY>;
+      values: () => IterableIterator<QUERY[keyof QUERY]>;
+      // TODO (?) append, delete, set
+    };
+  };
+  vovk: {
+    body: () => Promise<BODY>;
+    query: () => QUERY;
+    meta: <T = Record<KnownAny, KnownAny>>(meta?: T | null) => T;
+    form: <T = KnownAny>() => Promise<T>;
+  };
+}
+export type ControllerStaticMethod<
+  REQ extends VovkRequest<KnownAny, KnownAny> = VovkRequest<undefined, Record<string, string | string[]>>,
+  PARAMS extends { [key: string]: string } = KnownAny,
+> = ((req: REQ, params: PARAMS) => unknown) & {
+  _controller?: VovkController;
+};
+export type VovkControllerBody<T extends (...args: KnownAny) => KnownAny> = Awaited<
+  ReturnType<Parameters<T>[0]['vovk']['body']>
+>;
+export type VovkControllerQuery<T extends (...args: KnownAny) => KnownAny> = ReturnType<
+  Parameters<T>[0]['vovk']['query']
+>;
+export type VovkControllerParams<T extends (...args: KnownAny) => KnownAny> = Parameters<T>[1];
+export type VovkControllerYieldType<T extends (req: VovkRequest<KnownAny, KnownAny>) => KnownAny> = T extends (
+  ...args: KnownAny[]
+) => AsyncGenerator<infer Y, KnownAny, KnownAny>
+  ? Y
+  : T extends (...args: KnownAny[]) => Generator<infer Y, KnownAny, KnownAny>
+    ? Y
+    : T extends (...args: KnownAny[]) => Promise<StreamJSONResponse<infer Y>> | StreamJSONResponse<infer Y>
+      ? Y
+      : never;
+export type VovkBody<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['body'];
+export type VovkQuery<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['query'];
+export type VovkParams<T extends (...args: KnownAny[]) => unknown> = Parameters<T>[0]['params'];
+export type VovkYieldType<T extends (...args: KnownAny[]) => unknown> = T extends (
+  ...args: KnownAny[]
+) => Promise<StreamAsyncIterator<infer Y>>
+  ? Y
+  : never;
+export type VovkReturnType<T extends (...args: KnownAny) => unknown> = Awaited<ReturnType<T>>;
+export type StreamAbortMessage = {
+  isError: true;
+  reason: KnownAny;
+};
+export enum HttpMethod {
+  GET = 'GET',
+  POST = 'POST',
+  PUT = 'PUT',
+  PATCH = 'PATCH',
+  DELETE = 'DELETE',
+  HEAD = 'HEAD',
+  OPTIONS = 'OPTIONS',
+}
+export enum HttpStatus {
+  NULL = 0,
+  CONTINUE = 100,
+  SWITCHING_PROTOCOLS = 101,
+  PROCESSING = 102,
+  EARLYHINTS = 103,
+  OK = 200,
+  CREATED = 201,
+  ACCEPTED = 202,
+  NON_AUTHORITATIVE_INFORMATION = 203,
+  NO_CONTENT = 204,
+  RESET_CONTENT = 205,
+  PARTIAL_CONTENT = 206,
+  AMBIGUOUS = 300,
+  MOVED_PERMANENTLY = 301,
+  FOUND = 302,
+  SEE_OTHER = 303,
+  NOT_MODIFIED = 304,
+  TEMPORARY_REDIRECT = 307,
+  PERMANENT_REDIRECT = 308,
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  PAYMENT_REQUIRED = 402,
+  FORBIDDEN = 403,
+  NOT_FOUND = 404,
+  METHOD_NOT_ALLOWED = 405,
+  NOT_ACCEPTABLE = 406,
+  PROXY_AUTHENTICATION_REQUIRED = 407,
+  REQUEST_TIMEOUT = 408,
+  CONFLICT = 409,
+  GONE = 410,
+  LENGTH_REQUIRED = 411,
+  PRECONDITION_FAILED = 412,
+  PAYLOAD_TOO_LARGE = 413,
+  URI_TOO_LONG = 414,
+  UNSUPPORTED_MEDIA_TYPE = 415,
+  REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+  EXPECTATION_FAILED = 417,
+  I_AM_A_TEAPOT = 418,
+  MISDIRECTED = 421,
+  UNPROCESSABLE_ENTITY = 422,
+  FAILED_DEPENDENCY = 424,
+  PRECONDITION_REQUIRED = 428,
+  TOO_MANY_REQUESTS = 429,
+  INTERNAL_SERVER_ERROR = 500,
+  NOT_IMPLEMENTED = 501,
+  BAD_GATEWAY = 502,
+  SERVICE_UNAVAILABLE = 503,
+  GATEWAY_TIMEOUT = 504,
+  HTTP_VERSION_NOT_SUPPORTED = 505,
+}

package/src/utils/generateStaticAPI.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import type { VovkController, StaticClass } from '../types';
+export function generateStaticAPI(c: Record<string, StaticClass>, slug = 'vovk') {
+  const controllers = c as Record<string, VovkController>;
+  return [
+    { [slug]: ['_schema_'] },
+    ...Object.values(controllers)
+      .map((controller) => {
+        const handlers = controller._handlers;
+        const splitPrefix = controller._prefix?.split('/') ?? [];
+        return Object.values(handlers).map((handler) => {
+          return { [slug]: [...splitPrefix, ...handler.path.split('/')].filter(Boolean) };
+        });
+      })
+      .flat(),
+  ];
+}

package/src/utils/getSchema.ts ADDED Viewed

@@ -0,0 +1,48 @@
+import type { VovkSchema, VovkController, VovkWorker, StaticClass } from '../types';
+export default function getSchema(options: {
+  emitSchema?: boolean;
+  segmentName?: string;
+  controllers: Record<string, StaticClass>;
+  workers?: Record<string, StaticClass>;
+  exposeValidation?: boolean;
+}) {
+  const exposeValidation = options?.exposeValidation ?? true;
+  const emitSchema = options.emitSchema ?? true;
+  const schema: VovkSchema = {
+    emitSchema,
+    segmentName: options.segmentName ?? '',
+    controllers: {},
+    workers: {},
+  };
+  if (!emitSchema) return schema;
+  for (const [controllerName, controller] of Object.entries(options.controllers) as [string, VovkController][]) {
+    schema.controllers[controllerName] = {
+      controllerName: controllerName,
+      originalControllerName: controller.name,
+      prefix: controller._prefix ?? '',
+      handlers: {
+        ...(exposeValidation
+          ? controller._handlers
+          : Object.fromEntries(
+              Object.entries(controller._handlers ?? {}).map(([key, value]) => [
+                key,
+                { ...value, validation: undefined },
+              ])
+            )),
+      },
+    };
+  }
+  for (const [workerName, worker] of Object.entries(options.workers ?? {}) as [string, VovkWorker][]) {
+    schema.workers[workerName] = {
+      workerName,
+      originalWorkerName: worker.name,
+      handlers: { ...worker._handlers },
+    };
+  }
+  return schema;
+}

package/src/utils/reqForm.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import type { KnownAny, VovkRequest } from '../types';
+const formMap = new WeakMap();
+export default async function reqForm<T = KnownAny>(req: VovkRequest<KnownAny, KnownAny>): Promise<T> {
+  if (formMap.has(req)) {
+    return formMap.get(req) as T;
+  }
+  const body = await req.formData();
+  const formData = Object.fromEntries(body.entries()) as T;
+  formMap.set(req, formData);
+  return formData;
+}

package/src/utils/reqMeta.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import type { KnownAny, VovkRequest } from '../types';
+const metaMap = new WeakMap();
+export default function reqMeta<T = Record<KnownAny, KnownAny>>(
+  req: VovkRequest<KnownAny, KnownAny>,
+  meta?: T | null
+): T {
+  if (meta) {
+    metaMap.set(req, { ...metaMap.get(req), ...meta });
+  } else if (meta === null) {
+    metaMap.delete(req);
+  }
+  return (metaMap.get(req) ?? {}) as T;
+}

package/src/utils/reqQuery.ts ADDED Viewed

@@ -0,0 +1,26 @@
+import { ARRAY_QUERY_KEY } from '../client/createRPC';
+import type { KnownAny, VovkRequest } from '../types';
+export default function reqQuery<T extends object | undefined>(req: VovkRequest<KnownAny, T>): T {
+  type Query = NonNullable<T>;
+  const queryArr = (req.nextUrl.searchParams.get(ARRAY_QUERY_KEY as keyof T) as string | undefined)?.split(',') ?? null;
+  const entries = [...req.nextUrl.searchParams.entries()] as [string, string][];
+  const query = entries.reduce(
+    (acc, [key, value]) => {
+      if (key === ARRAY_QUERY_KEY) return acc;
+      if (queryArr?.includes(key)) {
+        if (!(key in acc)) {
+          acc[key] = [value];
+        } else {
+          (acc[key] as string[]).push(value);
+        }
+      } else {
+        acc[key] = value;
+      }
+      return acc;
+    },
+    {} as Record<string, string | string[]>
+  );
+  return query as Query;
+}

package/src/utils/setClientValidatorsForHandler.ts ADDED Viewed

@@ -0,0 +1,45 @@
+import type { KnownAny, VovkController } from '../types';
+export function setClientValidatorsForHandler(
+  h: (...args: KnownAny[]) => KnownAny,
+  validation: {
+    body: unknown;
+    query: unknown;
+  }
+) {
+  return new Promise<void>((resolve) => {
+    // the setTimeout is necessary to ensure that the _controller is already defined
+    setTimeout(() => {
+      const controller = (h as unknown as { _controller: VovkController })._controller;
+      if (!controller) {
+        throw new Error(
+          'Error setting client validators. Controller not found. Did you forget to use an HTTP decorator?'
+        );
+      }
+      const handlerName = Object.getOwnPropertyNames(controller).find(
+        (key) =>
+          (
+            controller[key] as {
+              _sourceMethod?: unknown;
+            }
+          )._sourceMethod === h
+      );
+      if (!handlerName) {
+        throw new Error('Error setting client validators. Handler not found.');
+      }
+      controller._handlers = {
+        ...controller._handlers,
+        [handlerName]: {
+          ...controller._handlers[handlerName],
+          validation,
+        },
+      };
+      resolve();
+    }, 0);
+  });
+}

package/src/utils/shim.ts ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

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

package/src/worker/types.ts ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 DELETED Viewed

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

package/client/defaultFetcher.d.ts DELETED Viewed

@@ -1,4 +0,0 @@
-import type { _VovkDefaultFetcherOptions as VovkDefaultFetcherOptions, _VovkClientFetcher as VovkClientFetcher } from './types';
-export declare const DEFAULT_ERROR_MESSAGE = "Unknown error at defaultFetcher";
-declare const defaultFetcher: VovkClientFetcher<VovkDefaultFetcherOptions>;
-export default defaultFetcher;