@orpc/client 0.0.0-next.ff5907c → 0.0.0-next.ff7ad2e

package/dist/chunk-TPEMQB7D.js

@@ -1,178 +0,0 @@
-import {
-  ORPCError,
-  mapEventIterator,
-  toORPCError
-} from "./chunk-2UPNYYFF.js";
-
-// src/rpc/serializer.ts
-import { ErrorEvent, isAsyncIteratorObject } from "@orpc/server-standard";
-import { findDeepMatches, isObject, set } from "@orpc/shared";
-var RPCSerializer = class {
-  serialize(data) {
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => serializeRPCJson(value),
-        error: async (e) => {
-          if (e instanceof ErrorEvent) {
-            return new ErrorEvent({
-              data: serializeRPCJson(e.data),
-              cause: e
-            });
-          }
-          return new ErrorEvent({
-            data: serializeRPCJson(toORPCError(e).toJSON()),
-            cause: e
-          });
-        }
-      });
-    }
-    const serializedJSON = serializeRPCJson(data);
-    const { maps, values: blobs } = findDeepMatches((v) => v instanceof Blob, serializedJSON.json);
-    if (blobs.length === 0) {
-      return serializedJSON;
-    }
-    const form = new FormData();
-    form.set("data", JSON.stringify(serializedJSON));
-    form.set("maps", JSON.stringify(maps));
-    for (const i in blobs) {
-      form.set(i, blobs[i]);
-    }
-    return form;
-  }
-  deserialize(serialized) {
-    if (isAsyncIteratorObject(serialized)) {
-      return mapEventIterator(serialized, {
-        value: async (value) => deserializeRPCJson(value),
-        error: async (e) => {
-          if (!(e instanceof ErrorEvent)) {
-            return e;
-          }
-          const deserialized = deserializeRPCJson(e.data);
-          if (ORPCError.isValidJSON(deserialized)) {
-            return ORPCError.fromJSON(deserialized, { cause: e });
-          }
-          return new ErrorEvent({
-            data: deserialized,
-            cause: e
-          });
-        }
-      });
-    }
-    if (!(serialized instanceof FormData)) {
-      return deserializeRPCJson(serialized);
-    }
-    const data = JSON.parse(serialized.get("data"));
-    const maps = JSON.parse(serialized.get("maps"));
-    for (const i in maps) {
-      data.json = set(data.json, maps[i], serialized.get(i));
-    }
-    return deserializeRPCJson(data);
-  }
-};
-function serializeRPCJson(value, segments = [], meta = []) {
-  if (typeof value === "bigint") {
-    meta.push(["bigint", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (value instanceof Date) {
-    meta.push(["date", segments]);
-    const data = Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
-    return { json: data, meta };
-  }
-  if (Number.isNaN(value)) {
-    meta.push(["nan", segments]);
-    return { json: "NaN", meta };
-  }
-  if (value instanceof RegExp) {
-    meta.push(["regexp", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (value instanceof URL) {
-    meta.push(["url", segments]);
-    return { json: value.toString(), meta };
-  }
-  if (isObject(value)) {
-    const json = {};
-    for (const k in value) {
-      json[k] = serializeRPCJson(value[k], [...segments, k], meta).json;
-    }
-    return { json, meta };
-  }
-  if (Array.isArray(value)) {
-    const json = value.map((v, i) => {
-      if (v === void 0) {
-        meta.push(["undefined", [...segments, i]]);
-        return null;
-      }
-      return serializeRPCJson(v, [...segments, i], meta).json;
-    });
-    return { json, meta };
-  }
-  if (value instanceof Set) {
-    const result = serializeRPCJson(Array.from(value), segments, meta);
-    meta.push(["set", segments]);
-    return result;
-  }
-  if (value instanceof Map) {
-    const result = serializeRPCJson(Array.from(value.entries()), segments, meta);
-    meta.push(["map", segments]);
-    return result;
-  }
-  return { json: value, meta };
-}
-function deserializeRPCJson({
-  json,
-  meta
-}) {
-  if (meta.length === 0) {
-    return json;
-  }
-  const ref = { data: json };
-  for (const [type, segments] of meta) {
-    let currentRef = ref;
-    let preSegment = "data";
-    for (let i = 0; i < segments.length; i++) {
-      currentRef = currentRef[preSegment];
-      preSegment = segments[i];
-    }
-    switch (type) {
-      case "nan":
-        currentRef[preSegment] = Number.NaN;
-        break;
-      case "bigint":
-        currentRef[preSegment] = BigInt(currentRef[preSegment]);
-        break;
-      case "date":
-        currentRef[preSegment] = new Date(currentRef[preSegment]);
-        break;
-      case "regexp": {
-        const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
-        currentRef[preSegment] = new RegExp(pattern, flags);
-        break;
-      }
-      case "url":
-        currentRef[preSegment] = new URL(currentRef[preSegment]);
-        break;
-      case "undefined":
-        currentRef[preSegment] = void 0;
-        break;
-      case "map":
-        currentRef[preSegment] = new Map(currentRef[preSegment]);
-        break;
-      case "set":
-        currentRef[preSegment] = new Set(currentRef[preSegment]);
-        break;
-      /* v8 ignore next 3 */
-      default: {
-        const _expected = type;
-      }
-    }
-  }
-  return ref.data;
-}
-
-export {
-  RPCSerializer,
-  serializeRPCJson
-};
-//# sourceMappingURL=chunk-TPEMQB7D.js.map

package/dist/fetch.js

@@ -1,128 +0,0 @@
-import {
-  RPCSerializer
-} from "./chunk-TPEMQB7D.js";
-import {
-  ORPCError,
-  createAutoRetryEventIterator
-} from "./chunk-2UPNYYFF.js";
-
-// src/adapters/fetch/rpc-link.ts
-import { isAsyncIteratorObject } from "@orpc/server-standard";
-import { toFetchBody, toStandardBody } from "@orpc/server-standard-fetch";
-import { trim, value } from "@orpc/shared";
-var InvalidEventSourceRetryResponse = class extends Error {
-};
-var RPCLink = class {
-  fetch;
-  rpcSerializer;
-  maxUrlLength;
-  fallbackMethod;
-  method;
-  headers;
-  url;
-  eventSourceMaxNumberOfRetries;
-  eventSourceRetryDelay;
-  eventSourceRetry;
-  constructor(options) {
-    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
-    this.maxUrlLength = options.maxUrlLength ?? 2083;
-    this.fallbackMethod = options.fallbackMethod ?? "POST";
-    this.url = options.url;
-    this.eventSourceMaxNumberOfRetries = options.eventSourceMaxNumberOfRetries ?? 5;
-    this.method = options.method ?? this.fallbackMethod;
-    this.headers = options.headers ?? {};
-    this.eventSourceRetry = options.eventSourceRetry ?? true;
-    this.eventSourceRetryDelay = options.eventSourceRetryDelay ?? (({ retryTimes, lastRetry }) => lastRetry ?? 1e3 * 2 ** retryTimes);
-  }
-  async call(path, input, options) {
-    const output = await this.performCall(path, input, options);
-    if (!isAsyncIteratorObject(output)) {
-      return output;
-    }
-    return createAutoRetryEventIterator(output, async (reconnectOptions) => {
-      if (options.signal?.aborted || reconnectOptions.retryTimes > this.eventSourceMaxNumberOfRetries) {
-        return null;
-      }
-      if (!await value(this.eventSourceRetry, reconnectOptions, options, path, input)) {
-        return null;
-      }
-      const delay = await value(this.eventSourceRetryDelay, reconnectOptions, options, path, input);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      const updatedOptions = { ...options, lastEventId: reconnectOptions.lastEventId };
-      const maybeIterator = await this.performCall(path, input, updatedOptions);
-      if (!isAsyncIteratorObject(maybeIterator)) {
-        throw new InvalidEventSourceRetryResponse("Invalid EventSource retry response");
-      }
-      return maybeIterator;
-    }, void 0);
-  }
-  async performCall(path, input, options) {
-    const encoded = await this.encodeRequest(path, input, options);
-    const fetchBody = toFetchBody(encoded.body, encoded.headers);
-    if (options.lastEventId !== void 0) {
-      encoded.headers.set("last-event-id", options.lastEventId);
-    }
-    const response = await this.fetch(encoded.url, {
-      method: encoded.method,
-      headers: encoded.headers,
-      body: fetchBody,
-      signal: options.signal
-    }, options, path, input);
-    const body = await toStandardBody(response);
-    const deserialized = (() => {
-      try {
-        return this.rpcSerializer.deserialize(body);
-      } catch (error) {
-        if (response.ok) {
-          throw new ORPCError("INTERNAL_SERVER_ERROR", {
-            message: "Invalid RPC response",
-            cause: error
-          });
-        }
-        throw new ORPCError(response.status.toString(), {
-          message: response.statusText
-        });
-      }
-    })();
-    if (!response.ok) {
-      if (ORPCError.isValidJSON(deserialized)) {
-        throw ORPCError.fromJSON(deserialized);
-      }
-      throw new ORPCError("INTERNAL_SERVER_ERROR", {
-        message: "Invalid RPC error response",
-        cause: deserialized
-      });
-    }
-    return deserialized;
-  }
-  async encodeRequest(path, input, options) {
-    const expectedMethod = await value(this.method, options, path, input);
-    const headers = new Headers(await value(this.headers, options, path, input));
-    const url = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
-    const serialized = this.rpcSerializer.serialize(input);
-    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
-      const getUrl = new URL(url);
-      getUrl.searchParams.append("data", JSON.stringify(serialized));
-      if (getUrl.toString().length <= this.maxUrlLength) {
-        return {
-          body: void 0,
-          method: expectedMethod,
-          headers,
-          url: getUrl
-        };
-      }
-    }
-    return {
-      url,
-      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
-      headers,
-      body: serialized
-    };
-  }
-};
-export {
-  InvalidEventSourceRetryResponse,
-  RPCLink
-};
-//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,81 +0,0 @@
-import {
-  COMMON_ORPC_ERROR_DEFS,
-  ORPCError,
-  createAutoRetryEventIterator,
-  fallbackORPCErrorMessage,
-  fallbackORPCErrorStatus,
-  isDefinedError,
-  mapEventIterator,
-  onEventIteratorStatusChange,
-  registerEventIteratorState,
-  toORPCError,
-  updateEventIteratorStatus
-} from "./chunk-2UPNYYFF.js";
-
-// src/client.ts
-function createORPCClient(link, options) {
-  const path = options?.path ?? [];
-  const procedureClient = async (...[input, options2]) => {
-    const optionsOut = {
-      ...options2,
-      context: options2?.context ?? {}
-      // options.context can be undefined when all field is optional
-    };
-    return await link.call(path, input, optionsOut);
-  };
-  const recursive = new Proxy(procedureClient, {
-    get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
-      }
-      return createORPCClient(link, {
-        ...options,
-        path: [...path, key]
-      });
-    }
-  });
-  return recursive;
-}
-
-// src/dynamic-link.ts
-var DynamicLink = class {
-  constructor(linkResolver) {
-    this.linkResolver = linkResolver;
-  }
-  async call(path, input, options) {
-    const resolvedLink = await this.linkResolver(options, path, input);
-    const output = await resolvedLink.call(path, input, options);
-    return output;
-  }
-};
-
-// src/utils.ts
-async function safe(promise) {
-  try {
-    const output = await promise;
-    return [output, void 0, false];
-  } catch (e) {
-    const error = e;
-    if (isDefinedError(error)) {
-      return [void 0, error, true];
-    }
-    return [void 0, error, false];
-  }
-}
-export {
-  COMMON_ORPC_ERROR_DEFS,
-  DynamicLink,
-  ORPCError,
-  createAutoRetryEventIterator,
-  createORPCClient,
-  fallbackORPCErrorMessage,
-  fallbackORPCErrorStatus,
-  isDefinedError,
-  mapEventIterator,
-  onEventIteratorStatusChange,
-  registerEventIteratorState,
-  safe,
-  toORPCError,
-  updateEventIteratorStatus
-};
-//# sourceMappingURL=index.js.map

package/dist/openapi.js

@@ -1,329 +0,0 @@
-import {
-  ORPCError,
-  __export,
-  mapEventIterator,
-  toORPCError
-} from "./chunk-2UPNYYFF.js";
-
-// src/openapi/bracket-notation.ts
-var bracket_notation_exports = {};
-__export(bracket_notation_exports, {
-  deserialize: () => deserialize,
-  escapeSegment: () => escapeSegment,
-  parsePath: () => parsePath,
-  serialize: () => serialize,
-  stringifyPath: () => stringifyPath
-});
-import { isObject } from "@orpc/shared";
-function serialize(payload, parentKey = "") {
-  if (!Array.isArray(payload) && !isObject(payload))
-    return [["", payload]];
-  const result = [];
-  function helper(value, path) {
-    if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        helper(item, [...path, String(index)]);
-      });
-    } else if (isObject(value)) {
-      for (const [key, val] of Object.entries(value)) {
-        helper(val, [...path, key]);
-      }
-    } else {
-      result.push([stringifyPath(path), value]);
-    }
-  }
-  helper(payload, parentKey ? [parentKey] : []);
-  return result;
-}
-function deserialize(entities) {
-  if (entities.length === 0) {
-    return void 0;
-  }
-  const isRootArray = entities.every(([path]) => path === "");
-  const result = isRootArray ? [] : {};
-  const arrayPushPaths = /* @__PURE__ */ new Set();
-  for (const [path, _] of entities) {
-    const segments = parsePath(path);
-    const base = segments.slice(0, -1).join(".");
-    const last = segments[segments.length - 1];
-    if (last === "") {
-      arrayPushPaths.add(base);
-    } else {
-      arrayPushPaths.delete(base);
-    }
-  }
-  function setValue(obj, segments, value, fullPath) {
-    const [first, ...rest_] = segments;
-    if (Array.isArray(obj) && first === "") {
-      ;
-      obj.push(value);
-      return;
-    }
-    const objAsRecord = obj;
-    if (rest_.length === 0) {
-      objAsRecord[first] = value;
-      return;
-    }
-    const rest = rest_;
-    if (rest[0] === "") {
-      const pathToCheck = segments.slice(0, -1).join(".");
-      if (rest.length === 1 && arrayPushPaths.has(pathToCheck)) {
-        if (!(first in objAsRecord)) {
-          objAsRecord[first] = [];
-        }
-        if (Array.isArray(objAsRecord[first])) {
-          ;
-          objAsRecord[first].push(value);
-          return;
-        }
-      }
-      if (!(first in objAsRecord)) {
-        objAsRecord[first] = {};
-      }
-      const target = objAsRecord[first];
-      target[""] = value;
-      return;
-    }
-    if (!(first in objAsRecord)) {
-      objAsRecord[first] = {};
-    }
-    setValue(
-      objAsRecord[first],
-      rest,
-      value,
-      fullPath
-    );
-  }
-  for (const [path, value] of entities) {
-    const segments = parsePath(path);
-    setValue(result, segments, value, path);
-  }
-  return result;
-}
-function escapeSegment(segment) {
-  return segment.replace(/[\\[\]]/g, (match) => {
-    switch (match) {
-      case "\\":
-        return "\\\\";
-      case "[":
-        return "\\[";
-      case "]":
-        return "\\]";
-      default:
-        return match;
-    }
-  });
-}
-function stringifyPath(path) {
-  const [first, ...rest] = path;
-  const firstSegment = escapeSegment(first);
-  const base = first === "" ? "" : firstSegment;
-  return rest.reduce(
-    (result, segment) => `${result}[${escapeSegment(segment)}]`,
-    base
-  );
-}
-function parsePath(path) {
-  if (path === "")
-    return [""];
-  const result = [];
-  let currentSegment = "";
-  let inBracket = false;
-  let bracketContent = "";
-  let backslashCount = 0;
-  for (let i = 0; i < path.length; i++) {
-    const char = path[i];
-    if (char === "\\") {
-      backslashCount++;
-      continue;
-    }
-    if (backslashCount > 0) {
-      const literalBackslashes = "\\".repeat(Math.floor(backslashCount / 2));
-      if (char === "[" || char === "]") {
-        if (backslashCount % 2 === 1) {
-          if (inBracket) {
-            bracketContent += literalBackslashes + char;
-          } else {
-            currentSegment += literalBackslashes + char;
-          }
-        } else {
-          if (inBracket) {
-            bracketContent += literalBackslashes;
-          } else {
-            currentSegment += literalBackslashes;
-          }
-          if (char === "[" && !inBracket) {
-            if (currentSegment !== "" || result.length === 0) {
-              result.push(currentSegment);
-            }
-            inBracket = true;
-            bracketContent = "";
-            currentSegment = "";
-          } else if (char === "]" && inBracket) {
-            result.push(bracketContent);
-            inBracket = false;
-            bracketContent = "";
-          } else {
-            if (inBracket) {
-              bracketContent += char;
-            } else {
-              currentSegment += char;
-            }
-          }
-        }
-      } else {
-        const allBackslashes = "\\".repeat(backslashCount);
-        if (inBracket) {
-          bracketContent += allBackslashes + char;
-        } else {
-          currentSegment += allBackslashes + char;
-        }
-      }
-      backslashCount = 0;
-      continue;
-    }
-    if (char === "[" && !inBracket) {
-      if (currentSegment !== "" || result.length === 0) {
-        result.push(currentSegment);
-      }
-      inBracket = true;
-      bracketContent = "";
-      currentSegment = "";
-      continue;
-    }
-    if (char === "]" && inBracket) {
-      result.push(bracketContent);
-      inBracket = false;
-      bracketContent = "";
-      continue;
-    }
-    if (inBracket) {
-      bracketContent += char;
-    } else {
-      currentSegment += char;
-    }
-  }
-  if (backslashCount > 0) {
-    const remainingBackslashes = "\\".repeat(backslashCount);
-    if (inBracket) {
-      bracketContent += remainingBackslashes;
-    } else {
-      currentSegment += remainingBackslashes;
-    }
-  }
-  if (inBracket) {
-    if (currentSegment !== "" || result.length === 0) {
-      result.push(currentSegment);
-    }
-    result.push(`[${bracketContent}`);
-  } else if (currentSegment !== "" || result.length === 0) {
-    result.push(currentSegment);
-  }
-  return result;
-}
-
-// src/openapi/json-serializer.ts
-import { isObject as isObject2 } from "@orpc/shared";
-var OpenAPIJsonSerializer = class {
-  serialize(payload) {
-    if (payload instanceof Set)
-      return this.serialize([...payload]);
-    if (payload instanceof Map)
-      return this.serialize([...payload.entries()]);
-    if (Array.isArray(payload)) {
-      return payload.map((v) => v === void 0 ? "undefined" : this.serialize(v));
-    }
-    if (Number.isNaN(payload))
-      return "NaN";
-    if (typeof payload === "bigint")
-      return payload.toString();
-    if (payload instanceof Date && Number.isNaN(payload.getTime())) {
-      return "Invalid Date";
-    }
-    if (payload instanceof RegExp)
-      return payload.toString();
-    if (payload instanceof URL)
-      return payload.toString();
-    if (!isObject2(payload))
-      return payload;
-    return Object.keys(payload).reduce(
-      (carry, key) => {
-        const val = payload[key];
-        carry[key] = this.serialize(val);
-        return carry;
-      },
-      {}
-    );
-  }
-};
-
-// src/openapi/serializer.ts
-import { ErrorEvent, isAsyncIteratorObject } from "@orpc/server-standard";
-import { findDeepMatches } from "@orpc/shared";
-var OpenAPISerializer = class {
-  jsonSerializer;
-  constructor(options) {
-    this.jsonSerializer = options?.jsonSerializer ?? new OpenAPIJsonSerializer();
-  }
-  serialize(data) {
-    if (data instanceof Blob || data === void 0) {
-      return data;
-    }
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => this.jsonSerializer.serialize(value),
-        error: async (e) => {
-          if (e instanceof ErrorEvent) {
-            return new ErrorEvent({
-              data: this.jsonSerializer.serialize(e.data),
-              cause: e
-            });
-          }
-          return new ErrorEvent({
-            data: this.jsonSerializer.serialize(toORPCError(e).toJSON()),
-            cause: e
-          });
-        }
-      });
-    }
-    const serializedJSON = this.jsonSerializer.serialize(data);
-    const { values: blobs } = findDeepMatches((v) => v instanceof Blob, serializedJSON);
-    if (blobs.length === 0) {
-      return serializedJSON;
-    }
-    const form = new FormData();
-    for (const [path, value] of serialize(serializedJSON)) {
-      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        form.append(path, value.toString());
-      } else if (value instanceof Date) {
-        form.append(path, value.toISOString());
-      } else if (value instanceof Blob) {
-        form.append(path, value);
-      }
-    }
-    return form;
-  }
-  deserialize(serialized) {
-    if (serialized instanceof URLSearchParams || serialized instanceof FormData) {
-      return deserialize([...serialized.entries()]);
-    }
-    if (isAsyncIteratorObject(serialized)) {
-      return mapEventIterator(serialized, {
-        value: async (value) => value,
-        error: async (e) => {
-          if (e instanceof ErrorEvent && ORPCError.isValidJSON(e.data)) {
-            return ORPCError.fromJSON(e.data, { cause: e });
-          }
-          return e;
-        }
-      });
-    }
-    return serialized;
-  }
-};
-export {
-  bracket_notation_exports as BracketNotation,
-  OpenAPIJsonSerializer,
-  OpenAPISerializer
-};
-//# sourceMappingURL=openapi.js.map