@temporary-name/zod 1.9.3-alpha.e09726e1bf5340c7b7052eeabcb4935b3c85ce93 → 1.9.3-alpha.e2d8d164da72fb570c2b14a4fa956c80f9e33cdc

package/dist/zod4/index.mjs

@@ -1,743 +0,0 @@
-import { isObject, guard, intercept, toArray } from '@temporary-name/shared';
-import { JsonSchemaXNativeType } from '@temporary-name/json-schema';
-import { JSONSchemaFormat, JSONSchemaContentEncoding } from '@temporary-name/server/openapi';
-import { registry, globalRegistry } from 'zod/v4/core';
-
-class experimental_ZodSmartCoercionPlugin {
-  init(options) {
-    options.clientInterceptors ??= [];
-    options.clientInterceptors.unshift((options2) => {
-      const inputSchema = options2.procedure["~orpc"].inputSchema;
-      if (!inputSchema || inputSchema["~standard"].vendor !== "zod" || !("_zod" in inputSchema)) {
-        return options2.next();
-      }
-      const coercedInput = this.#coerce(inputSchema, options2.input);
-      return options2.next({ ...options2, input: coercedInput });
-    });
-  }
-  #coerce(schema, value) {
-    switch (schema._zod.def.type) {
-      case "number": {
-        if (typeof value === "string") {
-          return this.#stringToNumber(value);
-        }
-        return value;
-      }
-      case "bigint": {
-        if (typeof value === "string") {
-          return this.#stringToBigInt(value);
-        }
-        return value;
-      }
-      case "boolean":
-      case "success": {
-        if (typeof value === "string") {
-          return this.#stringToBoolean(value);
-        }
-        return value;
-      }
-      case "date": {
-        if (typeof value === "string") {
-          return this.#stringToDate(value);
-        }
-        return value;
-      }
-      case "literal":
-      case "enum": {
-        const literal = schema;
-        if (!literal._zod.values.has(value) && typeof value === "string") {
-          const num = this.#stringToNumber(value);
-          if (literal._zod.values.has(num)) {
-            return num;
-          }
-          const bool = this.#stringToBoolean(value);
-          if (literal._zod.values.has(bool)) {
-            return bool;
-          }
-          const bigint = this.#stringToBigInt(value);
-          if (literal._zod.values.has(bigint)) {
-            return bigint;
-          }
-        }
-        return value;
-      }
-      case "array": {
-        const array = schema;
-        if (value === void 0) {
-          return [];
-        }
-        if (Array.isArray(value)) {
-          return value.map((v) => this.#coerce(array._zod.def.element, v));
-        }
-        return value;
-      }
-      case "tuple": {
-        const tuple = schema;
-        if (value === void 0) {
-          return [];
-        }
-        if (Array.isArray(value)) {
-          return value.map((v, i) => {
-            const s = tuple._zod.def.items[i] ?? tuple._zod.def.rest;
-            return s ? this.#coerce(s, v) : v;
-          });
-        }
-        return value;
-      }
-      case "set": {
-        const set = schema;
-        if (value === void 0) {
-          return /* @__PURE__ */ new Set();
-        }
-        if (Array.isArray(value)) {
-          return new Set(value.map((v) => this.#coerce(set._zod.def.valueType, v)));
-        }
-        if (value instanceof Set) {
-          return new Set(Array.from(value).map((v) => this.#coerce(set._zod.def.valueType, v)));
-        }
-        return value;
-      }
-      case "object": {
-        const object = schema;
-        if (value === void 0) {
-          return {};
-        }
-        if (isObject(value)) {
-          const newObj = {};
-          const keys = /* @__PURE__ */ new Set([...Object.keys(value), ...Object.keys(object._zod.def.shape)]);
-          for (const k of keys) {
-            const s = object._zod.def.shape[k] ?? object._zod.def.catchall;
-            newObj[k] = s ? this.#coerce(s, value[k]) : value[k];
-          }
-          return newObj;
-        }
-        return value;
-      }
-      case "record": {
-        const record = schema;
-        if (value === void 0) {
-          return {};
-        }
-        if (isObject(value)) {
-          const newObj = {};
-          for (const [k, v] of Object.entries(value)) {
-            const key = this.#coerce(record._zod.def.keyType, k);
-            const val = this.#coerce(record._zod.def.valueType, v);
-            newObj[key] = val;
-          }
-          return newObj;
-        }
-        return value;
-      }
-      case "map": {
-        const map = schema;
-        if (value === void 0) {
-          return /* @__PURE__ */ new Map();
-        }
-        if (Array.isArray(value) && value.every((i) => Array.isArray(i) && i.length <= 2)) {
-          return new Map(
-            value.map(([k, v]) => [
-              this.#coerce(map._zod.def.keyType, k),
-              this.#coerce(map._zod.def.valueType, v)
-            ])
-          );
-        }
-        if (value instanceof Map) {
-          return new Map(
-            Array.from(value).map(([k, v]) => [
-              this.#coerce(map._zod.def.keyType, k),
-              this.#coerce(map._zod.def.valueType, v)
-            ])
-          );
-        }
-        return value;
-      }
-      case "union": {
-        const union = schema;
-        if (union._zod.def.options.length === 1) {
-          return this.#coerce(union._zod.def.options[0], value);
-        }
-        if (isObject(value)) {
-          const discriminator = "discriminator" in union._zod.def && typeof union._zod.def.discriminator === "string" ? union._zod.def.discriminator : void 0;
-          for (const option of union._zod.def.options) {
-            if (!option._zod.propValues) {
-              continue;
-            }
-            if (discriminator !== void 0) {
-              if (option._zod.propValues[discriminator]?.has(value[discriminator])) {
-                return this.#coerce(option, value);
-              }
-            } else {
-              for (const key in option._zod.propValues) {
-                if (option._zod.propValues[key]?.has(value[key])) {
-                  return this.#coerce(option, value);
-                }
-              }
-            }
-          }
-        }
-        return value;
-      }
-      case "intersection": {
-        const intersection = schema;
-        return this.#coerce(intersection._zod.def.right, this.#coerce(intersection._zod.def.left, value));
-      }
-      case "optional": {
-        const optional = schema;
-        if (value === void 0) {
-          return void 0;
-        }
-        return this.#coerce(optional._zod.def.innerType, value);
-      }
-      case "nonoptional": {
-        const nonoptional = schema;
-        return this.#coerce(nonoptional._zod.def.innerType, value);
-      }
-      case "nullable": {
-        const nullable = schema;
-        if (value === null) {
-          return null;
-        }
-        return this.#coerce(nullable._zod.def.innerType, value);
-      }
-      case "readonly": {
-        const readonly_ = schema;
-        return this.#coerce(readonly_._zod.def.innerType, value);
-      }
-      case "pipe": {
-        const pipe = schema;
-        return this.#coerce(pipe._zod.def.in, value);
-      }
-      case "default":
-      case "prefault": {
-        const default_ = schema;
-        if (value === void 0) {
-          return value;
-        }
-        return this.#coerce(default_._zod.def.innerType, value);
-      }
-      case "catch": {
-        const catch_ = schema;
-        return this.#coerce(catch_._zod.def.innerType, value);
-      }
-      case "lazy": {
-        const lazy = schema;
-        if (value !== void 0) {
-          return this.#coerce(lazy._zod.def.getter(), value);
-        }
-        return value;
-      }
-      default: {
-        schema._zod.def.type;
-        return value;
-      }
-    }
-  }
-  #stringToNumber(value) {
-    const num = Number(value);
-    return Number.isNaN(num) || num.toString() !== value ? value : num;
-  }
-  #stringToBigInt(value) {
-    return guard(() => BigInt(value)) ?? value;
-  }
-  #stringToBoolean(value) {
-    const lower = value.toLowerCase();
-    if (lower === "false" || lower === "off" || lower === "f") {
-      return false;
-    }
-    if (lower === "true" || lower === "on" || lower === "t") {
-      return true;
-    }
-    return value;
-  }
-  #stringToDate(value) {
-    const date = new Date(value);
-    if (!Number.isNaN(date.getTime()) && date.toISOString().startsWith(value)) {
-      return date;
-    }
-    return value;
-  }
-}
-
-const JSON_SCHEMA_REGISTRY = registry();
-const JSON_SCHEMA_INPUT_REGISTRY = registry();
-const JSON_SCHEMA_OUTPUT_REGISTRY = registry();
-
-class ZodToJsonSchemaConverter {
-  maxLazyDepth;
-  maxStructureDepth;
-  anyJsonSchema;
-  unsupportedJsonSchema;
-  undefinedJsonSchema;
-  interceptors;
-  constructor(options = {}) {
-    this.maxLazyDepth = options.maxLazyDepth ?? 2;
-    this.maxStructureDepth = options.maxStructureDepth ?? 10;
-    this.anyJsonSchema = options.anyJsonSchema ?? {};
-    this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };
-    this.undefinedJsonSchema = options.undefinedJsonSchema ?? { not: {} };
-    this.interceptors = options.interceptors ?? [];
-  }
-  condition(schema) {
-    return schema !== void 0 && schema["~standard"].vendor === "zod" && "_zod" in schema;
-  }
-  convert(schema, options) {
-    return this.#convert(schema, options, 0, 0);
-  }
-  #convert(schema, options, lazyDepth, structureDepth, isHandledCustomJSONSchema = false) {
-    return intercept(
-      this.interceptors,
-      { schema, options, lazyDepth, isHandledCustomJSONSchema },
-      ({ schema: schema2, options: options2, lazyDepth: lazyDepth2, isHandledCustomJSONSchema: isHandledCustomJSONSchema2 }) => {
-        if (structureDepth > this.maxStructureDepth) {
-          return [false, this.anyJsonSchema];
-        }
-        if (!options2.minStructureDepthForRef || options2.minStructureDepthForRef <= structureDepth) {
-          const components = toArray(options2.components);
-          for (const component of components) {
-            if (component.schema === schema2 && component.allowedStrategies.includes(options2.strategy)) {
-              return [component.required, { $ref: component.ref }];
-            }
-          }
-        }
-        if (!isHandledCustomJSONSchema2) {
-          const customJSONSchema = this.#getCustomJsonSchema(schema2, options2);
-          if (customJSONSchema) {
-            const [required, json] = this.#convert(schema2, options2, lazyDepth2, structureDepth, true);
-            return [required, { ...json, ...customJSONSchema }];
-          }
-        }
-        switch (schema2._zod.def.type) {
-          case "string": {
-            const string = schema2;
-            const json = { type: "string" };
-            const { minimum, maximum, format, patterns, contentEncoding } = string._zod.bag;
-            if (typeof minimum === "number") {
-              json.minLength = minimum;
-            }
-            if (typeof maximum === "number") {
-              json.maxLength = maximum;
-            }
-            if (typeof contentEncoding === "string") {
-              json.contentEncoding = this.#handleContentEncoding(contentEncoding);
-            }
-            if (typeof format === "string" && format !== "regex" && json.contentEncoding === void 0) {
-              json.format = this.#handleStringFormat(format);
-            }
-            if (patterns instanceof Set && json.contentEncoding === void 0 && json.format === void 0) {
-              for (const pattern of patterns) {
-                if (json.pattern === void 0) {
-                  json.pattern = pattern.source;
-                } else {
-                  json.allOf ??= [];
-                  json.allOf.push({ pattern: pattern.source });
-                }
-              }
-            }
-            if (format === "jwt" && json.contentEncoding === void 0 && json.format === void 0 && json.pattern === void 0) {
-              json.pattern = /^[\w-]+\.[\w-]+\.[\w-]+$/.source;
-            }
-            return [true, json];
-          }
-          case "number": {
-            const number = schema2;
-            const json = { type: "number" };
-            const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = number._zod.bag;
-            if (typeof format === "string" && format?.includes("int")) {
-              json.type = "integer";
-            }
-            if (typeof minimum === "number") {
-              json.minimum = minimum;
-            }
-            if (typeof maximum === "number") {
-              json.maximum = maximum;
-            }
-            if (typeof exclusiveMinimum === "number") {
-              json.exclusiveMinimum = exclusiveMinimum;
-            }
-            if (typeof exclusiveMaximum === "number") {
-              json.exclusiveMaximum = exclusiveMaximum;
-            }
-            if (typeof multipleOf === "number") {
-              json.multipleOf = multipleOf;
-            }
-            return [true, json];
-          }
-          case "boolean": {
-            return [true, { type: "boolean" }];
-          }
-          case "bigint": {
-            return [
-              true,
-              {
-                type: "string",
-                pattern: "^-?[0-9]+$",
-                "x-native-type": JsonSchemaXNativeType.BigInt
-              }
-            ];
-          }
-          case "date": {
-            return [
-              true,
-              {
-                type: "string",
-                format: JSONSchemaFormat.DateTime,
-                "x-native-type": JsonSchemaXNativeType.Date
-              }
-            ];
-          }
-          case "null": {
-            return [true, { type: "null" }];
-          }
-          case "undefined":
-          case "void": {
-            return [false, this.undefinedJsonSchema];
-          }
-          case "any": {
-            return [false, this.anyJsonSchema];
-          }
-          case "unknown": {
-            return [false, this.anyJsonSchema];
-          }
-          case "never": {
-            return [true, this.unsupportedJsonSchema];
-          }
-          case "array": {
-            const array = schema2;
-            const json = { type: "array" };
-            const { minimum, maximum } = array._zod.bag;
-            if (typeof minimum === "number") {
-              json.minItems = minimum;
-            }
-            if (typeof maximum === "number") {
-              json.maxItems = maximum;
-            }
-            json.items = this.#handleArrayItemJsonSchema(
-              this.#convert(array._zod.def.element, options2, lazyDepth2, structureDepth + 1),
-              options2
-            );
-            return [true, json];
-          }
-          case "object": {
-            const object = schema2;
-            const json = { type: "object" };
-            for (const [key, value] of Object.entries(object._zod.def.shape)) {
-              const [itemRequired, itemJson] = this.#convert(value, options2, lazyDepth2, structureDepth + 1);
-              json.properties ??= {};
-              json.properties[key] = itemJson;
-              if (itemRequired) {
-                json.required ??= [];
-                json.required.push(key);
-              }
-            }
-            if (object._zod.def.catchall) {
-              if (object._zod.def.catchall._zod.def.type === "never") {
-                json.additionalProperties = false;
-              } else {
-                const [_, addJson] = this.#convert(
-                  object._zod.def.catchall,
-                  options2,
-                  lazyDepth2,
-                  structureDepth + 1
-                );
-                json.additionalProperties = addJson;
-              }
-            }
-            return [true, json];
-          }
-          case "union": {
-            const union = schema2;
-            const anyOf = [];
-            let required = true;
-            for (const item of union._zod.def.options) {
-              const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth);
-              if (!itemRequired) {
-                required = false;
-              }
-              if (options2.strategy === "input") {
-                if (itemJson !== this.undefinedJsonSchema && itemJson !== this.unsupportedJsonSchema) {
-                  anyOf.push(itemJson);
-                }
-              } else {
-                if (itemJson !== this.undefinedJsonSchema) {
-                  anyOf.push(itemJson);
-                }
-              }
-            }
-            return [required, anyOf.length === 1 ? anyOf[0] : { anyOf }];
-          }
-          case "intersection": {
-            const intersection = schema2;
-            const json = { allOf: [] };
-            let required = false;
-            for (const item of [intersection._zod.def.left, intersection._zod.def.right]) {
-              const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth);
-              json.allOf.push(itemJson);
-              if (itemRequired) {
-                required = true;
-              }
-            }
-            return [required, json];
-          }
-          case "tuple": {
-            const tuple = schema2;
-            const json = { type: "array", prefixItems: [] };
-            for (const item of tuple._zod.def.items) {
-              json.prefixItems.push(
-                this.#handleArrayItemJsonSchema(
-                  this.#convert(item, options2, lazyDepth2, structureDepth + 1),
-                  options2
-                )
-              );
-            }
-            if (tuple._zod.def.rest) {
-              json.items = this.#handleArrayItemJsonSchema(
-                this.#convert(tuple._zod.def.rest, options2, lazyDepth2, structureDepth + 1),
-                options2
-              );
-            }
-            const { minimum, maximum } = tuple._zod.bag;
-            if (typeof minimum === "number") {
-              json.minItems = minimum;
-            }
-            if (typeof maximum === "number") {
-              json.maxItems = maximum;
-            }
-            return [true, json];
-          }
-          case "record": {
-            const record = schema2;
-            const json = { type: "object" };
-            json.propertyNames = this.#convert(
-              record._zod.def.keyType,
-              options2,
-              lazyDepth2,
-              structureDepth + 1
-            )[1];
-            json.additionalProperties = this.#convert(
-              record._zod.def.valueType,
-              options2,
-              lazyDepth2,
-              structureDepth + 1
-            )[1];
-            return [true, json];
-          }
-          case "map": {
-            const map = schema2;
-            return [
-              true,
-              {
-                type: "array",
-                items: {
-                  type: "array",
-                  prefixItems: [
-                    this.#handleArrayItemJsonSchema(
-                      this.#convert(map._zod.def.keyType, options2, lazyDepth2, structureDepth + 1),
-                      options2
-                    ),
-                    this.#handleArrayItemJsonSchema(
-                      this.#convert(map._zod.def.valueType, options2, lazyDepth2, structureDepth + 1),
-                      options2
-                    )
-                  ],
-                  maxItems: 2,
-                  minItems: 2
-                },
-                "x-native-type": JsonSchemaXNativeType.Map
-              }
-            ];
-          }
-          case "set": {
-            const set = schema2;
-            return [
-              true,
-              {
-                type: "array",
-                uniqueItems: true,
-                items: this.#handleArrayItemJsonSchema(
-                  this.#convert(set._zod.def.valueType, options2, lazyDepth2, structureDepth + 1),
-                  options2
-                ),
-                "x-native-type": JsonSchemaXNativeType.Set
-              }
-            ];
-          }
-          case "enum": {
-            const enum_ = schema2;
-            return [true, { enum: Object.values(enum_._zod.def.entries) }];
-          }
-          case "literal": {
-            const literal = schema2;
-            let required = true;
-            const values = /* @__PURE__ */ new Set();
-            for (const value of literal._zod.def.values) {
-              if (value === void 0) {
-                required = false;
-              } else {
-                values.add(typeof value === "bigint" ? value.toString() : value);
-              }
-            }
-            const json = values.size === 0 ? this.undefinedJsonSchema : values.size === 1 ? { const: values.values().next().value } : { enum: Array.from(values) };
-            return [required, json];
-          }
-          case "file": {
-            const file = schema2;
-            const oneOf = [];
-            const { mime } = file._zod.bag;
-            if (mime === void 0 || Array.isArray(mime) && mime.every((m) => typeof m === "string")) {
-              for (const type of mime ?? ["*/*"]) {
-                oneOf.push({
-                  type: "string",
-                  contentMediaType: type
-                });
-              }
-            }
-            return [true, oneOf.length === 1 ? oneOf[0] : { anyOf: oneOf }];
-          }
-          case "transform": {
-            return [false, this.anyJsonSchema];
-          }
-          case "nullable": {
-            const nullable = schema2;
-            const [required, json] = this.#convert(
-              nullable._zod.def.innerType,
-              options2,
-              lazyDepth2,
-              structureDepth
-            );
-            return [required, { anyOf: [json, { type: "null" }] }];
-          }
-          case "nonoptional": {
-            const nonoptional = schema2;
-            const [, json] = this.#convert(
-              nonoptional._zod.def.innerType,
-              options2,
-              lazyDepth2,
-              structureDepth
-            );
-            return [true, json];
-          }
-          case "success": {
-            return [true, { type: "boolean" }];
-          }
-          case "default":
-          case "prefault": {
-            const default_ = schema2;
-            const [, json] = this.#convert(default_._zod.def.innerType, options2, lazyDepth2, structureDepth);
-            return [
-              false,
-              {
-                ...json,
-                default: default_._zod.def.defaultValue
-              }
-            ];
-          }
-          case "catch": {
-            const catch_ = schema2;
-            return this.#convert(catch_._zod.def.innerType, options2, lazyDepth2, structureDepth);
-          }
-          case "nan": {
-            return [true, options2.strategy === "input" ? this.unsupportedJsonSchema : { type: "null" }];
-          }
-          case "pipe": {
-            const pipe = schema2;
-            return this.#convert(
-              options2.strategy === "input" ? pipe._zod.def.in : pipe._zod.def.out,
-              options2,
-              lazyDepth2,
-              structureDepth
-            );
-          }
-          case "readonly": {
-            const readonly_ = schema2;
-            const [required, json] = this.#convert(
-              readonly_._zod.def.innerType,
-              options2,
-              lazyDepth2,
-              structureDepth
-            );
-            return [required, { ...json, readOnly: true }];
-          }
-          case "template_literal": {
-            const templateLiteral = schema2;
-            return [
-              true,
-              {
-                type: "string",
-                pattern: templateLiteral._zod.pattern.source
-              }
-            ];
-          }
-          case "optional": {
-            const optional = schema2;
-            const [, json] = this.#convert(optional._zod.def.innerType, options2, lazyDepth2, structureDepth);
-            return [false, json];
-          }
-          case "lazy": {
-            const lazy = schema2;
-            const currentLazyDepth = lazyDepth2 + 1;
-            if (currentLazyDepth > this.maxLazyDepth) {
-              return [false, this.anyJsonSchema];
-            }
-            return this.#convert(lazy._zod.def.getter(), options2, currentLazyDepth, structureDepth);
-          }
-          default: {
-            schema2._zod.def.type;
-            return [true, this.unsupportedJsonSchema];
-          }
-        }
-      }
-    );
-  }
-  #getCustomJsonSchema(schema, options) {
-    if (options.strategy === "input" && JSON_SCHEMA_INPUT_REGISTRY.has(schema)) {
-      return JSON_SCHEMA_INPUT_REGISTRY.get(schema);
-    }
-    if (options.strategy === "output" && JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) {
-      return JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
-    }
-    if (JSON_SCHEMA_REGISTRY.has(schema)) {
-      return JSON_SCHEMA_REGISTRY.get(schema);
-    }
-    const global = globalRegistry.get(schema);
-    if (global) {
-      return {
-        title: global.title,
-        description: global.description,
-        examples: Array.isArray(global.examples) ? global.examples : void 0
-      };
-    }
-  }
-  #handleArrayItemJsonSchema([required, schema], options) {
-    if (required || options.strategy === "input" || schema.default !== void 0) {
-      return schema;
-    }
-    if (schema === this.undefinedJsonSchema) {
-      return { type: "null" };
-    }
-    return {
-      anyOf: [
-        // schema can contain { type: 'null' } so we should use anyOf instead of oneOf
-        schema,
-        { type: "null" }
-      ]
-    };
-  }
-  #handleStringFormat(format) {
-    if (format === "guid") {
-      return JSONSchemaFormat.UUID;
-    }
-    if (format === "url") {
-      return JSONSchemaFormat.URI;
-    }
-    if (format === "datetime") {
-      return JSONSchemaFormat.DateTime;
-    }
-    return Object.values(JSONSchemaFormat).includes(format) ? format : void 0;
-  }
-  #handleContentEncoding(contentEncoding) {
-    return Object.values(JSONSchemaContentEncoding).includes(contentEncoding) ? contentEncoding : void 0;
-  }
-}
-
-export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter, experimental_ZodSmartCoercionPlugin };