@orpc/openapi 1.14.11 → 1.14.12

package/dist/shared/openapi.zZH_UksW.mjs

@@ -1,278 +0,0 @@
-import { wrapAsyncIteratorPreservingEventMeta, toORPCError, isORPCErrorJson, createORPCErrorFromJson } from '@orpc/client';
-import { isPlainObject, isAsyncIteratorObject } from '@orpc/shared';
-import { ErrorEvent } from '@standardserver/core';
-import { B as BracketNotationSerializer } from './openapi.Bt87OzTt.mjs';
-
-const DEFAULT_OPENAPI_METHOD = "POST";
-const DEFAULT_OPENAPI_SUCCESS_DESCRIPTION = "OK";
-const DEFAULT_OPENAPI_INPUT_STRUCTURE = "compact";
-const DEFAULT_OPENAPI_OUTPUT_STRUCTURE = "compact";
-
-const DEFAULT_OPEN_API_JSON_SERIALIZER_HANDLERS = {
-  undefined: {
-    condition(data) {
-      return data === void 0;
-    },
-    serialize() {
-      return null;
-    },
-    isTerminal: true
-  },
-  bigint: {
-    condition(data) {
-      return typeof data === "bigint";
-    },
-    serialize(data) {
-      return data.toString();
-    },
-    isTerminal: true
-  },
-  date: {
-    condition(data) {
-      return data instanceof Date;
-    },
-    serialize(data) {
-      if (Number.isNaN(data.getTime())) {
-        return null;
-      }
-      return data.toISOString();
-    },
-    isTerminal: true
-  },
-  nan: {
-    condition(data) {
-      return typeof data === "number" && Number.isNaN(data);
-    },
-    serialize() {
-      return null;
-    },
-    isTerminal: true
-  },
-  url: {
-    condition(data) {
-      return data instanceof URL;
-    },
-    serialize(data) {
-      return data.toString();
-    },
-    isTerminal: true
-  },
-  regexp: {
-    condition(data) {
-      return data instanceof RegExp;
-    },
-    serialize(data) {
-      return data.toString();
-    },
-    isTerminal: true
-  },
-  set: {
-    condition(data) {
-      return data instanceof Set;
-    },
-    serialize(data) {
-      return Array.from(data);
-    }
-  },
-  map: {
-    condition(data) {
-      return data instanceof Map;
-    },
-    serialize(data) {
-      return Array.from(data.entries());
-    }
-  }
-};
-class OpenAPIJsonSerializer {
-  handlers;
-  omitUndefinedProperties;
-  constructor(options = {}) {
-    this.handlers = {
-      ...DEFAULT_OPEN_API_JSON_SERIALIZER_HANDLERS,
-      ...options.handlers
-    };
-    this.omitUndefinedProperties = options.omitUndefinedProperties !== false;
-  }
-  serialize(data) {
-    const [json, maps, blobs] = this.serializeValue(data, [], [], []);
-    return { json, maps, blobs };
-  }
-  serializeValue(data, segments, 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) {
-          return [serialized, maps, blobs];
-        }
-        const result = this.serializeValue(serialized, segments, maps, blobs);
-        return result;
-      }
-    }
-    if (data instanceof Blob) {
-      maps.push(segments);
-      blobs.push(data);
-      return [data, maps, blobs];
-    }
-    if (Array.isArray(data)) {
-      const json = data.map((v, i) => {
-        return this.serializeValue(v, [...segments, i], maps, blobs)[0];
-      });
-      return [json, 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], maps, blobs)[0];
-      }
-      return [json, maps, blobs];
-    }
-    return [data, 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];
-      });
-    }
-    return ref.data;
-  }
-}
-
-class OpenAPISerializer {
-  jsonSerializer;
-  bracketNotation;
-  defaultSerializeOptions;
-  constructor({ bracketNotation, serialize, ...options } = {}) {
-    this.jsonSerializer = new OpenAPIJsonSerializer(options);
-    this.bracketNotation = new BracketNotationSerializer(bracketNotation);
-    this.defaultSerializeOptions = serialize;
-  }
-  serialize(data, options = {}) {
-    const useFormDataForBlobFields = options.useFormDataForBlobFields ?? this.defaultSerializeOptions?.useFormDataForBlobFields ?? true;
-    const asFormData = options.asFormData ?? this.defaultSerializeOptions?.asFormData ?? false;
-    if (!options.asFormData) {
-      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, { asFormData: false, useFormDataForBlobFields: false }) };
-          },
-          mapError: (e) => {
-            return new ErrorEvent({
-              data: this.serializeValue(toORPCError(e).toJSON(), { asFormData: false, useFormDataForBlobFields: false }),
-              cause: e
-            });
-          }
-        });
-      }
-    }
-    return this.serializeValue(data, { useFormDataForBlobFields, asFormData });
-  }
-  serializeValue(value, options) {
-    const { json, blobs } = this.jsonSerializer.serialize(value);
-    if (!options.asFormData && (json instanceof Blob || json === void 0 || !blobs?.length || !options.useFormDataForBlobFields)) {
-      return json;
-    }
-    const form = new FormData();
-    for (const [path, value2] of this.bracketNotation.serialize(json)) {
-      if (value2 instanceof Blob) {
-        form.append(path, value2);
-      } else if (value2 !== void 0 && value2 !== null) {
-        form.append(path, String(value2));
-      }
-    }
-    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.jsonSerializer.deserialize({ json: result.value }) };
-        },
-        mapError: (e) => {
-          if (e instanceof ErrorEvent) {
-            const deserialized = this.jsonSerializer.deserialize({ json: e.data });
-            if (isORPCErrorJson(deserialized)) {
-              return createORPCErrorFromJson(deserialized, { cause: e });
-            }
-          }
-          return e;
-        }
-      });
-    }
-    if (data instanceof URLSearchParams || data instanceof FormData) {
-      data = this.bracketNotation.deserialize(Array.from(data.entries()));
-    }
-    return this.jsonSerializer.deserialize({ json: data });
-  }
-}
-
-function isBodylessMethod(method) {
-  return method === "GET" || method === "HEAD";
-}
-const PARAMETER_NAME_REGEX = /^[\w-]+$/;
-function getDynamicPathParams(path) {
-  if (!path.includes("{")) {
-    return void 0;
-  }
-  const len = path.length;
-  let params;
-  let index = 1;
-  while (index < len) {
-    const segmentStart = index;
-    const slashPos = path.indexOf("/", index);
-    const segmentEnd = slashPos === -1 ? len : slashPos;
-    if (segmentEnd > segmentStart && path.charCodeAt(segmentStart) === 123 && path.charCodeAt(segmentEnd - 1) === 125) {
-      let parameterStart = segmentStart + 1;
-      let allowsSlash = false;
-      const operator = path.charCodeAt(parameterStart);
-      if (operator === 43) {
-        allowsSlash = true;
-        parameterStart++;
-      }
-      const parameterName = path.slice(parameterStart, segmentEnd - 1);
-      if (PARAMETER_NAME_REGEX.test(parameterName)) {
-        params ??= [];
-        params.push({
-          segment: path.slice(segmentStart, segmentEnd),
-          startIndex: segmentStart,
-          parameterName,
-          allowsSlash
-        });
-      }
-    }
-    index = segmentEnd + 1;
-  }
-  return params;
-}
-
-export { DEFAULT_OPENAPI_METHOD as D, OpenAPISerializer as O, DEFAULT_OPENAPI_INPUT_STRUCTURE as a, DEFAULT_OPENAPI_OUTPUT_STRUCTURE as b, DEFAULT_OPENAPI_SUCCESS_DESCRIPTION as c, OpenAPIJsonSerializer as d, getDynamicPathParams as g, isBodylessMethod as i };