@orpc/client 1.14.9 → 1.14.11

package/dist/shared/client.DqYwRDUO.mjs

@@ -0,0 +1,343 @@
+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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "1.14.9",
+  "version": "1.14.11",
   "license": "MIT",
   "homepage": "https://orpc.dev",
   "repository": {
@@ -14,6 +14,7 @@
   ],
   "sideEffects": false,
   "exports": {
+    "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs",
@@ -49,17 +50,16 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/shared": "1.14.9",
-    "@orpc/standard-server-peer": "1.14.9",
-    "@orpc/standard-server-fetch": "1.14.9",
-    "@orpc/standard-server": "1.14.9"
+    "@standardserver/core": "^0.5.0",
+    "@standardserver/fetch": "^0.5.0",
+    "@standardserver/peer": "^0.5.0",
+    "@orpc/shared": "1.14.11"
   },
   "devDependencies": {
-    "zod": "^4.3.6"
+    "zod": "^4.4.3"
   },
   "scripts": {
     "build": "unbuild",
-    "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }
 }

package/dist/shared/client.2jUAqzYU.d.ts

@@ -1,45 +0,0 @@
-import { Interceptor } from '@orpc/shared';
-import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { b as ClientContext, c as ClientOptions, C as ClientLink } from './client.i2uoJbEp.js';
-
-interface StandardLinkPlugin<T extends ClientContext> {
-    order?: number;
-    init?(options: StandardLinkOptions<T>): void;
-}
-declare class CompositeStandardLinkPlugin<T extends ClientContext, TPlugin extends StandardLinkPlugin<T>> implements StandardLinkPlugin<T> {
-    protected readonly plugins: TPlugin[];
-    constructor(plugins?: readonly TPlugin[]);
-    init(options: StandardLinkOptions<T>): void;
-}
-
-interface StandardLinkCodec<T extends ClientContext> {
-    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
-    decode(response: StandardLazyResponse, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<unknown>;
-}
-interface StandardLinkClient<T extends ClientContext> {
-    call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
-}
-
-interface StandardLinkInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
-    path: readonly string[];
-    input: unknown;
-}
-interface StandardLinkClientInterceptorOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
-    request: StandardRequest;
-}
-interface StandardLinkOptions<T extends ClientContext> {
-    interceptors?: Interceptor<StandardLinkInterceptorOptions<T>, Promise<unknown>>[];
-    clientInterceptors?: Interceptor<StandardLinkClientInterceptorOptions<T>, Promise<StandardLazyResponse>>[];
-    plugins?: StandardLinkPlugin<T>[];
-}
-declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
-    readonly codec: StandardLinkCodec<T>;
-    readonly sender: StandardLinkClient<T>;
-    private readonly interceptors;
-    private readonly clientInterceptors;
-    constructor(codec: StandardLinkCodec<T>, sender: StandardLinkClient<T>, options?: StandardLinkOptions<T>);
-    call(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<unknown>;
-}
-
-export { CompositeStandardLinkPlugin as C, StandardLink as d };
-export type { StandardLinkClientInterceptorOptions as S, StandardLinkPlugin as a, StandardLinkOptions as b, StandardLinkInterceptorOptions as c, StandardLinkCodec as e, StandardLinkClient as f };

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

@@ -1,91 +0,0 @@
-import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.i2uoJbEp.js';
-import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.2jUAqzYU.js';
-import { Segment, Value, Promisable } from '@orpc/shared';
-import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-
-declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
-    readonly BIGINT: 0;
-    readonly DATE: 1;
-    readonly NAN: 2;
-    readonly UNDEFINED: 3;
-    readonly URL: 4;
-    readonly REGEXP: 5;
-    readonly SET: 6;
-    readonly MAP: 7;
-};
-type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
-type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
-interface StandardRPCCustomJsonSerializer {
-    type: number;
-    condition(data: unknown): boolean;
-    serialize(data: any): unknown;
-    deserialize(serialized: any): unknown;
-}
-interface StandardRPCJsonSerializerOptions {
-    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
-}
-declare class StandardRPCJsonSerializer {
-    private readonly customSerializers;
-    constructor(options?: StandardRPCJsonSerializerOptions);
-    serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
-    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
-    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
-}
-
-declare class StandardRPCSerializer {
-    #private;
-    private readonly jsonSerializer;
-    constructor(jsonSerializer: StandardRPCJsonSerializer);
-    serialize(data: unknown): object;
-    deserialize(data: unknown): unknown;
-}
-
-interface StandardRPCLinkCodecOptions<T extends ClientContext> {
-    /**
-     * Base url for all requests.
-     */
-    url: Value<Promisable<string | URL>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
-    /**
-     * The maximum length of the URL.
-     *
-     * @default 2083
-     */
-    maxUrlLength?: Value<Promisable<number>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
-    /**
-     * The method used to make the request.
-     *
-     * @default 'POST'
-     */
-    method?: Value<Promisable<Exclude<HTTPMethod, 'HEAD'>>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
-    /**
-     * The method to use when the payload cannot safely pass to the server with method return from method function.
-     * GET is not allowed, it's very dangerous.
-     *
-     * @default 'POST'
-     */
-    fallbackMethod?: Exclude<HTTPMethod, 'HEAD' | 'GET'>;
-    /**
-     * Inject headers to the request.
-     */
-    headers?: Value<Promisable<StandardHeaders | Headers>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
-}
-declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
-    private readonly serializer;
-    private readonly baseUrl;
-    private readonly maxUrlLength;
-    private readonly fallbackMethod;
-    private readonly expectedMethod;
-    private readonly headers;
-    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
-    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
-    decode(response: StandardLazyResponse): Promise<unknown>;
-}
-
-interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
-}
-declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
-    constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
-}
-
-export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, StandardRPCJsonSerializer as e, StandardRPCLink as g, StandardRPCLinkCodec as i, StandardRPCSerializer as j };
-export type { StandardRPCJsonSerializedMetaItem as a, StandardRPCJsonSerialized as b, StandardRPCCustomJsonSerializer as c, StandardRPCJsonSerializerOptions as d, StandardRPCLinkOptions as f, StandardRPCLinkCodecOptions as h };

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

@@ -1,91 +0,0 @@
-import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.i2uoJbEp.mjs';
-import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.CpCa3si8.mjs';
-import { Segment, Value, Promisable } from '@orpc/shared';
-import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-
-declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
-    readonly BIGINT: 0;
-    readonly DATE: 1;
-    readonly NAN: 2;
-    readonly UNDEFINED: 3;
-    readonly URL: 4;
-    readonly REGEXP: 5;
-    readonly SET: 6;
-    readonly MAP: 7;
-};
-type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
-type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
-interface StandardRPCCustomJsonSerializer {
-    type: number;
-    condition(data: unknown): boolean;
-    serialize(data: any): unknown;
-    deserialize(serialized: any): unknown;
-}
-interface StandardRPCJsonSerializerOptions {
-    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
-}
-declare class StandardRPCJsonSerializer {
-    private readonly customSerializers;
-    constructor(options?: StandardRPCJsonSerializerOptions);
-    serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
-    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
-    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
-}
-
-declare class StandardRPCSerializer {
-    #private;
-    private readonly jsonSerializer;
-    constructor(jsonSerializer: StandardRPCJsonSerializer);
-    serialize(data: unknown): object;
-    deserialize(data: unknown): unknown;
-}
-
-interface StandardRPCLinkCodecOptions<T extends ClientContext> {
-    /**
-     * Base url for all requests.
-     */
-    url: Value<Promisable<string | URL>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
-    /**
-     * The maximum length of the URL.
-     *
-     * @default 2083
-     */
-    maxUrlLength?: Value<Promisable<number>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
-    /**
-     * The method used to make the request.
-     *
-     * @default 'POST'
-     */
-    method?: Value<Promisable<Exclude<HTTPMethod, 'HEAD'>>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
-    /**
-     * The method to use when the payload cannot safely pass to the server with method return from method function.
-     * GET is not allowed, it's very dangerous.
-     *
-     * @default 'POST'
-     */
-    fallbackMethod?: Exclude<HTTPMethod, 'HEAD' | 'GET'>;
-    /**
-     * Inject headers to the request.
-     */
-    headers?: Value<Promisable<StandardHeaders | Headers>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
-}
-declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
-    private readonly serializer;
-    private readonly baseUrl;
-    private readonly maxUrlLength;
-    private readonly fallbackMethod;
-    private readonly expectedMethod;
-    private readonly headers;
-    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
-    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
-    decode(response: StandardLazyResponse): Promise<unknown>;
-}
-
-interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
-}
-declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
-    constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
-}
-
-export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, StandardRPCJsonSerializer as e, StandardRPCLink as g, StandardRPCLinkCodec as i, StandardRPCSerializer as j };
-export type { StandardRPCJsonSerializedMetaItem as a, StandardRPCJsonSerialized as b, StandardRPCCustomJsonSerializer as c, StandardRPCJsonSerializerOptions as d, StandardRPCLinkOptions as f, StandardRPCLinkCodecOptions as h };

package/dist/shared/client.BLtwTQUg.mjs

@@ -1,40 +0,0 @@
-import { AsyncIteratorClass, isTypescriptObject } from '@orpc/shared';
-import { getEventMeta, withEventMeta } from '@orpc/standard-server';
-
-function mapEventIterator(iterator, maps) {
-  const mapError = async (error) => {
-    let mappedError = await maps.error(error);
-    if (mappedError !== error) {
-      const meta = getEventMeta(error);
-      if (meta && isTypescriptObject(mappedError)) {
-        mappedError = withEventMeta(mappedError, meta);
-      }
-    }
-    return mappedError;
-  };
-  return new AsyncIteratorClass(async () => {
-    const { done, value } = await (async () => {
-      try {
-        return await iterator.next();
-      } catch (error) {
-        throw await mapError(error);
-      }
-    })();
-    let mappedValue = await maps.value(value, done);
-    if (mappedValue !== value) {
-      const meta = getEventMeta(value);
-      if (meta && isTypescriptObject(mappedValue)) {
-        mappedValue = withEventMeta(mappedValue, meta);
-      }
-    }
-    return { done, value: mappedValue };
-  }, async () => {
-    try {
-      await iterator.return?.();
-    } catch (error) {
-      throw await mapError(error);
-    }
-  });
-}
-
-export { mapEventIterator as m };