@amritk/generate-validators 0.10.0 → 0.10.1

package/dist/generators/generate-validator-function.js

@@ -580,7 +580,12 @@ const generateObjectValidator = (schema, typeName, suffix) => {
     if (hasPropertyNames(schema) && isSchemaObject(schema.propertyNames)) {
         propertyLines.push(...generatePropertyNameChecks(schema.propertyNames, suffix));
     }
-    const body = propertyLines.length > 0 ? '\n' + propertyLines.join('\n') + '\n' : '';
+    // Lazily allocate the errors array so a valid input never builds one — the same
+    // allocation-free happy path the runtime interpreter uses. Each emitted
+    // `errors.push(...)` becomes a create-on-first-use push; nothing is allocated
+    // until the first actual error, so the common valid case stays alloc-free even
+    // when the schema is too rich for the boolean guard.
+    const body = (propertyLines.length > 0 ? '\n' + propertyLines.join('\n') + '\n' : '').replaceAll('errors.push(', '(errors ??= []).push(');
     // Hoisted statements (e.g. known-keys Sets) come first so every call of the
     // validator reuses them instead of rebuilding them.
     const hoistedBlock = ctx.hoisted.length > 0 ? `${ctx.hoisted.join('\n')}\n\n` : '';
@@ -602,9 +607,9 @@ const generateObjectValidator = (schema, typeName, suffix) => {
         `    return { valid: false, errors: [{ message: 'must be object', path: _path }] }`,
         `  }`,
         ``,
-        `  const errors: ValidationError[] = []`,
+        `  let errors: ValidationError[] | undefined`,
         body,
-        `  return errors.length > 0 ? { valid: false, errors } : true`,
+        `  return errors !== undefined ? { valid: false, errors } : true`,
         `}`,
     ].join('\n');
     // No guard: the exported validator is the error-collecting function itself.
@@ -661,6 +666,23 @@ const rightTypeCondition = (accessor, type) => {
             return null;
     }
 };
+/**
+ * Builds the membership test for an `enum`, matching the slow path's
+ * `[...].includes(value)` verdict exactly. For the common all-primitive case it
+ * emits a parenthesized `a === x || a === y` chain — no per-call array
+ * allocation and no linear scan, so it stays on the allocation-free hot path —
+ * and falls back to `.includes` when a member is an object/array (reference
+ * equality) or `NaN` (where `includes`'s SameValueZero differs from `===`).
+ */
+const enumMembershipExpr = (values, acc) => {
+    const allPrimitive = values.length > 0 &&
+        values.every((v) => (v === null || typeof v !== 'object') && typeof v !== 'function') &&
+        !values.some((v) => typeof v === 'number' && Number.isNaN(v));
+    if (allPrimitive) {
+        return `(${values.map((v) => `${acc} === ${JSON.stringify(v)}`).join(' || ')})`;
+    }
+    return `(${JSON.stringify(values)} as unknown[]).includes(${acc})`;
+};
 /**
  * Builds a boolean expression that is TRUE iff `acc` satisfies `schema`, with the
  * *exact same verdict* as the error-collecting validator — or `null` when the
@@ -686,7 +708,7 @@ const booleanLeafExpr = (schema, acc) => {
     }
     // enum — same membership test the validator uses.
     if (hasEnum(schema)) {
-        return `(${JSON.stringify(schema.enum)} as unknown[]).includes(${acc})`;
+        return enumMembershipExpr(schema.enum, acc);
     }
     if (!hasType(schema))
         return null;
@@ -738,6 +760,12 @@ const booleanLeafExpr = (schema, acc) => {
  * array shape and — for typed items — only each item's *type* (objects are shape-
  * checked, not recursed into); it never enforces `minItems`/`maxItems` or item
  * constraints. Returns `null` for `$ref` items (those defer to the validator).
+ *
+ * Item iteration goes through `Array.from` rather than `Array.prototype.every`
+ * because `every` *skips holes* in a sparse array (`[, 'x']`), whereas the
+ * validator's index-based `for` loop reads a hole as `undefined` and rejects it.
+ * Materialising the array first makes the guard's verdict match the slow path's
+ * on sparse input — the guard must never accept what the slow path would reject.
  */
 const booleanArrayExpr = (schema, acc) => {
     const base = `Array.isArray(${acc})`;
@@ -753,7 +781,7 @@ const booleanArrayExpr = (schema, acc) => {
     const itemCheck = rightTypeCondition('_it', items.type);
     if (itemCheck === null)
         return base;
-    return `${base} && (${acc} as unknown[]).every((_it) => ${itemCheck})`;
+    return `${base} && Array.from(${acc} as unknown[]).every((_it) => ${itemCheck})`;
 };
 /**
  * Builds the `&&` conditions proving an object value is valid (same verdict as
@@ -978,9 +1006,9 @@ const generateScalarValidator = (schema, typeName, suffix) => {
             `  if (${wrongType}) {`,
             `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
             `  }`,
-            `  const errors: ValidationError[] = []`,
-            constraintLines.join('\n'),
-            `  return errors.length > 0 ? { valid: false, errors } : true`,
+            `  let errors: ValidationError[] | undefined`,
+            constraintLines.join('\n').replaceAll('errors.push(', '(errors ??= []).push('),
+            `  return errors !== undefined ? { valid: false, errors } : true`,
             `}`,
         ].join('\n');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",