@orpc/client 1.14.11 → 1.14.12

package/dist/shared/client.BdItY5DT.d.mts

@@ -1,111 +0,0 @@
-import { StandardBody } from '@standardserver/core';
-import { Segment } from '@orpc/shared';
-
-type RPCJsonSerializationMeta = [type: string, ...path: Segment[]];
-type RPCJsonSerialization = {
-    json: unknown;
-    meta?: RPCJsonSerializationMeta[] | undefined;
-    maps?: undefined;
-    blobs?: undefined;
-} | {
-    json: unknown;
-    meta?: RPCJsonSerializationMeta[] | undefined;
-    maps: Segment[][];
-    blobs: Blob[];
-};
-interface RPCJsonSerializerHandler {
-    condition(value: unknown): boolean;
-    serialize(value: any): unknown;
-    deserialize(serialized: any): unknown;
-    /**
-     * If false, the result of this serializer will not be further processed by other serializers,
-     * even if it matches their conditions and treat it as final serialized value.
-     * This can be useful for serializers that return primitive values, which should not be further processed.
-     * to improve performance and avoid potential issues with other serializers.
-     *
-     * @default false
-     */
-    isTerminal?: boolean;
-}
-interface RPCJsonSerializerOptions {
-    /**
-     * Extend or override the built-in type handlers used during serialization and deserialization.
-     *
-     * Each key is a unique type identifier (e.g. `"date"`, `"bigint"`) and maps to a handler
-     * that defines how to detect, serialize, and deserialize values of that type.
-     *
-     * **Extending:** Add new keys to support custom types:
-     * ```ts
-     * handlers: {
-     *   buffer: {
-     *     condition: (v) => v instanceof Buffer,
-     *     serialize: (v: Buffer) => v.toString('base64'),
-     *     deserialize: (s: string) => Buffer.from(s, 'base64'),
-     *     isTerminal: true,
-     *   }
-     * }
-     * ```
-     *
-     * **Overriding:** Use an existing key to replace a built-in handler:
-     * ```ts
-     * handlers: {
-     *   date: {
-     *     condition: (v) => v instanceof Date,
-     *     serialize: (v: Date) => v.getTime(),
-     *     deserialize: (n: number) => new Date(n),
-     *     isTerminal: true,
-     *   }
-     * }
-     * ```
-     *
-     * **Disabling:** Set a key to `undefined` to remove a built-in handler:
-     * ```ts
-     * handlers: { regexp: undefined }
-     * ```
-     *
-     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `regexp`, `set`, `map`.
-     */
-    handlers?: Record<string, undefined | RPCJsonSerializerHandler> | undefined;
-    /**
-     * If true, properties with undefined values will be omitted during serialization.
-     *
-     * @default true
-     */
-    omitUndefinedProperties?: boolean | undefined;
-}
-declare class RPCJsonSerializer {
-    private readonly handlers;
-    private readonly omitUndefinedProperties;
-    constructor(options?: RPCJsonSerializerOptions);
-    serialize(data: unknown): RPCJsonSerialization;
-    private serializeValue;
-    deserialize(serialized: RPCJsonSerialization): unknown;
-}
-
-interface RPCSerializerSerializeOptions {
-    /**
-     * Use FormData for serialization when nested blobs are present.
-     * Does not apply to root-level Blob values.
-     *
-     * @default true
-     */
-    useFormDataForBlobFields?: boolean;
-}
-interface RPCSerializerOptions extends RPCJsonSerializerOptions {
-    /**
-     * Default options for serialize method
-     */
-    serialize?: RPCSerializerSerializeOptions | undefined;
-}
-declare class RPCSerializer {
-    private readonly jsonSerializer;
-    private readonly defaultSerializeOptions;
-    constructor(options?: RPCSerializerOptions);
-    serialize(data: unknown, options?: RPCSerializerSerializeOptions): StandardBody;
-    private serializeValue;
-    deserialize(data: StandardBody): unknown;
-    private deserializeValue;
-}
-
-export { RPCJsonSerializer as b, RPCSerializer as e };
-export type { RPCJsonSerialization as R, RPCJsonSerializationMeta as a, RPCJsonSerializerHandler as c, RPCJsonSerializerOptions as d, RPCSerializerOptions as f, RPCSerializerSerializeOptions as g };

package/dist/shared/client.BdItY5DT.d.ts

@@ -1,111 +0,0 @@
-import { StandardBody } from '@standardserver/core';
-import { Segment } from '@orpc/shared';
-
-type RPCJsonSerializationMeta = [type: string, ...path: Segment[]];
-type RPCJsonSerialization = {
-    json: unknown;
-    meta?: RPCJsonSerializationMeta[] | undefined;
-    maps?: undefined;
-    blobs?: undefined;
-} | {
-    json: unknown;
-    meta?: RPCJsonSerializationMeta[] | undefined;
-    maps: Segment[][];
-    blobs: Blob[];
-};
-interface RPCJsonSerializerHandler {
-    condition(value: unknown): boolean;
-    serialize(value: any): unknown;
-    deserialize(serialized: any): unknown;
-    /**
-     * If false, the result of this serializer will not be further processed by other serializers,
-     * even if it matches their conditions and treat it as final serialized value.
-     * This can be useful for serializers that return primitive values, which should not be further processed.
-     * to improve performance and avoid potential issues with other serializers.
-     *
-     * @default false
-     */
-    isTerminal?: boolean;
-}
-interface RPCJsonSerializerOptions {
-    /**
-     * Extend or override the built-in type handlers used during serialization and deserialization.
-     *
-     * Each key is a unique type identifier (e.g. `"date"`, `"bigint"`) and maps to a handler
-     * that defines how to detect, serialize, and deserialize values of that type.
-     *
-     * **Extending:** Add new keys to support custom types:
-     * ```ts
-     * handlers: {
-     *   buffer: {
-     *     condition: (v) => v instanceof Buffer,
-     *     serialize: (v: Buffer) => v.toString('base64'),
-     *     deserialize: (s: string) => Buffer.from(s, 'base64'),
-     *     isTerminal: true,
-     *   }
-     * }
-     * ```
-     *
-     * **Overriding:** Use an existing key to replace a built-in handler:
-     * ```ts
-     * handlers: {
-     *   date: {
-     *     condition: (v) => v instanceof Date,
-     *     serialize: (v: Date) => v.getTime(),
-     *     deserialize: (n: number) => new Date(n),
-     *     isTerminal: true,
-     *   }
-     * }
-     * ```
-     *
-     * **Disabling:** Set a key to `undefined` to remove a built-in handler:
-     * ```ts
-     * handlers: { regexp: undefined }
-     * ```
-     *
-     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `regexp`, `set`, `map`.
-     */
-    handlers?: Record<string, undefined | RPCJsonSerializerHandler> | undefined;
-    /**
-     * If true, properties with undefined values will be omitted during serialization.
-     *
-     * @default true
-     */
-    omitUndefinedProperties?: boolean | undefined;
-}
-declare class RPCJsonSerializer {
-    private readonly handlers;
-    private readonly omitUndefinedProperties;
-    constructor(options?: RPCJsonSerializerOptions);
-    serialize(data: unknown): RPCJsonSerialization;
-    private serializeValue;
-    deserialize(serialized: RPCJsonSerialization): unknown;
-}
-
-interface RPCSerializerSerializeOptions {
-    /**
-     * Use FormData for serialization when nested blobs are present.
-     * Does not apply to root-level Blob values.
-     *
-     * @default true
-     */
-    useFormDataForBlobFields?: boolean;
-}
-interface RPCSerializerOptions extends RPCJsonSerializerOptions {
-    /**
-     * Default options for serialize method
-     */
-    serialize?: RPCSerializerSerializeOptions | undefined;
-}
-declare class RPCSerializer {
-    private readonly jsonSerializer;
-    private readonly defaultSerializeOptions;
-    constructor(options?: RPCSerializerOptions);
-    serialize(data: unknown, options?: RPCSerializerSerializeOptions): StandardBody;
-    private serializeValue;
-    deserialize(data: StandardBody): unknown;
-    private deserializeValue;
-}
-
-export { RPCJsonSerializer as b, RPCSerializer as e };
-export type { RPCJsonSerialization as R, RPCJsonSerializationMeta as a, RPCJsonSerializerHandler as c, RPCJsonSerializerOptions as d, RPCSerializerOptions as f, RPCSerializerSerializeOptions as g };

package/dist/shared/client.Dnfj8jnT.mjs

@@ -1,92 +0,0 @@
-import { resolveMaybeOptionalOptions, getConstructor } from '@orpc/shared';
-
-const COMMON_ERROR_STATUS_MAP = {
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  PAYMENT_REQUIRED: 402,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_SUPPORTED: 405,
-  NOT_ACCEPTABLE: 406,
-  TIMEOUT: 408,
-  CONFLICT: 409,
-  GONE: 410,
-  PRECONDITION_FAILED: 412,
-  PAYLOAD_TOO_LARGE: 413,
-  UNSUPPORTED_MEDIA_TYPE: 415,
-  UNPROCESSABLE_CONTENT: 422,
-  PRECONDITION_REQUIRED: 428,
-  TOO_MANY_REQUESTS: 429,
-  CLIENT_CLOSED_REQUEST: 499,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504
-};
-let ORPCErrorConstructors;
-class ORPCError extends Error {
-  static {
-    const ORPC_ERROR_CONSTRUCTORS_SYMBOL = Symbol.for("ORPC_ERROR_CONSTRUCTORS");
-    void (globalThis[ORPC_ERROR_CONSTRUCTORS_SYMBOL] ??= /* @__PURE__ */ new WeakSet());
-    ORPCErrorConstructors = globalThis[ORPC_ERROR_CONSTRUCTORS_SYMBOL];
-    ORPCErrorConstructors.add(ORPCError);
-  }
-  /**
-   * @info
-   * The `__branch` property is used for type branding, helping TypeScript distinguish
-   * an `ORPCError` instance from plain objects with a similar structure.
-   */
-  name = "ORPCError";
-  /**
-   * Indicates whether the error matches a definition in the procedure's `.errors` map.
-   */
-  defined = false;
-  /**
-   * Indicates whether the error's type is inferable at the TypeScript level.
-   * This is typically true when the error is explicitly defined or returned within a handler.
-   */
-  inferable = false;
-  code;
-  data;
-  constructor(code, ...rest) {
-    const options = resolveMaybeOptionalOptions(rest);
-    const message = options.message ?? code.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
-    super(message, options);
-    this.code = code;
-    this.data = options.data;
-  }
-  toJSON() {
-    return {
-      defined: this.defined,
-      inferable: this.inferable,
-      code: this.code,
-      message: this.message,
-      data: this.data
-    };
-  }
-  /**
-   * Workaround for Next.js where different contexts use separate
-   * dependency graphs, causing multiple ORPCError constructors existing and breaking
-   * `instanceof` checks across contexts.
-   *
-   * This is particularly problematic with "Optimized SSR", where orpc-client
-   * executes in one context but is invoked from another. When an error is thrown
-   * in the execution context, `instanceof ORPCError` checks fail in the
-   * invocation context due to separate class constructors.
-   *
-   * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
-   */
-  static [Symbol.hasInstance](instance) {
-    if (!ORPCErrorConstructors.has(this)) {
-      return super[Symbol.hasInstance](instance);
-    }
-    const constructor = getConstructor(instance);
-    if (constructor && ORPCErrorConstructors.has(constructor)) {
-      return true;
-    }
-    return super[Symbol.hasInstance](instance);
-  }
-}
-
-export { COMMON_ERROR_STATUS_MAP as C, ORPCError as O };

package/dist/shared/client.DqYwRDUO.mjs

@@ -1,343 +0,0 @@
-import { isPlainObject, wrapAsyncIterator, isTypescriptObject, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
-import { getEventMeta, withEventMeta, ErrorEvent } from '@standardserver/core';
-import { O as ORPCError } from './client.Dnfj8jnT.mjs';
-
-function isInferableError(error) {
-  return error instanceof ORPCError && error.inferable;
-}
-function toORPCError(error) {
-  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", { cause: error });
-}
-function isORPCErrorJson(json) {
-  if (!isPlainObject(json)) {
-    return false;
-  }
-  const validKeys = ["defined", "inferable", "code", "message", "data"];
-  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
-    return false;
-  }
-  return "defined" in json && typeof json.defined === "boolean" && "inferable" in json && typeof json.inferable === "boolean" && "code" in json && typeof json.code === "string" && "message" in json && typeof json.message === "string";
-}
-function createORPCErrorFromJson(json, options = {}) {
-  const error = new ORPCError(json.code, {
-    ...json,
-    ...options
-  });
-  error.defined = json.defined;
-  error.inferable = json.inferable;
-  return error;
-}
-function cloneORPCError(error) {
-  const cloned = new ORPCError(error.code, {
-    ...error,
-    message: error.message,
-    data: error.data,
-    cause: error.cause
-  });
-  cloned.stack = error.stack;
-  cloned.defined = error.defined;
-  cloned.inferable = error.inferable;
-  return cloned;
-}
-
-function wrapAsyncIteratorPreservingEventMeta(iterator, { mapResult, mapError, ...rest }) {
-  return wrapAsyncIterator(iterator, {
-    ...rest,
-    mapResult: mapResult && (async (result) => {
-      const mapped = await mapResult(result);
-      if (mapped.value !== result.value) {
-        const meta = getEventMeta(result.value);
-        if (meta && isTypescriptObject(mapped.value)) {
-          return { done: mapped.done, value: withEventMeta(mapped.value, meta) };
-        }
-      }
-      return mapped;
-    }),
-    mapError: mapError && (async (error) => {
-      const mapped = await mapError(error);
-      if (mapped !== error) {
-        const meta = getEventMeta(error);
-        if (meta && isTypescriptObject(mapped)) {
-          return withEventMeta(mapped, meta);
-        }
-      }
-      return mapped;
-    })
-  });
-}
-
-const REGEX_STRING_PATTERN = /^\/(.*)\/([a-z]*)$/;
-const DEFAULT_RPC_JSON_SERIALIZER_HANDLERS = {
-  undefined: {
-    condition(data) {
-      return data === void 0;
-    },
-    serialize() {
-      return null;
-    },
-    deserialize() {
-      return void 0;
-    },
-    isTerminal: true
-  },
-  bigint: {
-    condition(data) {
-      return typeof data === "bigint";
-    },
-    serialize(data) {
-      return data.toString();
-    },
-    deserialize(serialized) {
-      return BigInt(serialized);
-    },
-    isTerminal: true
-  },
-  date: {
-    condition(data) {
-      return data instanceof Date;
-    },
-    serialize(data) {
-      if (Number.isNaN(data.getTime())) {
-        return null;
-      }
-      return data.toISOString();
-    },
-    deserialize(serialized) {
-      return new Date(serialized ?? "Invalid Date");
-    },
-    isTerminal: true
-  },
-  nan: {
-    condition(data) {
-      return typeof data === "number" && Number.isNaN(data);
-    },
-    serialize() {
-      return null;
-    },
-    deserialize() {
-      return Number.NaN;
-    },
-    isTerminal: true
-  },
-  url: {
-    condition(data) {
-      return data instanceof URL;
-    },
-    serialize(data) {
-      return data.toString();
-    },
-    deserialize(serialized) {
-      return new URL(serialized);
-    },
-    isTerminal: true
-  },
-  regexp: {
-    condition(data) {
-      return data instanceof RegExp;
-    },
-    serialize(data) {
-      return data.toString();
-    },
-    deserialize(serialized) {
-      const [, pattern, flags] = serialized.match(REGEX_STRING_PATTERN);
-      return new RegExp(pattern, flags);
-    },
-    isTerminal: true
-  },
-  set: {
-    condition(data) {
-      return data instanceof Set;
-    },
-    serialize(data) {
-      return Array.from(data);
-    },
-    deserialize(serialized) {
-      return new Set(serialized);
-    }
-  },
-  map: {
-    condition(data) {
-      return data instanceof Map;
-    },
-    serialize(data) {
-      return Array.from(data.entries());
-    },
-    deserialize(serialized) {
-      return new Map(serialized);
-    }
-  }
-};
-class RPCJsonSerializer {
-  handlers;
-  omitUndefinedProperties;
-  constructor(options = {}) {
-    this.handlers = {
-      ...DEFAULT_RPC_JSON_SERIALIZER_HANDLERS,
-      ...options.handlers
-    };
-    this.omitUndefinedProperties = options.omitUndefinedProperties !== false;
-  }
-  serialize(data) {
-    const [json, meta_, maps, blobs] = this.serializeValue(data, [], [], [], []);
-    const meta = meta_.length === 0 ? void 0 : meta_;
-    if (maps.length === 0) {
-      return { json, meta };
-    }
-    return { json, meta, maps, blobs };
-  }
-  serializeValue(data, segments, meta, maps, blobs) {
-    for (const key in this.handlers) {
-      const handler = this.handlers[key];
-      if (handler && handler.condition(data)) {
-        const serialized = handler.serialize(data);
-        if (handler.isTerminal) {
-          meta.push([key, ...segments]);
-          return [serialized, meta, maps, blobs];
-        }
-        const result = this.serializeValue(serialized, segments, meta, maps, blobs);
-        meta.push([key, ...segments]);
-        return result;
-      }
-    }
-    if (data instanceof Blob) {
-      maps.push(segments);
-      blobs.push(data);
-      return [data, meta, maps, blobs];
-    }
-    if (Array.isArray(data)) {
-      const json = data.map((v, i) => {
-        return this.serializeValue(v, [...segments, i], meta, maps, blobs)[0];
-      });
-      return [json, meta, maps, blobs];
-    }
-    if (isPlainObject(data)) {
-      const json = {};
-      for (const k in data) {
-        const v = data[k];
-        if (k === "toJSON" && typeof v === "function") {
-          continue;
-        }
-        if (v === void 0 && this.omitUndefinedProperties) {
-          continue;
-        }
-        json[k] = this.serializeValue(v, [...segments, k], meta, maps, blobs)[0];
-      }
-      return [json, meta, maps, blobs];
-    }
-    return [data, meta, maps, blobs];
-  }
-  deserialize(serialized) {
-    const ref = { data: serialized.json };
-    if (serialized.blobs?.length) {
-      serialized.maps.forEach((segments, i) => {
-        let currentRef = ref;
-        let preSegment = "data";
-        segments.forEach((segment) => {
-          currentRef = currentRef[preSegment];
-          preSegment = segment;
-          if (!Object.hasOwn(currentRef, preSegment)) {
-            throw new Error(`Security error: Invalid serialized data. Segment "${preSegment}" does not exist.`);
-          }
-        });
-        currentRef[preSegment] = serialized.blobs[i];
-      });
-    }
-    serialized.meta?.forEach((item) => {
-      const type = item[0];
-      let currentRef = ref;
-      let preSegment = "data";
-      for (let i = 1; i < item.length; i++) {
-        currentRef = currentRef[preSegment];
-        preSegment = item[i];
-        if (!Object.hasOwn(currentRef, preSegment)) {
-          throw new Error(`Security error: Invalid serialized data. Segment "${preSegment}" does not exist.`);
-        }
-      }
-      currentRef[preSegment] = this.handlers[type].deserialize(currentRef[preSegment]);
-    });
-    return ref.data;
-  }
-}
-
-class RPCSerializer {
-  jsonSerializer;
-  defaultSerializeOptions;
-  constructor(options = {}) {
-    this.jsonSerializer = new RPCJsonSerializer(options);
-    this.defaultSerializeOptions = options.serialize;
-  }
-  serialize(data, options = {}) {
-    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
-      return data;
-    }
-    if (isAsyncIteratorObject(data)) {
-      return wrapAsyncIteratorPreservingEventMeta(data, {
-        mapResult: (result) => {
-          if (result.value === void 0) {
-            return result;
-          }
-          return { done: result.done, value: this.serializeValue(result.value, options) };
-        },
-        mapError: (e) => new ErrorEvent(
-          this.serializeValue(toORPCError(e).toJSON(), { ...options, useFormDataForBlobFields: false }),
-          { cause: e }
-        )
-      });
-    }
-    return this.serializeValue(data, options);
-  }
-  serializeValue(data, options) {
-    const useFormDataForBlobs = options.useFormDataForBlobFields ?? this.defaultSerializeOptions?.useFormDataForBlobFields ?? true;
-    const { json, meta, maps, blobs } = this.jsonSerializer.serialize(data);
-    if (!useFormDataForBlobs || !blobs?.length) {
-      return { json, meta };
-    }
-    const form = new FormData();
-    form.set("data", stringifyJSON({ json, meta, maps }));
-    blobs.forEach((blob, i) => {
-      form.set(i.toString(), blob);
-    });
-    return form;
-  }
-  deserialize(data) {
-    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
-      return data;
-    }
-    if (isAsyncIteratorObject(data)) {
-      return wrapAsyncIteratorPreservingEventMeta(data, {
-        mapResult: (result) => {
-          if (result.value === void 0) {
-            return result;
-          }
-          return { done: result.done, value: this.deserializeValue(result.value) };
-        },
-        mapError: (e) => {
-          if (!(e instanceof ErrorEvent)) {
-            return e;
-          }
-          const deserialized = this.deserializeValue(e.data);
-          if (isORPCErrorJson(deserialized)) {
-            return createORPCErrorFromJson(deserialized, { cause: e });
-          }
-          return new ErrorEvent(deserialized, { cause: e });
-        }
-      });
-    }
-    return this.deserializeValue(data);
-  }
-  deserializeValue(data) {
-    if (!(data instanceof FormData)) {
-      return this.jsonSerializer.deserialize(data);
-    }
-    const serialized = JSON.parse(data.get("data"));
-    const blobs = [];
-    for (const [key, value] of data) {
-      if (value instanceof Blob) {
-        blobs[Number(key)] = value;
-      }
-    }
-    return this.jsonSerializer.deserialize({ ...serialized, blobs });
-  }
-}
-
-export { RPCSerializer as R, isInferableError as a, RPCJsonSerializer as b, createORPCErrorFromJson as c, cloneORPCError as d, isORPCErrorJson as i, toORPCError as t, wrapAsyncIteratorPreservingEventMeta as w };