@orpc/shared 0.0.0-next.fd6982a → 0.0.0-next.fe5c63f

package/README.md

@@ -1,8 +1,3 @@
-> [!WARNING]
->
-> `@orpc/shared` is an internal dependency of oRPC packages. It does not follow semver and may change at any time without notice.
-> Please do not use it in your project.
-
 <div align="center">
   <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
 </div>
@@ -35,7 +30,7 @@
 - **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
 - **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
 - **📝 Contract-First Development**: Optionally define your API contract before implementation.
-- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte, Angular), Pinia Colada, and more.
 - **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
 - **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
 - **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
@@ -54,14 +49,12 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
 - [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
 - [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
-- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with NestJS.
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with [NestJS](https://nestjs.com/).
 - [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
-- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
-- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
-- [@orpc/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).
-- [@orpc/svelte-query](https://www.npmjs.com/package/@orpc/svelte-query): Integration with [Svelte Query](https://tanstack.com/query/latest/docs/framework/svelte/overview).
+- [@orpc/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.
 - [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
-- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/hey-api](https://www.npmjs.com/package/@orpc/hey-api): [Hey API](https://heyapi.dev/) integration.
 - [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
 - [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
 - [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { Promisable } from 'type-fest';
-export { IsEqual, IsNever, PartialDeep, Promisable } from 'type-fest';
+export { IsEqual, IsNever, JsonValue, PartialDeep, Promisable } from 'type-fest';
 export { group, guard, mapEntries, mapValues, omit } from 'radash';
 
 type MaybeOptionalOptions<TOptions> = Record<never, never> extends TOptions ? [options?: TOptions] : [options: TOptions];
@@ -8,17 +8,87 @@ declare function resolveMaybeOptionalOptions<T>(rest: MaybeOptionalOptions<T>):
 declare function toArray<T>(value: T): T extends readonly any[] ? T : Exclude<T, undefined | null>[];
 declare function splitInHalf<T>(arr: readonly T[]): [T[], T[]];
 
+/**
+ * Converts Request/Response/Blob/File/.. to a buffer (ArrayBuffer or Uint8Array).
+ *
+ * Prefers the newer `.bytes` method when available as it more efficient but not widely supported yet.
+ */
+declare function readAsBuffer(source: Pick<Blob, 'arrayBuffer' | 'bytes'>): Promise<ArrayBuffer | Uint8Array>;
+
 type AnyFunction = (...args: any[]) => any;
 declare function once<T extends () => any>(fn: T): () => ReturnType<T>;
 declare function sequential<A extends any[], R>(fn: (...args: A) => Promise<R>): (...args: A) => Promise<R>;
+/**
+ * Executes the callback function after the current call stack has been cleared.
+ */
+declare function defer(callback: () => void): void;
 
 type OmitChainMethodDeep<T extends object, K extends keyof any> = {
     [P in keyof Omit<T, K>]: T[P] extends AnyFunction ? ((...args: Parameters<T[P]>) => OmitChainMethodDeep<ReturnType<T[P]>, K>) : T[P];
 };
 
+interface EventPublisherOptions {
+    /**
+     * Maximum number of events to buffer for async iterator subscribers.
+     *
+     * If the buffer exceeds this limit, the oldest event is dropped.
+     * This prevents unbounded memory growth if consumers process events slowly.
+     *
+     * Set to:
+     * - `0`: Disable buffering. Events must be consumed before the next one arrives.
+     * - `1`: Only keep the latest event. Useful for real-time updates where only the most recent value matters.
+     * - `Infinity`: Keep all events. Ensures no data loss, but may lead to high memory usage.
+     *
+     * @default 100
+     */
+    maxBufferedEvents?: number;
+}
+interface EventPublisherSubscribeIteratorOptions extends EventPublisherOptions {
+    /**
+     * Aborts the async iterator. Throws if aborted before or during pulling.
+     */
+    signal?: AbortSignal;
+}
+declare class EventPublisher<T extends Record<PropertyKey, any>> {
+    #private;
+    constructor(options?: EventPublisherOptions);
+    get size(): number;
+    /**
+     * Emits an event and delivers the payload to all subscribed listeners.
+     */
+    publish<K extends keyof T>(event: K, payload: T[K]): void;
+    /**
+     * Subscribes to a specific event using a callback function.
+     * Returns an unsubscribe function to remove the listener.
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = publisher.subscribe('event', (payload) => {
+     *   console.log(payload)
+     * })
+     *
+     * // Later
+     * unsubscribe()
+     * ```
+     */
+    subscribe<K extends keyof T>(event: K, listener: (payload: T[K]) => void): () => void;
+    /**
+     * Subscribes to a specific event using an async iterator.
+     * Useful for `for await...of` loops with optional buffering and abort support.
+     *
+     * @example
+     * ```ts
+     * for await (const payload of publisher.subscribe('event', { signal })) {
+     *   console.log(payload)
+     * }
+     * ```
+     */
+    subscribe<K extends keyof T>(event: K, options?: EventPublisherSubscribeIteratorOptions): AsyncGenerator<T[K]> & AsyncIteratorObject<T[K]>;
+}
+
 declare class SequentialIdGenerator {
-    private nextId;
-    generate(): number;
+    private index;
+    generate(): string;
 }
 
 type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
@@ -72,13 +142,34 @@ declare function onFinish<T, TOptions extends {
 declare function intercept<TOptions extends InterceptableOptions, TResult>(interceptors: Interceptor<TOptions, TResult>[], options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => TResult>): TResult;
 
 declare function isAsyncIteratorObject(maybe: unknown): maybe is AsyncIteratorObject<any, any, any>;
-interface CreateAsyncIteratorObjectCleanupFn {
+interface AsyncIteratorClassNextFn<T, TReturn> {
+    (): Promise<IteratorResult<T, TReturn>>;
+}
+interface AsyncIteratorClassCleanupFn {
     (reason: 'return' | 'throw' | 'next' | 'dispose'): Promise<void>;
 }
-declare function createAsyncIteratorObject<T, TReturn, TNext>(next: () => Promise<IteratorResult<T, TReturn>>, cleanup: CreateAsyncIteratorObjectCleanupFn): AsyncIteratorObject<T, TReturn, TNext> & AsyncGenerator<T, TReturn, TNext>;
+declare const fallbackAsyncDisposeSymbol: unique symbol;
+declare const asyncDisposeSymbol: typeof Symbol extends {
+    asyncDispose: infer T;
+} ? T : typeof fallbackAsyncDisposeSymbol;
+declare class AsyncIteratorClass<T, TReturn = unknown, TNext = unknown> implements AsyncIteratorObject<T, TReturn, TNext>, AsyncGenerator<T, TReturn, TNext> {
+    #private;
+    constructor(next: AsyncIteratorClassNextFn<T, TReturn>, cleanup: AsyncIteratorClassCleanupFn);
+    next(): Promise<IteratorResult<T, TReturn>>;
+    return(value?: any): Promise<IteratorResult<T, TReturn>>;
+    throw(err: any): Promise<IteratorResult<T, TReturn>>;
+    /**
+     * asyncDispose symbol only available in esnext, we should fallback to Symbol.for('asyncDispose')
+     */
+    [asyncDisposeSymbol](): Promise<void>;
+    [Symbol.asyncIterator](): this;
+}
+declare function replicateAsyncIterator<T, TReturn, TNext>(source: AsyncIterator<T, TReturn, TNext>, count: number): (AsyncIteratorClass<T, TReturn, TNext>)[];
 
 declare function parseEmptyableJSON(text: string | null | undefined): unknown;
-declare function stringifyJSON<T>(value: T): undefined extends T ? undefined | string : string;
+declare function stringifyJSON<T>(value: T | {
+    toJSON(): T;
+}): undefined extends T ? undefined | string : string;
 
 type Segment = string | number;
 declare function findDeepMatches(check: (value: unknown) => boolean, payload: unknown, segments?: Segment[], maps?: Segment[][], values?: unknown[]): {
@@ -94,28 +185,34 @@ declare function isObject(value: unknown): value is Record<PropertyKey, unknown>
  */
 declare function isTypescriptObject(value: unknown): value is object & Record<PropertyKey, unknown>;
 declare function clone<T>(value: T): T;
-declare function get(object: object, path: readonly string[]): unknown;
+declare function get(object: unknown, path: readonly string[]): unknown;
 declare function isPropertyKey(value: unknown): value is PropertyKey;
+declare const NullProtoObj: ({
+    new <T extends Record<PropertyKey, unknown>>(): T;
+});
 
 interface AsyncIdQueueCloseOptions {
-    id?: number;
-    reason?: Error;
+    id?: string;
+    reason?: unknown;
 }
 declare class AsyncIdQueue<T> {
     private readonly openIds;
     private readonly items;
     private readonly pendingPulls;
     get length(): number;
-    open(id: number): void;
-    isOpen(id: number): boolean;
-    push(id: number, item: T): void;
-    pull(id: number): Promise<T>;
+    open(id: string): void;
+    isOpen(id: string): boolean;
+    push(id: string, item: T): void;
+    pull(id: string): Promise<T>;
     close({ id, reason }?: AsyncIdQueueCloseOptions): void;
-    assertOpen(id: number): void;
+    assertOpen(id: string): void;
 }
 
+declare function streamToAsyncIteratorClass<T>(stream: ReadableStream<T>): AsyncIteratorClass<T>;
+declare function asyncIteratorToStream<T>(iterator: AsyncIterator<T>): ReadableStream<T>;
+
 type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => T);
 declare function value<T, TArgs extends any[]>(value: Value<T, TArgs>, ...args: NoInfer<TArgs>): T extends Value<infer U, any> ? U : never;
 
-export { AsyncIdQueue, SequentialIdGenerator, clone, createAsyncIteratorObject, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, resolveMaybeOptionalOptions, sequential, splitInHalf, stringifyJSON, toArray, value };
-export type { AnyFunction, AsyncIdQueueCloseOptions, CreateAsyncIteratorObjectCleanupFn, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OmitChainMethodDeep, OnFinishState, PromiseWithError, Registry, Segment, SetOptional, ThrowableError, Value };
+export { AsyncIdQueue, AsyncIteratorClass, EventPublisher, NullProtoObj, SequentialIdGenerator, asyncIteratorToStream, clone, defer, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, readAsBuffer, replicateAsyncIterator, resolveMaybeOptionalOptions, sequential, splitInHalf, streamToAsyncIteratorClass, stringifyJSON, toArray, value };
+export type { AnyFunction, AsyncIdQueueCloseOptions, AsyncIteratorClassCleanupFn, AsyncIteratorClassNextFn, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OmitChainMethodDeep, OnFinishState, PromiseWithError, Registry, Segment, SetOptional, ThrowableError, Value };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Promisable } from 'type-fest';
-export { IsEqual, IsNever, PartialDeep, Promisable } from 'type-fest';
+export { IsEqual, IsNever, JsonValue, PartialDeep, Promisable } from 'type-fest';
 export { group, guard, mapEntries, mapValues, omit } from 'radash';
 
 type MaybeOptionalOptions<TOptions> = Record<never, never> extends TOptions ? [options?: TOptions] : [options: TOptions];
@@ -8,17 +8,87 @@ declare function resolveMaybeOptionalOptions<T>(rest: MaybeOptionalOptions<T>):
 declare function toArray<T>(value: T): T extends readonly any[] ? T : Exclude<T, undefined | null>[];
 declare function splitInHalf<T>(arr: readonly T[]): [T[], T[]];
 
+/**
+ * Converts Request/Response/Blob/File/.. to a buffer (ArrayBuffer or Uint8Array).
+ *
+ * Prefers the newer `.bytes` method when available as it more efficient but not widely supported yet.
+ */
+declare function readAsBuffer(source: Pick<Blob, 'arrayBuffer' | 'bytes'>): Promise<ArrayBuffer | Uint8Array>;
+
 type AnyFunction = (...args: any[]) => any;
 declare function once<T extends () => any>(fn: T): () => ReturnType<T>;
 declare function sequential<A extends any[], R>(fn: (...args: A) => Promise<R>): (...args: A) => Promise<R>;
+/**
+ * Executes the callback function after the current call stack has been cleared.
+ */
+declare function defer(callback: () => void): void;
 
 type OmitChainMethodDeep<T extends object, K extends keyof any> = {
     [P in keyof Omit<T, K>]: T[P] extends AnyFunction ? ((...args: Parameters<T[P]>) => OmitChainMethodDeep<ReturnType<T[P]>, K>) : T[P];
 };
 
+interface EventPublisherOptions {
+    /**
+     * Maximum number of events to buffer for async iterator subscribers.
+     *
+     * If the buffer exceeds this limit, the oldest event is dropped.
+     * This prevents unbounded memory growth if consumers process events slowly.
+     *
+     * Set to:
+     * - `0`: Disable buffering. Events must be consumed before the next one arrives.
+     * - `1`: Only keep the latest event. Useful for real-time updates where only the most recent value matters.
+     * - `Infinity`: Keep all events. Ensures no data loss, but may lead to high memory usage.
+     *
+     * @default 100
+     */
+    maxBufferedEvents?: number;
+}
+interface EventPublisherSubscribeIteratorOptions extends EventPublisherOptions {
+    /**
+     * Aborts the async iterator. Throws if aborted before or during pulling.
+     */
+    signal?: AbortSignal;
+}
+declare class EventPublisher<T extends Record<PropertyKey, any>> {
+    #private;
+    constructor(options?: EventPublisherOptions);
+    get size(): number;
+    /**
+     * Emits an event and delivers the payload to all subscribed listeners.
+     */
+    publish<K extends keyof T>(event: K, payload: T[K]): void;
+    /**
+     * Subscribes to a specific event using a callback function.
+     * Returns an unsubscribe function to remove the listener.
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = publisher.subscribe('event', (payload) => {
+     *   console.log(payload)
+     * })
+     *
+     * // Later
+     * unsubscribe()
+     * ```
+     */
+    subscribe<K extends keyof T>(event: K, listener: (payload: T[K]) => void): () => void;
+    /**
+     * Subscribes to a specific event using an async iterator.
+     * Useful for `for await...of` loops with optional buffering and abort support.
+     *
+     * @example
+     * ```ts
+     * for await (const payload of publisher.subscribe('event', { signal })) {
+     *   console.log(payload)
+     * }
+     * ```
+     */
+    subscribe<K extends keyof T>(event: K, options?: EventPublisherSubscribeIteratorOptions): AsyncGenerator<T[K]> & AsyncIteratorObject<T[K]>;
+}
+
 declare class SequentialIdGenerator {
-    private nextId;
-    generate(): number;
+    private index;
+    generate(): string;
 }
 
 type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
@@ -72,13 +142,34 @@ declare function onFinish<T, TOptions extends {
 declare function intercept<TOptions extends InterceptableOptions, TResult>(interceptors: Interceptor<TOptions, TResult>[], options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => TResult>): TResult;
 
 declare function isAsyncIteratorObject(maybe: unknown): maybe is AsyncIteratorObject<any, any, any>;
-interface CreateAsyncIteratorObjectCleanupFn {
+interface AsyncIteratorClassNextFn<T, TReturn> {
+    (): Promise<IteratorResult<T, TReturn>>;
+}
+interface AsyncIteratorClassCleanupFn {
     (reason: 'return' | 'throw' | 'next' | 'dispose'): Promise<void>;
 }
-declare function createAsyncIteratorObject<T, TReturn, TNext>(next: () => Promise<IteratorResult<T, TReturn>>, cleanup: CreateAsyncIteratorObjectCleanupFn): AsyncIteratorObject<T, TReturn, TNext> & AsyncGenerator<T, TReturn, TNext>;
+declare const fallbackAsyncDisposeSymbol: unique symbol;
+declare const asyncDisposeSymbol: typeof Symbol extends {
+    asyncDispose: infer T;
+} ? T : typeof fallbackAsyncDisposeSymbol;
+declare class AsyncIteratorClass<T, TReturn = unknown, TNext = unknown> implements AsyncIteratorObject<T, TReturn, TNext>, AsyncGenerator<T, TReturn, TNext> {
+    #private;
+    constructor(next: AsyncIteratorClassNextFn<T, TReturn>, cleanup: AsyncIteratorClassCleanupFn);
+    next(): Promise<IteratorResult<T, TReturn>>;
+    return(value?: any): Promise<IteratorResult<T, TReturn>>;
+    throw(err: any): Promise<IteratorResult<T, TReturn>>;
+    /**
+     * asyncDispose symbol only available in esnext, we should fallback to Symbol.for('asyncDispose')
+     */
+    [asyncDisposeSymbol](): Promise<void>;
+    [Symbol.asyncIterator](): this;
+}
+declare function replicateAsyncIterator<T, TReturn, TNext>(source: AsyncIterator<T, TReturn, TNext>, count: number): (AsyncIteratorClass<T, TReturn, TNext>)[];
 
 declare function parseEmptyableJSON(text: string | null | undefined): unknown;
-declare function stringifyJSON<T>(value: T): undefined extends T ? undefined | string : string;
+declare function stringifyJSON<T>(value: T | {
+    toJSON(): T;
+}): undefined extends T ? undefined | string : string;
 
 type Segment = string | number;
 declare function findDeepMatches(check: (value: unknown) => boolean, payload: unknown, segments?: Segment[], maps?: Segment[][], values?: unknown[]): {
@@ -94,28 +185,34 @@ declare function isObject(value: unknown): value is Record<PropertyKey, unknown>
  */
 declare function isTypescriptObject(value: unknown): value is object & Record<PropertyKey, unknown>;
 declare function clone<T>(value: T): T;
-declare function get(object: object, path: readonly string[]): unknown;
+declare function get(object: unknown, path: readonly string[]): unknown;
 declare function isPropertyKey(value: unknown): value is PropertyKey;
+declare const NullProtoObj: ({
+    new <T extends Record<PropertyKey, unknown>>(): T;
+});
 
 interface AsyncIdQueueCloseOptions {
-    id?: number;
-    reason?: Error;
+    id?: string;
+    reason?: unknown;
 }
 declare class AsyncIdQueue<T> {
     private readonly openIds;
     private readonly items;
     private readonly pendingPulls;
     get length(): number;
-    open(id: number): void;
-    isOpen(id: number): boolean;
-    push(id: number, item: T): void;
-    pull(id: number): Promise<T>;
+    open(id: string): void;
+    isOpen(id: string): boolean;
+    push(id: string, item: T): void;
+    pull(id: string): Promise<T>;
     close({ id, reason }?: AsyncIdQueueCloseOptions): void;
-    assertOpen(id: number): void;
+    assertOpen(id: string): void;
 }
 
+declare function streamToAsyncIteratorClass<T>(stream: ReadableStream<T>): AsyncIteratorClass<T>;
+declare function asyncIteratorToStream<T>(iterator: AsyncIterator<T>): ReadableStream<T>;
+
 type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => T);
 declare function value<T, TArgs extends any[]>(value: Value<T, TArgs>, ...args: NoInfer<TArgs>): T extends Value<infer U, any> ? U : never;
 
-export { AsyncIdQueue, SequentialIdGenerator, clone, createAsyncIteratorObject, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, resolveMaybeOptionalOptions, sequential, splitInHalf, stringifyJSON, toArray, value };
-export type { AnyFunction, AsyncIdQueueCloseOptions, CreateAsyncIteratorObjectCleanupFn, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OmitChainMethodDeep, OnFinishState, PromiseWithError, Registry, Segment, SetOptional, ThrowableError, Value };
+export { AsyncIdQueue, AsyncIteratorClass, EventPublisher, NullProtoObj, SequentialIdGenerator, asyncIteratorToStream, clone, defer, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, readAsBuffer, replicateAsyncIterator, resolveMaybeOptionalOptions, sequential, splitInHalf, streamToAsyncIteratorClass, stringifyJSON, toArray, value };
+export type { AnyFunction, AsyncIdQueueCloseOptions, AsyncIteratorClassCleanupFn, AsyncIteratorClassNextFn, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, InterceptableOptions, Interceptor, InterceptorOptions, IntersectPick, MaybeOptionalOptions, OmitChainMethodDeep, OnFinishState, PromiseWithError, Registry, Segment, SetOptional, ThrowableError, Value };

package/dist/index.mjs

@@ -12,6 +12,13 @@ function splitInHalf(arr) {
   return [arr.slice(0, half), arr.slice(half)];
 }
 
+function readAsBuffer(source) {
+  if (typeof source.bytes === "function") {
+    return source.bytes();
+  }
+  return source.arrayBuffer();
+}
+
 function once(fn) {
   let cached;
   return () => {
@@ -32,15 +39,291 @@ function sequential(fn) {
     });
   };
 }
+function defer(callback) {
+  if (typeof setTimeout === "function") {
+    setTimeout(callback, 0);
+  } else {
+    Promise.resolve().then(() => Promise.resolve().then(() => Promise.resolve().then(callback)));
+  }
+}
+
+class AsyncIdQueue {
+  openIds = /* @__PURE__ */ new Set();
+  items = /* @__PURE__ */ new Map();
+  pendingPulls = /* @__PURE__ */ new Map();
+  get length() {
+    return this.openIds.size;
+  }
+  open(id) {
+    this.openIds.add(id);
+  }
+  isOpen(id) {
+    return this.openIds.has(id);
+  }
+  push(id, item) {
+    this.assertOpen(id);
+    const pending = this.pendingPulls.get(id);
+    if (pending?.length) {
+      pending.shift()[0](item);
+      if (pending.length === 0) {
+        this.pendingPulls.delete(id);
+      }
+    } else {
+      const items = this.items.get(id);
+      if (items) {
+        items.push(item);
+      } else {
+        this.items.set(id, [item]);
+      }
+    }
+  }
+  async pull(id) {
+    this.assertOpen(id);
+    const items = this.items.get(id);
+    if (items?.length) {
+      const item = items.shift();
+      if (items.length === 0) {
+        this.items.delete(id);
+      }
+      return item;
+    }
+    return new Promise((resolve, reject) => {
+      const waitingPulls = this.pendingPulls.get(id);
+      const pending = [resolve, reject];
+      if (waitingPulls) {
+        waitingPulls.push(pending);
+      } else {
+        this.pendingPulls.set(id, [pending]);
+      }
+    });
+  }
+  close({ id, reason } = {}) {
+    if (id === void 0) {
+      this.pendingPulls.forEach((pendingPulls, id2) => {
+        pendingPulls.forEach(([, reject]) => {
+          reject(reason ?? new Error(`[AsyncIdQueue] Queue[${id2}] was closed or aborted while waiting for pulling.`));
+        });
+      });
+      this.pendingPulls.clear();
+      this.openIds.clear();
+      this.items.clear();
+      return;
+    }
+    this.pendingPulls.get(id)?.forEach(([, reject]) => {
+      reject(reason ?? new Error(`[AsyncIdQueue] Queue[${id}] was closed or aborted while waiting for pulling.`));
+    });
+    this.pendingPulls.delete(id);
+    this.openIds.delete(id);
+    this.items.delete(id);
+  }
+  assertOpen(id) {
+    if (!this.isOpen(id)) {
+      throw new Error(`[AsyncIdQueue] Cannot access queue[${id}] because it is not open or aborted.`);
+    }
+  }
+}
+
+function isAsyncIteratorObject(maybe) {
+  if (!maybe || typeof maybe !== "object") {
+    return false;
+  }
+  return "next" in maybe && typeof maybe.next === "function" && Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
+}
+const fallbackAsyncDisposeSymbol = Symbol.for("asyncDispose");
+const asyncDisposeSymbol = Symbol.asyncDispose ?? fallbackAsyncDisposeSymbol;
+class AsyncIteratorClass {
+  #isDone = false;
+  #isExecuteComplete = false;
+  #cleanup;
+  #next;
+  constructor(next, cleanup) {
+    this.#cleanup = cleanup;
+    this.#next = sequential(async () => {
+      if (this.#isDone) {
+        return { done: true, value: void 0 };
+      }
+      try {
+        const result = await next();
+        if (result.done) {
+          this.#isDone = true;
+        }
+        return result;
+      } catch (err) {
+        this.#isDone = true;
+        throw err;
+      } finally {
+        if (this.#isDone && !this.#isExecuteComplete) {
+          this.#isExecuteComplete = true;
+          await this.#cleanup("next");
+        }
+      }
+    });
+  }
+  next() {
+    return this.#next();
+  }
+  async return(value) {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("return");
+    }
+    return { done: true, value };
+  }
+  async throw(err) {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("throw");
+    }
+    throw err;
+  }
+  /**
+   * asyncDispose symbol only available in esnext, we should fallback to Symbol.for('asyncDispose')
+   */
+  async [asyncDisposeSymbol]() {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("dispose");
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+}
+function replicateAsyncIterator(source, count) {
+  const queue = new AsyncIdQueue();
+  const replicated = [];
+  let error;
+  const start = once(async () => {
+    try {
+      while (true) {
+        const item = await source.next();
+        for (let id = 0; id < count; id++) {
+          if (queue.isOpen(id.toString())) {
+            queue.push(id.toString(), item);
+          }
+        }
+        if (item.done) {
+          break;
+        }
+      }
+    } catch (e) {
+      error = { value: e };
+    }
+  });
+  for (let id = 0; id < count; id++) {
+    queue.open(id.toString());
+    replicated.push(new AsyncIteratorClass(
+      () => {
+        start();
+        return new Promise((resolve, reject) => {
+          queue.pull(id.toString()).then(resolve).catch(reject);
+          defer(() => {
+            if (error) {
+              reject(error.value);
+            }
+          });
+        });
+      },
+      async (reason) => {
+        queue.close({ id: id.toString() });
+        if (reason !== "next") {
+          if (replicated.every((_, id2) => !queue.isOpen(id2.toString()))) {
+            await source?.return?.();
+          }
+        }
+      }
+    ));
+  }
+  return replicated;
+}
+
+class EventPublisher {
+  #listenersMap = /* @__PURE__ */ new Map();
+  #maxBufferedEvents;
+  constructor(options = {}) {
+    this.#maxBufferedEvents = options.maxBufferedEvents ?? 100;
+  }
+  get size() {
+    return this.#listenersMap.size;
+  }
+  /**
+   * Emits an event and delivers the payload to all subscribed listeners.
+   */
+  publish(event, payload) {
+    const listeners = this.#listenersMap.get(event);
+    if (!listeners) {
+      return;
+    }
+    for (const listener of listeners) {
+      listener(payload);
+    }
+  }
+  subscribe(event, listenerOrOptions) {
+    if (typeof listenerOrOptions === "function") {
+      let listeners = this.#listenersMap.get(event);
+      if (!listeners) {
+        this.#listenersMap.set(event, listeners = /* @__PURE__ */ new Set());
+      }
+      listeners.add(listenerOrOptions);
+      return () => {
+        listeners.delete(listenerOrOptions);
+        if (listeners.size === 0) {
+          this.#listenersMap.delete(event);
+        }
+      };
+    }
+    const signal = listenerOrOptions?.signal;
+    const maxBufferedEvents = listenerOrOptions?.maxBufferedEvents ?? this.#maxBufferedEvents;
+    signal?.throwIfAborted();
+    const bufferedEvents = [];
+    const pullResolvers = [];
+    const unsubscribe = this.subscribe(event, (payload) => {
+      const resolver = pullResolvers.shift();
+      if (resolver) {
+        resolver[0]({ done: false, value: payload });
+      } else {
+        bufferedEvents.push(payload);
+        if (bufferedEvents.length > maxBufferedEvents) {
+          bufferedEvents.shift();
+        }
+      }
+    });
+    const abortListener = (event2) => {
+      unsubscribe();
+      pullResolvers.forEach((resolver) => resolver[1](event2.target.reason));
+      pullResolvers.length = 0;
+      bufferedEvents.length = 0;
+    };
+    signal?.addEventListener("abort", abortListener, { once: true });
+    return new AsyncIteratorClass(async () => {
+      if (signal?.aborted) {
+        throw signal.reason;
+      }
+      if (bufferedEvents.length > 0) {
+        return { done: false, value: bufferedEvents.shift() };
+      }
+      return new Promise((resolve, reject) => {
+        pullResolvers.push([resolve, reject]);
+      });
+    }, async () => {
+      unsubscribe();
+      signal?.removeEventListener("abort", abortListener);
+      pullResolvers.forEach((resolver) => resolver[0]({ done: true, value: void 0 }));
+      pullResolvers.length = 0;
+      bufferedEvents.length = 0;
+    });
+  }
+}
 
 class SequentialIdGenerator {
-  nextId = 0;
+  index = BigInt(0);
   generate() {
-    if (this.nextId === Number.MAX_SAFE_INTEGER) {
-      this.nextId = 0;
-      return Number.MAX_SAFE_INTEGER;
-    }
-    return this.nextId++;
+    const id = this.index.toString(32);
+    this.index++;
+    return id;
   }
 }
 
@@ -96,69 +379,6 @@ function intercept(interceptors, options, main) {
   return next(options, 0);
 }
 
-function isAsyncIteratorObject(maybe) {
-  if (!maybe || typeof maybe !== "object") {
-    return false;
-  }
-  return Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
-}
-function createAsyncIteratorObject(next, cleanup) {
-  let isExecuteComplete = false;
-  let isDone = false;
-  const iterator = {
-    next: sequential(async () => {
-      if (isDone) {
-        return { done: true, value: void 0 };
-      }
-      try {
-        const result = await next();
-        if (result.done) {
-          isDone = true;
-        }
-        return result;
-      } catch (err) {
-        isDone = true;
-        throw err;
-      } finally {
-        if (isDone && !isExecuteComplete) {
-          isExecuteComplete = true;
-          await cleanup("next");
-        }
-      }
-    }),
-    async return(value) {
-      isDone = true;
-      if (!isExecuteComplete) {
-        isExecuteComplete = true;
-        await cleanup("return");
-      }
-      return { done: true, value };
-    },
-    async throw(err) {
-      isDone = true;
-      if (!isExecuteComplete) {
-        isExecuteComplete = true;
-        await cleanup("throw");
-      }
-      throw err;
-    },
-    /**
-     * asyncDispose symbol only available in esnext, we should fallback to Symbol.for('asyncDispose')
-     */
-    async [Symbol.asyncDispose ?? Symbol.for("asyncDispose")]() {
-      isDone = true;
-      if (!isExecuteComplete) {
-        isExecuteComplete = true;
-        await cleanup("dispose");
-      }
-    },
-    [Symbol.asyncIterator]() {
-      return iterator;
-    }
-  };
-  return iterator;
-}
-
 function parseEmptyableJSON(text) {
   if (!text) {
     return void 0;
@@ -221,81 +441,39 @@ function isPropertyKey(value) {
   const type = typeof value;
   return type === "string" || type === "number" || type === "symbol";
 }
+const NullProtoObj = /* @__PURE__ */ (() => {
+  const e = function() {
+  };
+  e.prototype = /* @__PURE__ */ Object.create(null);
+  Object.freeze(e.prototype);
+  return e;
+})();
 
-class AsyncIdQueue {
-  openIds = /* @__PURE__ */ new Set();
-  items = /* @__PURE__ */ new Map();
-  pendingPulls = /* @__PURE__ */ new Map();
-  get length() {
-    return this.openIds.size;
-  }
-  open(id) {
-    this.openIds.add(id);
-  }
-  isOpen(id) {
-    return this.openIds.has(id);
-  }
-  push(id, item) {
-    this.assertOpen(id);
-    const pending = this.pendingPulls.get(id);
-    if (pending?.length) {
-      pending.shift()[0](item);
-      if (pending.length === 0) {
-        this.pendingPulls.delete(id);
-      }
-    } else {
-      const items = this.items.get(id);
-      if (items) {
-        items.push(item);
-      } else {
-        this.items.set(id, [item]);
-      }
-    }
-  }
-  async pull(id) {
-    this.assertOpen(id);
-    const items = this.items.get(id);
-    if (items?.length) {
-      const item = items.shift();
-      if (items.length === 0) {
-        this.items.delete(id);
-      }
-      return item;
+function streamToAsyncIteratorClass(stream) {
+  const reader = stream.getReader();
+  return new AsyncIteratorClass(
+    async () => {
+      return reader.read();
+    },
+    async () => {
+      await reader.cancel();
     }
-    return new Promise((resolve, reject) => {
-      const waitingPulls = this.pendingPulls.get(id);
-      const pending = [resolve, reject];
-      if (waitingPulls) {
-        waitingPulls.push(pending);
+  );
+}
+function asyncIteratorToStream(iterator) {
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await iterator.next();
+      if (done) {
+        controller.close();
       } else {
-        this.pendingPulls.set(id, [pending]);
+        controller.enqueue(value);
       }
-    });
-  }
-  close({ id, reason } = {}) {
-    if (id === void 0) {
-      this.pendingPulls.forEach((pendingPulls, id2) => {
-        pendingPulls.forEach(([, reject]) => {
-          reject(reason ?? new Error(`[AsyncIdQueue] Queue[${id2}] was closed or aborted while waiting for pulling.`));
-        });
-      });
-      this.pendingPulls.clear();
-      this.openIds.clear();
-      this.items.clear();
-      return;
-    }
-    this.pendingPulls.get(id)?.forEach(([, reject]) => {
-      reject(reason ?? new Error(`[AsyncIdQueue] Queue[${id}] was closed or aborted while waiting for pulling.`));
-    });
-    this.pendingPulls.delete(id);
-    this.openIds.delete(id);
-    this.items.delete(id);
-  }
-  assertOpen(id) {
-    if (!this.isOpen(id)) {
-      throw new Error(`[AsyncIdQueue] Cannot access queue[${id}] because it is not open or aborted.`);
+    },
+    async cancel() {
+      await iterator.return?.();
     }
-  }
+  });
 }
 
 function value(value2, ...args) {
@@ -305,4 +483,4 @@ function value(value2, ...args) {
   return value2;
 }
 
-export { AsyncIdQueue, SequentialIdGenerator, clone, createAsyncIteratorObject, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, resolveMaybeOptionalOptions, sequential, splitInHalf, stringifyJSON, toArray, value };
+export { AsyncIdQueue, AsyncIteratorClass, EventPublisher, NullProtoObj, SequentialIdGenerator, asyncIteratorToStream, clone, defer, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, readAsBuffer, replicateAsyncIterator, resolveMaybeOptionalOptions, sequential, splitInHalf, streamToAsyncIteratorClass, stringifyJSON, toArray, value };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/shared",
   "type": "module",
-  "version": "0.0.0-next.fd6982a",
+  "version": "0.0.0-next.fe5c63f",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -24,9 +24,14 @@
     "dist"
   ],
   "dependencies": {
-    "radash": "^12.1.0",
+    "radash": "^12.1.1",
     "type-fest": "^4.39.1"
   },
+  "devDependencies": {
+    "arktype": "2.1.20",
+    "valibot": "^1.1.0",
+    "zod": "^4.0.5"
+  },
   "scripts": {
     "build": "unbuild",
     "build:watch": "pnpm run build --watch",