exact-mirror 1.1.1 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "exact-mirror",
-	"version": "1.1.1",
+	"version": "1.2.0",
 	"description": "Mirror exact value to TypeBox/OpenAPI model",
 	"license": "MIT",
 	"scripts": {
@@ -23,7 +23,7 @@
 		"elysia": "^1.4.28",
 		"eslint": "9.6.0",
 		"mitata": "^1.0.33",
-		"tsup": "^8.1.0",
+		"tsdown": "^0.22.2",
 		"tsx": "^4.19.2",
 		"typebox": "^1.1.15",
 		"typescript": "^6.0.0"
@@ -36,7 +36,7 @@
 		".": {
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.mjs",
-			"require": "./dist/cjs/index.js"
+			"require": "./dist/index.js"
 		}
 	},
 	"keywords": [

package/dist/cjs/index.d.ts

@@ -1,103 +0,0 @@
-import type { TSchema, TModule, Static } from 'typebox';
-import type { Compile, Validator } from 'typebox/compile';
-interface BaseSchema {
-    '~kind': string;
-    id?: string;
-    $id?: string;
-    type?: string;
-    $schema?: string;
-    const?: unknown[];
-    pattern?: string;
-    additionalItems?: boolean | AnySchema;
-    items?: AnySchema | AnySchema[];
-    required?: string[];
-    additionalProperties?: boolean | AnySchema;
-    definitions?: {
-        [name: string]: AnySchema;
-    };
-    properties?: {
-        [name: string]: AnySchema;
-    };
-    patternProperties?: {
-        [name: string]: AnySchema;
-    };
-    dependencies?: {
-        [name: string]: AnySchema | string[];
-    };
-    enum?: any[];
-    allOf?: AnySchema[];
-    anyOf?: AnySchema[];
-    oneOf?: AnySchema[];
-    not?: AnySchema;
-    $ref?: string;
-    $defs?: Record<string, AnySchema>;
-}
-type AnySchema = TSchema & BaseSchema;
-export declare const mergeObjectIntersection: (schema: AnySchema) => AnySchema;
-type MaybeArray<T> = T | T[];
-export interface Instruction<Emit extends boolean = false> {
-    optionals: string[];
-    optionalsInArray: string[][];
-    parentIsOptional: boolean;
-    array: number;
-    unions: Validator<any>[][];
-    unionKeys: Record<string, 1>;
-    sanitize: MaybeArray<(v: string) => string> | undefined;
-    fromUnion?: boolean;
-    emit?: Emit;
-    /**
-     * TypeCompiler is required when using Union
-     *
-     * Left as opt-in to reduce bundle size
-     * many end-user doesn't use Union
-     *
-     * @default undefined
-     */
-    Compile?: typeof Compile;
-    typeCompilerWanred?: boolean;
-    modules?: TModule<{}>;
-    definitions: Record<string, AnySchema>;
-    /**
-     * Shared cyclic codegen state: generated per-definition mirror
-     * functions, grouped by `$defs` object identity
-     */
-    cyclic: CyclicContext;
-    /**
-     * `$defs` group the current cyclic definition body is generated
-     * against, used to resolve `Ref` nodes to function calls
-     */
-    cyclicDefs?: CyclicGroup;
-    recursion: number;
-    /**
-     * @default 8
-     */
-    recursionLimit: number;
-    /**
-     * If incorrect type is passed to Union value, should it be removed?
-     *
-     * If you check a value later, it's recommended to set this to `false`
-     * otherwise, set this to true
-     *
-     * @default false
-     */
-    removeUnknownUnionType: boolean;
-}
-export declare function deepClone<T>(source: T, weak?: WeakMap<object, any>): T;
-interface CyclicGroup {
-    defs: Record<string, AnySchema>;
-    names: Record<string, string>;
-}
-interface CyclicContext {
-    groups: Map<object, CyclicGroup>;
-    fns: string[];
-    count: number;
-}
-export interface Manifest {
-    source: string;
-    externals: {
-        unions: Validator<any, TSchema, unknown, unknown>[][];
-        hof?: Record<string, Function>;
-    };
-}
-export declare const createMirror: <T extends TSchema, Emit extends boolean = false>(schema: T, { Compile, modules, definitions, sanitize, recursionLimit, removeUnknownUnionType, emit }?: Partial<Pick<Instruction<Emit>, "Compile" | "definitions" | "sanitize" | "modules" | "recursionLimit" | "removeUnknownUnionType" | "emit">>) => Emit extends true ? Manifest : (v: Static<T>) => Static<T>;
-export default createMirror;

package/dist/cjs/index.js

@@ -1,495 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  createMirror: () => createMirror,
-  deepClone: () => deepClone,
-  default: () => index_default,
-  mergeObjectIntersection: () => mergeObjectIntersection
-});
-module.exports = __toCommonJS(index_exports);
-var Kind = "~kind";
-var Hint = "~hint";
-var isSpecialProperty = (name) => !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
-var joinProperty = (v1, v2, isOptional = false) => {
-  if (typeof v2 === "number") return `${v1}[${v2}]`;
-  if (isSpecialProperty(v2))
-    return `${v1}${isOptional ? "?." : ""}[${JSON.stringify(v2)}]`;
-  return `${v1}${isOptional ? "?" : ""}.${v2}`;
-};
-var encodeProperty = (v) => isSpecialProperty(v) ? JSON.stringify(v) : v;
-var sanitize = (key, sanitize2 = 0, schema) => {
-  if (schema.type !== "string" || schema.const || schema.trusted) return key;
-  let hof = "";
-  for (let i = sanitize2 - 1; i >= 0; i--) hof += `d.h${i}(`;
-  return hof + key + ")".repeat(sanitize2);
-};
-var mergeObjectIntersection = (schema) => {
-  if (!schema.allOf || Kind in schema && (schema[Kind] !== "Intersect" || schema.type !== "object"))
-    return schema;
-  const { allOf, ...newSchema } = schema;
-  newSchema.properties = {};
-  if (Kind in newSchema) newSchema[Kind] = "Object";
-  for (const type of allOf) {
-    if (type.type !== "object") continue;
-    const { properties, required, type: _, [Kind]: __, ...rest } = type;
-    if (required)
-      newSchema.required = newSchema.required ? newSchema.required.concat(required) : required;
-    Object.assign(newSchema, rest);
-    for (const property in type.properties)
-      newSchema.properties[property] = mergeObjectIntersection(
-        type.properties[property]
-      );
-  }
-  return newSchema;
-};
-var handleRecord = (schema, property, instruction) => {
-  const child = schema.patternProperties["^(.*)$"] ?? schema.patternProperties[Object.keys(schema.patternProperties)[0]];
-  if (!child) return property;
-  const i = instruction.array;
-  instruction.array++;
-  let v = `(()=>{const ar${i}s=Object.keys(${property}),ar${i}v={};for(let i=0;i<ar${i}s.length;i++){const ar${i}p=${property}[ar${i}s[i]];ar${i}v[ar${i}s[i]]=${mirror(child, `ar${i}p`, instruction)}`;
-  const optionals = instruction.optionalsInArray[i + 1];
-  if (optionals) {
-    for (let oi = 0; oi < optionals.length; oi++) {
-      const target = `ar${i}v[ar${i}s[i]]${optionals[oi]}`;
-      v += `;if(${target}===undefined)delete ${target}`;
-    }
-    instruction.optionalsInArray[i + 1] = [];
-  }
-  v += `}return ar${i}v})()`;
-  return v;
-};
-var handleTuple = (schema, property, instruction) => {
-  const i = instruction.array;
-  instruction.array++;
-  const isRoot = property === "v" && !instruction.fromUnion;
-  let v = "";
-  if (!isRoot) v = `(()=>{`;
-  v += `const ar${i}v=[`;
-  for (let i2 = 0; i2 < schema.length; i2++) {
-    if (i2 !== 0) v += ",";
-    v += mirror(
-      schema[i2],
-      joinProperty(
-        property,
-        i2,
-        instruction.parentIsOptional || instruction.fromUnion
-      ),
-      instruction
-    );
-  }
-  v += `];`;
-  if (!isRoot) v += `return ar${i}v})()`;
-  return v;
-};
-function deepClone(source, weak = /* @__PURE__ */ new WeakMap()) {
-  if (source === null || typeof source !== "object" || typeof source === "function")
-    return source;
-  if (weak.has(source)) return weak.get(source);
-  if (Array.isArray(source)) {
-    const copy = new Array(source.length);
-    weak.set(source, copy);
-    for (let i = 0; i < source.length; i++)
-      copy[i] = deepClone(source[i], weak);
-    return copy;
-  }
-  if (typeof source === "object") {
-    const keys = Object.keys(source).concat(
-      Object.getOwnPropertySymbols(source)
-    );
-    const cloned = {};
-    for (const key of keys)
-      cloned[key] = deepClone(source[key], weak);
-    return cloned;
-  }
-  return source;
-}
-var handleCyclic = (schema, property, instruction) => {
-  const defs = schema.$defs;
-  let group = instruction.cyclic.groups.get(defs);
-  if (!group) {
-    group = { defs, names: {} };
-    instruction.cyclic.groups.set(defs, group);
-    for (const name in defs)
-      group.names[name] = `cy${instruction.cyclic.count++}`;
-    for (const name in defs)
-      instruction.cyclic.fns.push(
-        `function ${group.names[name]}(v){${mirror(defs[name], "v", {
-          ...instruction,
-          cyclicDefs: group,
-          fromUnion: false,
-          parentIsOptional: false,
-          optionals: [],
-          optionalsInArray: [],
-          unionKeys: {},
-          array: 0,
-          recursion: 0
-        })}}`
-      );
-  }
-  const fn = group.names[schema.$ref];
-  if (!fn)
-    throw new Error(
-      `[exact-mirror] cyclic reference "${schema.$ref}" is not found in $defs`
-    );
-  return `(${property}==null?${property}:${fn}(${property}))`;
-};
-var withDefs = (type, group) => {
-  if (Kind in type) {
-    if (type[Kind] === "Cyclic") return type;
-    if (type[Kind] === "Ref" && type.$ref in group.defs)
-      return Object.defineProperty(
-        { $defs: group.defs, $ref: type.$ref },
-        Kind,
-        { value: "Cyclic" }
-      );
-  }
-  let entry = "~check";
-  while (entry in group.defs) entry += "~";
-  const def = Object.create(
-    Object.getPrototypeOf(type),
-    Object.getOwnPropertyDescriptors(type)
-  );
-  def.$id = entry;
-  return Object.defineProperty(
-    { $defs: { ...group.defs, [entry]: def }, $ref: entry },
-    Kind,
-    { value: "Cyclic" }
-  );
-};
-var handleUnion = (schemas, property, instruction) => {
-  if (instruction.Compile === void 0) {
-    if (!instruction.typeCompilerWanred) {
-      console.warn(
-        new Error(
-          "[exact-mirror] TypeBox's TypeCompiler is required to use Union"
-        )
-      );
-      instruction.typeCompilerWanred = true;
-    }
-    return property;
-  }
-  instruction.unionKeys[property] = 1;
-  const ui = instruction.unions.length;
-  const typeChecks = instruction.unions[ui] = [];
-  let v = `(()=>{
-`;
-  const unwrapRef = (type) => {
-    if (!(Kind in type) || !type.$ref) return type;
-    if (type[Kind] === "This")
-      return deepClone(instruction.definitions[type.$ref]);
-    return type;
-  };
-  let cleanThenCheck = "";
-  for (let i = 0; i < schemas.length; i++) {
-    let type = unwrapRef(schemas[i]);
-    if (Array.isArray(type.anyOf))
-      for (let i2 = 0; i2 < type.anyOf.length; i2++)
-        type.anyOf[i2] = unwrapRef(type.anyOf[i2]);
-    else if (type.items) {
-      if (Array.isArray(type.items))
-        for (let i2 = 0; i2 < type.items.length; i2++)
-          type.items[i2] = unwrapRef(type.items[i2]);
-      else type.items = unwrapRef(type.items);
-    }
-    typeChecks.push(
-      instruction.Compile(
-        instruction.cyclicDefs ? withDefs(type, instruction.cyclicDefs) : type
-      )
-    );
-    v += `if(d.unions[${ui}][${i}].Check(${property})){return ${mirror(
-      type,
-      property,
-      {
-        ...instruction,
-        recursion: instruction.recursion + 1,
-        parentIsOptional: true,
-        fromUnion: true
-      }
-    )}}
-`;
-    cleanThenCheck += (i ? "" : "let ") + "tmp=" + mirror(type, property, {
-      ...instruction,
-      recursion: instruction.recursion + 1,
-      parentIsOptional: true,
-      fromUnion: true
-    }) + `
-if(d.unions[${ui}][${i}].Check(tmp))return tmp
-`;
-  }
-  if (cleanThenCheck) v += cleanThenCheck;
-  v += `return ${instruction.removeUnknownUnionType ? "undefined" : property}`;
-  return v + `})()`;
-};
-var mirror = (schema, property, instruction) => {
-  if (!schema) return "";
-  const isRoot = property === "v" && !instruction.fromUnion;
-  const optionalsLength = instruction.optionals.length;
-  try {
-    if (Kind in schema && schema[Kind] === "Cyclic") {
-      const call = handleCyclic(schema, property, instruction);
-      return isRoot ? `return ${call}` : call;
-    }
-    return mirrorNode(schema, property, instruction);
-  } catch (error) {
-    instruction.optionals.length = optionalsLength;
-    console.warn(
-      new Error(
-        "[exact-mirror] failed to generate mirror for a schema node, the node is passed through as-is. Please report this issue to https://github.com/elysiajs/exact-mirror/issues"
-      ),
-      error
-    );
-    return isRoot ? "return v" : property;
-  }
-};
-var mirrorNode = (schema, property, instruction) => {
-  const isRoot = property === "v" && !instruction.fromUnion;
-  if (instruction.cyclicDefs && Kind in schema && schema[Kind] === "Ref" && schema.$ref && schema.$ref in instruction.cyclicDefs.names) {
-    const call = `(${property}==null?${property}:${instruction.cyclicDefs.names[schema.$ref]}(${property}))`;
-    return isRoot ? `return ${call}` : call;
-  }
-  if (isRoot && schema.type !== "object" && schema.type !== "array" && !schema.anyOf)
-    return `return ${sanitize("v", instruction.sanitize?.length, schema)}`;
-  if (instruction.recursion >= instruction.recursionLimit) return property;
-  let v = "";
-  if (schema.$id && Hint in schema)
-    instruction.definitions[schema.$id] = schema;
-  switch (schema.type) {
-    case "object":
-      if (schema[Kind] === "Record") {
-        v = handleRecord(schema, property, instruction);
-        break;
-      }
-      schema = mergeObjectIntersection(schema);
-      if (!schema.properties) {
-        v = property;
-        break;
-      }
-      v += "{";
-      if (schema.additionalProperties) v += `...${property},`;
-      const keys = Object.keys(schema.properties);
-      for (let i2 = 0; i2 < keys.length; i2++) {
-        const key = keys[i2];
-        let isOptional = (
-          // all fields are optional
-          !schema.required || // field is explicitly required
-          schema.required && !schema.required.includes(key) || Array.isArray(schema.properties[key].anyOf)
-        );
-        const name = joinProperty(
-          property,
-          key,
-          // If parent is a union, any property could be undefined
-          instruction.parentIsOptional || instruction.fromUnion
-        );
-        if (isOptional) {
-          const index = instruction.array;
-          if (property.startsWith("ar")) {
-            const dotIndex = name.indexOf(".");
-            let refName;
-            if (dotIndex >= 0) {
-              refName = name.slice(dotIndex);
-            } else {
-              refName = name.slice(property.length);
-            }
-            if (refName.startsWith("?.")) {
-              if (refName.charAt(2) === "[") {
-                refName = refName.slice(2);
-              } else {
-                refName = refName.slice(1);
-              }
-            }
-            const array = instruction.optionalsInArray;
-            if (array[index]) {
-              array[index].push(refName);
-            } else {
-              array[index] = [refName];
-            }
-          } else {
-            instruction.optionals.push(name);
-          }
-        }
-        const child = schema.properties[key];
-        if (i2 !== 0) v += ",";
-        v += `${encodeProperty(key)}:${isOptional ? `${name}===undefined?undefined:` : ""}${mirror(
-          child,
-          name,
-          {
-            ...instruction,
-            recursion: instruction.recursion + 1,
-            parentIsOptional: isOptional
-          }
-        )}`;
-      }
-      v += "}";
-      break;
-    case "array":
-      if (!schema.items) {
-        v = property;
-        break;
-      }
-      if (
-        // @ts-expect-error
-        schema.items.type !== "object" && // @ts-expect-error
-        schema.items.type !== "array"
-      ) {
-        const cyclicItems = instruction.cyclicDefs !== void 0 && !Array.isArray(schema.items) && Kind in schema.items && schema.items[Kind] === "Ref" && schema.items.$ref !== void 0 && schema.items.$ref in instruction.cyclicDefs.names;
-        if (Array.isArray(schema.items)) {
-          v = handleTuple(schema.items, property, instruction);
-          break;
-        } else if (!cyclicItems) {
-          if (isRoot && !Array.isArray(schema.items.anyOf))
-            return "return v";
-          else if (Kind in schema.items && schema.items.$ref && (schema.items[Kind] === "Ref" || schema.items[Kind] === "This"))
-            v = mirror(
-              deepClone(
-                instruction.definitions[schema.items.$ref]
-              ),
-              property,
-              {
-                ...instruction,
-                parentIsOptional: true,
-                recursion: instruction.recursion + 1
-              }
-            );
-          else if (!Array.isArray(schema.items.anyOf)) {
-            v = property;
-            break;
-          }
-        }
-      }
-      const i = instruction.array;
-      instruction.array++;
-      let reference = property;
-      if (isRoot) v = `const ar${i}v=new Array(${property}.length);`;
-      else {
-        reference = `ar${i}s`;
-        v = `((${reference})=>{const ar${i}v=new Array(${reference}.length);`;
-      }
-      v += `for(let i=0;i<${reference}.length;i++){const ar${i}p=${reference}[i];ar${i}v[i]=${mirror(schema.items, `ar${i}p`, instruction)}`;
-      const optionals = instruction.optionalsInArray[i + 1];
-      if (optionals) {
-        for (let oi = 0; oi < optionals.length; oi++) {
-          const target = `ar${i}v[i]${optionals[oi]}`;
-          v += `;if(${target}===undefined)delete ${target}`;
-        }
-        instruction.optionalsInArray[i + 1] = [];
-      }
-      v += `}`;
-      if (!isRoot) v += `return ar${i}v})(${property})`;
-      break;
-    default:
-      if (schema.$ref && schema.$ref in instruction.definitions)
-        return mirror(
-          instruction.definitions[schema.$ref],
-          property,
-          instruction
-        );
-      if (Array.isArray(schema.anyOf)) {
-        v = handleUnion(schema.anyOf, property, instruction);
-        break;
-      }
-      v = sanitize(property, instruction.sanitize?.length, schema);
-      break;
-  }
-  if (!isRoot) return v;
-  if (schema.type === "array") {
-    v = `${v}const x=ar0v;`;
-  } else {
-    v = `const x=${v}
-`;
-  }
-  for (let i = 0; i < instruction.optionals.length; i++) {
-    const key = instruction.optionals[i];
-    const prop = key.slice(1);
-    v += `if(${key}===undefined`;
-    if (instruction.unionKeys[key]) v += `||x${prop}===undefined`;
-    const shouldQuestion = prop.charCodeAt(0) !== 63 && schema.type !== "array";
-    v += `)delete x${shouldQuestion ? prop.charCodeAt(0) === 91 ? "?." : "?" : ""}${prop}
-`;
-  }
-  return `${v}return x`;
-};
-var createMirror = (schema, {
-  Compile,
-  modules,
-  definitions,
-  sanitize: sanitize2,
-  recursionLimit = 8,
-  removeUnknownUnionType = false,
-  emit
-} = {}) => {
-  const unions = [];
-  const cyclic = { groups: /* @__PURE__ */ new Map(), fns: [], count: 0 };
-  if (typeof sanitize2 === "function") sanitize2 = [sanitize2];
-  const f = mirror(schema, "v", {
-    optionals: [],
-    optionalsInArray: [],
-    array: 0,
-    parentIsOptional: false,
-    unions,
-    unionKeys: {},
-    Compile,
-    modules,
-    // @ts-ignore private property
-    definitions: definitions ?? modules?.$defs ?? {},
-    cyclic,
-    sanitize: sanitize2,
-    recursion: 0,
-    recursionLimit,
-    removeUnknownUnionType
-  });
-  const fns = cyclic.fns.length ? cyclic.fns.join("\n") + "\n" : "";
-  if (!unions.length && !sanitize2?.length) {
-    if (emit) return { source: fns + f, externals: void 0 };
-    return Function("v", fns + f);
-  }
-  let hof;
-  if (sanitize2?.length) {
-    hof = {};
-    for (let i = 0; i < sanitize2.length; i++) hof[`h${i}`] = sanitize2[i];
-  }
-  const source = `${fns}return function mirror(v){${f}}`;
-  if (emit)
-    return {
-      source,
-      externals: {
-        unions,
-        hof
-      }
-    };
-  return Function(
-    "d",
-    source
-  )(
-    hof ? unions ? {
-      unions,
-      ...hof
-    } : hof : unions ? { unions } : void 0
-  );
-};
-var index_default = createMirror;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createMirror,
-  deepClone,
-  mergeObjectIntersection
-});