@orpc/shared 0.0.0-next.f17a1a0 → 0.0.0-next.f356b86

package/README.md

@@ -1,5 +1,10 @@
+> [!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 />
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
 </div>
 
 <h1></h1>
@@ -21,28 +26,24 @@
 
 <h3 align="center">Typesafe APIs Made Simple 🪄</h3>
 
-**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards
 
 ---
 
 ## Highlights
 
-- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
-- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
-- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
-- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
-- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
-- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
-- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
-- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
-- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
-- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
-- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
-- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
-- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
-- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
-- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
-- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+- **🔗 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, 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.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
+- **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
+- **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
+- **🛡️ Reliability**: Well-tested, TypeScript-based, production-ready, and MIT licensed.
 
 ## Documentation
 
@@ -53,16 +54,28 @@ 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/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/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/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/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/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/).
 
 ## `@orpc/shared`
 
 Provides shared utilities for oRPC packages.
 
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg'/>
+  </a>
+</p>
+
 ## License
 
 Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/index.d.mts

@@ -0,0 +1,215 @@
+import { 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];
+declare function resolveMaybeOptionalOptions<T>(rest: MaybeOptionalOptions<T>): 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 index;
+    generate(): string;
+}
+
+type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type IntersectPick<T, U> = Pick<T, keyof T & keyof U>;
+type PromiseWithError<T, TError> = Promise<T> & {
+    __error?: {
+        type: TError;
+    };
+};
+/**
+ * The place where you can config the orpc types.
+ *
+ * - `throwableError` the error type that represent throwable errors should be `Error` or `null | undefined | {}` if you want more strict.
+ */
+interface Registry {
+}
+type ThrowableError = Registry extends {
+    throwableError: infer T;
+} ? T : Error;
+
+type InterceptableOptions = Record<string, any>;
+type InterceptorOptions<TOptions extends InterceptableOptions, TResult> = Omit<TOptions, 'next'> & {
+    next(options?: TOptions): TResult;
+};
+type Interceptor<TOptions extends InterceptableOptions, TResult> = (options: InterceptorOptions<TOptions, TResult>) => TResult;
+/**
+ * Can used for interceptors or middlewares
+ */
+declare function onStart<T, TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
+/**
+ * Can used for interceptors or middlewares
+ */
+declare function onSuccess<T, TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(result: Awaited<ReturnType<TOptions['next']>>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
+/**
+ * Can used for interceptors or middlewares
+ */
+declare function onError<T, TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(error: ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
+type OnFinishState<TResult, TError> = [error: TError, data: undefined, isSuccess: false] | [error: null, data: TResult, isSuccess: true];
+/**
+ * Can used for interceptors or middlewares
+ */
+declare function onFinish<T, TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(state: OnFinishState<Awaited<ReturnType<TOptions['next']>>, ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
+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 AsyncIteratorClassNextFn<T, TReturn> {
+    (): Promise<IteratorResult<T, TReturn>>;
+}
+interface AsyncIteratorClassCleanupFn {
+    (reason: 'return' | 'throw' | 'next' | 'dispose'): Promise<void>;
+}
+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 | {
+    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[]): {
+    maps: Segment[][];
+    values: unknown[];
+};
+/**
+ * Check if the value is an object even it created by `Object.create(null)` or more tricky way.
+ */
+declare function isObject(value: unknown): value is Record<PropertyKey, unknown>;
+/**
+ * Check if the value satisfy a `object` type in typescript
+ */
+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 isPropertyKey(value: unknown): value is PropertyKey;
+declare const NullProtoObj: ({
+    new <T extends Record<PropertyKey, unknown>>(): T;
+});
+
+interface AsyncIdQueueCloseOptions {
+    id?: string;
+    reason?: unknown;
+}
+declare class AsyncIdQueue<T> {
+    private readonly openIds;
+    private readonly items;
+    private readonly pendingPulls;
+    get length(): number;
+    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: string): void;
+}
+
+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, AsyncIteratorClass, EventPublisher, NullProtoObj, SequentialIdGenerator, clone, defer, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, readAsBuffer, replicateAsyncIterator, resolveMaybeOptionalOptions, sequential, splitInHalf, 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

@@ -0,0 +1,215 @@
+import { 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];
+declare function resolveMaybeOptionalOptions<T>(rest: MaybeOptionalOptions<T>): 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 index;
+    generate(): string;
+}
+
+type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type IntersectPick<T, U> = Pick<T, keyof T & keyof U>;
+type PromiseWithError<T, TError> = Promise<T> & {
+    __error?: {
+        type: TError;
+    };
+};
+/**
+ * The place where you can config the orpc types.
+ *
+ * - `throwableError` the error type that represent throwable errors should be `Error` or `null | undefined | {}` if you want more strict.
+ */
+interface Registry {
+}
+type ThrowableError = Registry extends {
+    throwableError: infer T;
+} ? T : Error;
+
+type InterceptableOptions = Record<string, any>;
+type InterceptorOptions<TOptions extends InterceptableOptions, TResult> = Omit<TOptions, 'next'> & {
+    next(options?: TOptions): TResult;
+};
+type Interceptor<TOptions extends InterceptableOptions, TResult> = (options: InterceptorOptions<TOptions, TResult>) => TResult;
+/**
+ * Can used for interceptors or middlewares
+ */
+declare function onStart<T, TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
+/**
+ * Can used for interceptors or middlewares
+ */
+declare function onSuccess<T, TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(result: Awaited<ReturnType<TOptions['next']>>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
+/**
+ * Can used for interceptors or middlewares
+ */
+declare function onError<T, TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(error: ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
+type OnFinishState<TResult, TError> = [error: TError, data: undefined, isSuccess: false] | [error: null, data: TResult, isSuccess: true];
+/**
+ * Can used for interceptors or middlewares
+ */
+declare function onFinish<T, TOptions extends {
+    next(): any;
+}, TRest extends any[]>(callback: NoInfer<(state: OnFinishState<Awaited<ReturnType<TOptions['next']>>, ReturnType<TOptions['next']> extends PromiseWithError<any, infer E> ? E : ThrowableError>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => T | Promise<Awaited<ReturnType<TOptions['next']>>>;
+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 AsyncIteratorClassNextFn<T, TReturn> {
+    (): Promise<IteratorResult<T, TReturn>>;
+}
+interface AsyncIteratorClassCleanupFn {
+    (reason: 'return' | 'throw' | 'next' | 'dispose'): Promise<void>;
+}
+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 | {
+    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[]): {
+    maps: Segment[][];
+    values: unknown[];
+};
+/**
+ * Check if the value is an object even it created by `Object.create(null)` or more tricky way.
+ */
+declare function isObject(value: unknown): value is Record<PropertyKey, unknown>;
+/**
+ * Check if the value satisfy a `object` type in typescript
+ */
+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 isPropertyKey(value: unknown): value is PropertyKey;
+declare const NullProtoObj: ({
+    new <T extends Record<PropertyKey, unknown>>(): T;
+});
+
+interface AsyncIdQueueCloseOptions {
+    id?: string;
+    reason?: unknown;
+}
+declare class AsyncIdQueue<T> {
+    private readonly openIds;
+    private readonly items;
+    private readonly pendingPulls;
+    get length(): number;
+    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: string): void;
+}
+
+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, AsyncIteratorClass, EventPublisher, NullProtoObj, SequentialIdGenerator, clone, defer, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, readAsBuffer, replicateAsyncIterator, resolveMaybeOptionalOptions, sequential, splitInHalf, 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

@@ -0,0 +1,459 @@
+export { group, guard, mapEntries, mapValues, omit } from 'radash';
+
+function resolveMaybeOptionalOptions(rest) {
+  return rest[0] ?? {};
+}
+
+function toArray(value) {
+  return Array.isArray(value) ? value : value === void 0 || value === null ? [] : [value];
+}
+function splitInHalf(arr) {
+  const half = Math.ceil(arr.length / 2);
+  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 () => {
+    if (cached) {
+      return cached.result;
+    }
+    const result = fn();
+    cached = { result };
+    return result;
+  };
+}
+function sequential(fn) {
+  let lastOperationPromise = Promise.resolve();
+  return (...args) => {
+    return lastOperationPromise = lastOperationPromise.catch(() => {
+    }).then(() => {
+      return fn(...args);
+    });
+  };
+}
+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 {
+  index = BigInt(0);
+  generate() {
+    const id = this.index.toString(32);
+    this.index++;
+    return id;
+  }
+}
+
+function onStart(callback) {
+  return async (options, ...rest) => {
+    await callback(options, ...rest);
+    return await options.next();
+  };
+}
+function onSuccess(callback) {
+  return async (options, ...rest) => {
+    const result = await options.next();
+    await callback(result, options, ...rest);
+    return result;
+  };
+}
+function onError(callback) {
+  return async (options, ...rest) => {
+    try {
+      return await options.next();
+    } catch (error) {
+      await callback(error, options, ...rest);
+      throw error;
+    }
+  };
+}
+function onFinish(callback) {
+  let state;
+  return async (options, ...rest) => {
+    try {
+      const result = await options.next();
+      state = [null, result, true];
+      return result;
+    } catch (error) {
+      state = [error, void 0, false];
+      throw error;
+    } finally {
+      await callback(state, options, ...rest);
+    }
+  };
+}
+function intercept(interceptors, options, main) {
+  const next = (options2, index) => {
+    const interceptor = interceptors[index];
+    if (!interceptor) {
+      return main(options2);
+    }
+    return interceptor({
+      ...options2,
+      next: (newOptions = options2) => next(newOptions, index + 1)
+    });
+  };
+  return next(options, 0);
+}
+
+function parseEmptyableJSON(text) {
+  if (!text) {
+    return void 0;
+  }
+  return JSON.parse(text);
+}
+function stringifyJSON(value) {
+  return JSON.stringify(value);
+}
+
+function findDeepMatches(check, payload, segments = [], maps = [], values = []) {
+  if (check(payload)) {
+    maps.push(segments);
+    values.push(payload);
+  } else if (Array.isArray(payload)) {
+    payload.forEach((v, i) => {
+      findDeepMatches(check, v, [...segments, i], maps, values);
+    });
+  } else if (isObject(payload)) {
+    for (const key in payload) {
+      findDeepMatches(check, payload[key], [...segments, key], maps, values);
+    }
+  }
+  return { maps, values };
+}
+function isObject(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || !proto || !proto.constructor;
+}
+function isTypescriptObject(value) {
+  return !!value && (typeof value === "object" || typeof value === "function");
+}
+function clone(value) {
+  if (Array.isArray(value)) {
+    return value.map(clone);
+  }
+  if (isObject(value)) {
+    const result = {};
+    for (const key in value) {
+      result[key] = clone(value[key]);
+    }
+    return result;
+  }
+  return value;
+}
+function get(object, path) {
+  let current = object;
+  for (const key of path) {
+    if (!isTypescriptObject(current)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+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;
+})();
+
+function value(value2, ...args) {
+  if (typeof value2 === "function") {
+    return value2(...args);
+  }
+  return value2;
+}
+
+export { AsyncIdQueue, AsyncIteratorClass, EventPublisher, NullProtoObj, SequentialIdGenerator, clone, defer, findDeepMatches, get, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, onError, onFinish, onStart, onSuccess, once, parseEmptyableJSON, readAsBuffer, replicateAsyncIterator, resolveMaybeOptionalOptions, sequential, splitInHalf, stringifyJSON, toArray, value };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/shared",
   "type": "module",
-  "version": "0.0.0-next.f17a1a0",
+  "version": "0.0.0-next.f356b86",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,25 +15,25 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
-    "radash": "^12.1.0",
-    "type-fest": "^4.26.1"
+    "radash": "^12.1.1",
+    "type-fest": "^4.39.1"
+  },
+  "devDependencies": {
+    "arktype": "2.1.20",
+    "valibot": "^1.1.0",
+    "zod": "^3.25.76"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/index.js

@@ -1,155 +0,0 @@
-// src/object.ts
-function set(root, segments, value2) {
-  const ref = { root };
-  let currentRef = ref;
-  let preSegment = "root";
-  for (const segment of segments) {
-    currentRef = currentRef[preSegment];
-    preSegment = segment;
-  }
-  currentRef[preSegment] = value2;
-  return ref.root;
-}
-function get(root, segments) {
-  const ref = { root };
-  let currentRef = ref;
-  let preSegment = "root";
-  for (const segment of segments) {
-    if (typeof currentRef !== "object" && typeof currentRef !== "function" || currentRef === null) {
-      return void 0;
-    }
-    currentRef = currentRef[preSegment];
-    preSegment = segment;
-  }
-  if (typeof currentRef !== "object" && typeof currentRef !== "function" || currentRef === null) {
-    return void 0;
-  }
-  return currentRef[preSegment];
-}
-function findDeepMatches(check, payload, segments = [], maps = [], values = []) {
-  if (check(payload)) {
-    maps.push(segments);
-    values.push(payload);
-  } else if (Array.isArray(payload)) {
-    payload.forEach((v, i) => {
-      findDeepMatches(check, v, [...segments, i], maps, values);
-    });
-  } else if (isObject(payload)) {
-    for (const key in payload) {
-      findDeepMatches(check, payload[key], [...segments, key], maps, values);
-    }
-  }
-  return { maps, values };
-}
-function isObject(value2) {
-  if (!value2 || typeof value2 !== "object") {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(value2);
-  return proto === Object.prototype || !proto || !proto.constructor;
-}
-
-// src/error.ts
-function toError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-  if (typeof error === "string") {
-    return new Error(error, { cause: error });
-  }
-  if (isObject(error)) {
-    if ("message" in error && typeof error.message === "string") {
-      return new Error(error.message, { cause: error });
-    }
-    if ("name" in error && typeof error.name === "string") {
-      return new Error(error.name, { cause: error });
-    }
-  }
-  return new Error("Unknown error", { cause: error });
-}
-
-// src/interceptor.ts
-function onStart(callback) {
-  return async (options, ...rest) => {
-    await callback(options, ...rest);
-    return await options.next();
-  };
-}
-function onSuccess(callback) {
-  return async (options, ...rest) => {
-    const result = await options.next();
-    await callback(result, options, ...rest);
-    return result;
-  };
-}
-function onError(callback) {
-  return async (options, ...rest) => {
-    try {
-      return await options.next();
-    } catch (error) {
-      await callback(error, options, ...rest);
-      throw error;
-    }
-  };
-}
-function onFinish(callback) {
-  let state;
-  return async (options, ...rest) => {
-    try {
-      const result = await options.next();
-      state = [result, void 0, "success"];
-      return result;
-    } catch (error) {
-      state = [void 0, error, "error"];
-      throw error;
-    } finally {
-      await callback(state, options, ...rest);
-    }
-  };
-}
-async function intercept(interceptors, options, main) {
-  let index = 0;
-  const next = async (options2) => {
-    const interceptor = interceptors[index++];
-    if (!interceptor) {
-      return await main(options2);
-    }
-    return await interceptor({
-      ...options2,
-      next: (newOptions = options2) => next(newOptions)
-    });
-  };
-  return await next(options);
-}
-
-// src/value.ts
-function value(value2, ...args) {
-  if (typeof value2 === "function") {
-    return value2(...args);
-  }
-  return value2;
-}
-
-// src/index.ts
-import { group, guard, mapEntries, mapValues, omit, retry, trim } from "radash";
-export {
-  findDeepMatches,
-  get,
-  group,
-  guard,
-  intercept,
-  isObject,
-  mapEntries,
-  mapValues,
-  omit,
-  onError,
-  onFinish,
-  onStart,
-  onSuccess,
-  retry,
-  set,
-  toError,
-  trim,
-  value
-};
-//# sourceMappingURL=index.js.map

package/dist/src/chain.d.ts

@@ -1,5 +0,0 @@
-import type { AnyFunction } from './function';
-export 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];
-};
-//# sourceMappingURL=chain.d.ts.map

package/dist/src/error.d.ts

@@ -1,2 +0,0 @@
-export declare function toError(error: unknown): Error;
-//# sourceMappingURL=error.d.ts.map

package/dist/src/function.d.ts

@@ -1,2 +0,0 @@
-export type AnyFunction = (...args: any[]) => any;
-//# sourceMappingURL=function.d.ts.map

package/dist/src/index.d.ts

@@ -1,10 +0,0 @@
-export * from './chain';
-export * from './error';
-export * from './function';
-export * from './interceptor';
-export * from './object';
-export * from './types';
-export * from './value';
-export { group, guard, mapEntries, mapValues, omit, retry, trim } from 'radash';
-export type { IsEqual, IsNever, PartialDeep, Promisable } from 'type-fest';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/interceptor.d.ts

@@ -1,45 +0,0 @@
-import type { Promisable } from 'type-fest';
-export type InterceptableOptions = Record<string, any>;
-export type InterceptorOptions<TOptions extends InterceptableOptions, TResult> = Omit<TOptions, 'next'> & {
-    next(options?: TOptions): Promise<TResult>;
-};
-export type Interceptor<TOptions extends InterceptableOptions, TResult, TError> = (options: InterceptorOptions<TOptions, TResult>) => Promise<TResult> & {
-    __error?: {
-        type: TError;
-    };
-};
-/**
- * Can used for interceptors or middlewares
- */
-export declare function onStart<TOptions extends {
-    next(): any;
-}, TRest extends any[]>(callback: NoInfer<(options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>>;
-/**
- * Can used for interceptors or middlewares
- */
-export declare function onSuccess<TOptions extends {
-    next(): any;
-}, TRest extends any[]>(callback: NoInfer<(result: Awaited<ReturnType<TOptions['next']>>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>>;
-/**
- * Can used for interceptors or middlewares
- */
-export declare function onError<TError, TOptions extends {
-    next(): any;
-}, TRest extends any[]>(callback: NoInfer<(error: TError, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>> & {
-    __error?: {
-        type: TError;
-    };
-};
-export type OnFinishState<TResult, TError> = [TResult, undefined, 'success'] | [undefined, TError, 'error'];
-/**
- * Can used for interceptors or middlewares
- */
-export declare function onFinish<TError, TOptions extends {
-    next(): any;
-}, TRest extends any[]>(callback: NoInfer<(state: OnFinishState<Awaited<ReturnType<TOptions['next']>>, TError>, options: TOptions, ...rest: TRest) => Promisable<void>>): (options: TOptions, ...rest: TRest) => Promise<Awaited<ReturnType<TOptions['next']>>> & {
-    __error?: {
-        type: TError;
-    };
-};
-export declare function intercept<TOptions extends InterceptableOptions, TResult, TError>(interceptors: Interceptor<TOptions, TResult, TError>[], options: NoInfer<TOptions>, main: NoInfer<(options: TOptions) => Promisable<TResult>>): Promise<TResult>;
-//# sourceMappingURL=interceptor.d.ts.map

package/dist/src/object.d.ts

@@ -1,12 +0,0 @@
-export type Segment = string | number;
-export declare function set(root: unknown, segments: Readonly<Segment[]>, value: unknown): unknown;
-export declare function get(root: Readonly<Record<string, unknown> | unknown[]>, segments: Readonly<Segment[]>): unknown;
-export declare function findDeepMatches(check: (value: unknown) => boolean, payload: unknown, segments?: Segment[], maps?: Segment[][], values?: unknown[]): {
-    maps: Segment[][];
-    values: unknown[];
-};
-/**
- * Check if the value is an object even it created by `Object.create(null)` or more tricky way.
- */
-export declare function isObject(value: unknown): value is Record<PropertyKey, unknown>;
-//# sourceMappingURL=object.d.ts.map

package/dist/src/types.d.ts

@@ -1,3 +0,0 @@
-export type MaybeOptionalOptions<TOptions> = [options: TOptions] | (Record<never, never> extends TOptions ? [] : never);
-export type SetOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-//# sourceMappingURL=types.d.ts.map

package/dist/src/value.d.ts

@@ -1,4 +0,0 @@
-import type { Promisable } from 'type-fest';
-export type Value<T, TArgs extends any[] = []> = T | ((...args: TArgs) => Promisable<T>);
-export declare function value<T, TArgs extends any[]>(value: Value<T, TArgs>, ...args: NoInfer<TArgs>): Promise<T extends Value<infer U, any> ? U : never>;
-//# sourceMappingURL=value.d.ts.map