@amritk/generate-parsers 0.16.3 → 0.17.0

package/dist/generators/generate-files.js

@@ -1,86 +1,57 @@
-import { generateTypeDefinition } from '@amritk/helpers/generate-type-definition';
-import { collectHelpers, } from '../helpers/collect-helpers.js';
-import { collectImports, collectImportTypeNames } from '../helpers/collect-imports.js';
-import { generateParserFunction, generateShapeValidator } from './generate-parser-function.js';
-/**
- * Generates a complete TypeScript file from a JSON Schema.
- *
- * The generated file contains imports, type definition, and parser function.
- * When typesOnly is true, only the type definition is emitted without any parser.
- *
- * @param schema - The JSON Schema to generate code from
- * @param typeName - The name to use for the generated TypeScript type
- * @param options - Optional settings to control what gets generated
- * @returns The generated file content and the set of runtime helpers it references
- *
- * @example
- * ```typescript
- * const schema = {
- *   type: "object",
- *   properties: {
- *     name: { type: "string" },
- *     age: { type: "number" }
- *   },
- *   required: ["name"]
- * };
- *
- * const result = generateFile(schema, "User");
- * // result contains imports, type User, and parseUser function
- *
- * const typesOnly = generateFile(schema, "User", { typesOnly: true });
- * // typesOnly contains only type-only imports and type User (no parser)
- * ```
- */
-export const generateFile = (schema, typeName, options) => {
-    const typesOnly = options?.typesOnly === true;
-    const selfRef = options?.selfRef;
-    const rootSchema = options?.rootSchema;
-    const helpersMode = options?.helpersMode ?? 'package';
-    const typeSuffix = options?.typeSuffix ?? '';
-    const importExt = options?.importExt ?? 'js';
-    const typeDefinition = generateTypeDefinition(schema, typeName, { readonly: options?.readonly ?? false, typeSuffix });
-    if (typesOnly) {
-        // In types-only mode, skip the parser function and use type-only imports
-        const imports = collectImports(schema, { typesOnly: true, selfRef, rootSchema, typeSuffix, importExt });
-        let result = '';
-        if (imports.length > 0) {
-            result += imports[0];
-            for (let i = 1; i < imports.length; i++) {
-                result += '\n' + imports[i];
-            }
-            result += '\n\n';
-        }
-        return { content: result + typeDefinition, usedHelpers: new Set() };
+import { generateTypeDefinition } from "@amritk/helpers/generate-type-definition";
+import { collectHelpers } from "../helpers/collect-helpers.js";
+import { collectImports, collectImportTypeNames } from "../helpers/collect-imports.js";
+import { generateParserFunction, generateShapeValidator } from "./generate-parser-function.js";
+const generateFile = (schema, typeName, options) => {
+  const typesOnly = options?.typesOnly === true;
+  const selfRef = options?.selfRef;
+  const rootSchema = options?.rootSchema;
+  const helpersMode = options?.helpersMode ?? "package";
+  const typeSuffix = options?.typeSuffix ?? "";
+  const importExt = options?.importExt ?? "js";
+  const typeDefinition = generateTypeDefinition(schema, typeName, { readonly: options?.readonly ?? false, typeSuffix });
+  if (typesOnly) {
+    const imports2 = collectImports(schema, { typesOnly: true, selfRef, rootSchema, typeSuffix, importExt });
+    let result2 = "";
+    if (imports2.length > 0) {
+      result2 += imports2[0];
+      for (let i = 1; i < imports2.length; i++) {
+        result2 += "\n" + imports2[i];
+      }
+      result2 += "\n\n";
     }
-    const stripUnknown = options?.stripUnknown ?? false;
-    // Names this file imports for its $refs: synthesized private sub-type names
-    // dedup against them so they can never shadow an imported identifier. The
-    // parser and the shape validator must receive the SAME set — their derived
-    // sub-names have to agree.
-    const reservedNames = collectImportTypeNames(schema, { selfRef, rootSchema, typeSuffix });
-    const parserFunction = generateParserFunction(schema, typeName, {
-        useRefImports: true,
-        typeSuffix,
-        reservedNames,
-        ...(options?.isRoot !== undefined ? { isRoot: options.isRoot } : {}),
-        ...(rootSchema !== undefined ? { rootSchema } : {}),
-        ...(options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {}),
-        ...(options?.strict !== undefined ? { strict: options.strict } : {}),
-        ...(options?.stripUnknown !== undefined ? { stripUnknown: options.stripUnknown } : {}),
-        ...(options?.caseInsensitive !== undefined ? { caseInsensitive: options.caseInsensitive } : {}),
-    });
-    const shapeValidator = generateShapeValidator(schema, typeName, true, typeSuffix, true, stripUnknown, reservedNames);
-    const combinedFunctions = `${shapeValidator}\n\n${parserFunction}`;
-    const helpers = collectHelpers(combinedFunctions, helpersMode, options?.helpersImportPrefix, importExt);
-    const imports = [...collectImports(schema, { selfRef, rootSchema, typeSuffix, importExt }), ...helpers.imports];
-    // Build file output using string concatenation instead of array join for performance
-    let result = '';
-    if (imports.length > 0) {
-        result += imports[0];
-        for (let i = 1; i < imports.length; i++) {
-            result += '\n' + imports[i];
-        }
-        result += '\n\n';
+    return { content: result2 + typeDefinition, usedHelpers: /* @__PURE__ */ new Set() };
+  }
+  const stripUnknown = options?.stripUnknown ?? false;
+  const reservedNames = collectImportTypeNames(schema, { selfRef, rootSchema, typeSuffix });
+  const shapeValidator = generateShapeValidator(schema, typeName, true, typeSuffix, true, stripUnknown, reservedNames);
+  const parserFunction = generateParserFunction(schema, typeName, {
+    useRefImports: true,
+    typeSuffix,
+    reservedNames,
+    shapeValidatorSource: shapeValidator,
+    ...options?.isRoot !== void 0 ? { isRoot: options.isRoot } : {},
+    ...rootSchema !== void 0 ? { rootSchema } : {},
+    ...options?.logWarnings !== void 0 ? { logWarnings: options.logWarnings } : {},
+    ...options?.strict !== void 0 ? { strict: options.strict } : {},
+    ...options?.stripUnknown !== void 0 ? { stripUnknown: options.stripUnknown } : {},
+    ...options?.caseInsensitive !== void 0 ? { caseInsensitive: options.caseInsensitive } : {}
+  });
+  const combinedFunctions = `${shapeValidator}
+
+${parserFunction}`;
+  const helpers = collectHelpers(combinedFunctions, helpersMode, options?.helpersImportPrefix, importExt);
+  const imports = [...collectImports(schema, { selfRef, rootSchema, typeSuffix, importExt }), ...helpers.imports];
+  let result = "";
+  if (imports.length > 0) {
+    result += imports[0];
+    for (let i = 1; i < imports.length; i++) {
+      result += "\n" + imports[i];
     }
-    return { content: result + typeDefinition + '\n\n' + combinedFunctions, usedHelpers: helpers.used };
+    result += "\n\n";
+  }
+  return { content: result + typeDefinition + "\n\n" + combinedFunctions, usedHelpers: helpers.used };
+};
+export {
+  generateFile
 };

package/dist/generators/generate-non-discriminated-union-validation.js

@@ -1,28 +1,26 @@
-import { generateSchemaChecks } from './generate-schema-checks.js';
-/**
- * Generates a non-discriminated union validation expression.
- * Tries each schema in order until one matches.
- */
-export const generateNonDiscriminatedUnionValidation = (accessor, schemas, defaultValue, isRequired) => {
-    const cases = [];
-    for (const schema of schemas) {
-        const checks = generateSchemaChecks(accessor, schema);
-        if (checks.length > 0) {
-            let combinedChecks = checks[0];
-            for (let i = 1; i < checks.length; i++) {
-                combinedChecks += ' && ' + checks[i];
-            }
-            cases.push('(' + combinedChecks + ')');
-        }
+import { generateSchemaChecks } from "./generate-schema-checks.js";
+const generateNonDiscriminatedUnionValidation = (accessor, schemas, defaultValue, isRequired) => {
+  const cases = [];
+  for (const schema of schemas) {
+    const checks = generateSchemaChecks(accessor, schema);
+    if (checks.length > 0) {
+      let combinedChecks = checks[0];
+      for (let i = 1; i < checks.length; i++) {
+        combinedChecks += " && " + checks[i];
+      }
+      cases.push("(" + combinedChecks + ")");
     }
-    if (cases.length === 0) {
-        return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
-    }
-    // Try each schema in order
-    let combinedCheck = cases[0];
-    for (let i = 1; i < cases.length; i++) {
-        combinedCheck += ' || ' + cases[i];
-    }
-    const finalDefault = isRequired ? defaultValue : 'undefined';
-    return `(${combinedCheck}) ? ${accessor} : ${finalDefault}`;
+  }
+  if (cases.length === 0) {
+    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+  }
+  let combinedCheck = cases[0];
+  for (let i = 1; i < cases.length; i++) {
+    combinedCheck += " || " + cases[i];
+  }
+  const finalDefault = isRequired ? defaultValue : "undefined";
+  return `(${combinedCheck}) ? ${accessor} : ${finalDefault}`;
+};
+export {
+  generateNonDiscriminatedUnionValidation
 };

package/dist/generators/generate-parser-function.d.ts

@@ -67,6 +67,18 @@ type GenerateParserOptions = {
      * exact `===` fast path and the hot path is unaffected.
      */
     readonly caseInsensitive?: boolean;
+    /**
+     * The exact source of the `validate{TypeName}Shape` predicate emitted into
+     * the same file as this parser (generate-files produces it for the root
+     * type). When the parser can prove — by rendering the predicate it would
+     * need and comparing byte-for-byte — that this emitted predicate tests
+     * exactly its own fast-path guard, it emits `validate{TypeName}Shape(input)`
+     * instead of a second inline copy of the whole check chain, which roughly
+     * halves the emitted checks per object type. Any mismatch (composition
+     * keywords, conditional flattening, alias/union predicates, stubs) keeps
+     * the inline guard, so a wrong substitution is impossible by construction.
+     */
+    readonly shapeValidatorSource?: string;
 };
 /**
  * Generates a safe parser as an arrow function that never throws.