@orpc/client 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/shared/client.DMXKFDyV.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 wrapEventIteratorPreservingMeta(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 wrapEventIteratorPreservingMeta(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 wrapEventIteratorPreservingMeta(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.entries()) {
-      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, wrapEventIteratorPreservingMeta as w };