@amritk/generate-parsers 0.11.0 → 0.11.1

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

@@ -796,6 +796,40 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         lines.push(objectLines.join('\n'));
         lines.push(`  } as unknown as ${typeName};`);
     };
+    // The deep-guard fast path. `{ ...input }` is the only correct shape when the
+    // guard let undeclared keys through (no known-keys term) — they must survive.
+    // But when `stripKeys` is set the guard *also* proved `_hasOnlyKnownKeys`, so
+    // the input's keys are exactly the declared properties: an explicit literal of
+    // those keys is then equivalent to the spread, and faster — a fixed-shape
+    // literal beats a generic spread, yields a stable hidden class, and produces
+    // the same declared key order as the slow path (the spread used input order).
+    // The literal shares each value by reference, exactly like the spread did, so
+    // it never re-parses an already-validated nested object. allOf merges in
+    // properties this `propInfo` list doesn't carry, so it keeps the spread.
+    const emitDeepGuardReturn = (lines) => {
+        const canLiteral = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema));
+        if (!canLiteral) {
+            lines.push(`  if (${deepGuard}) return { ...input } as ${typeName};`);
+            return;
+        }
+        const fields = [];
+        for (const { key, varName, isRequired, propSchema } of propInfo) {
+            if (!isSchemaObject(propSchema)) {
+                if (isRequired)
+                    fields.push(`    ${safeKey(key)}: undefined,`);
+                continue;
+            }
+            const accessor = shouldCacheVariable(propSchema, canFastPath, useRefImports)
+                ? varName
+                : safeAccessor('input', key);
+            fields.push(isRequired
+                ? `    ${safeKey(key)}: ${accessor},`
+                : `    ...(${accessor} !== undefined && { ${safeKey(key)}: ${accessor} }),`);
+        }
+        lines.push(`  if (${deepGuard}) return {`);
+        lines.push(fields.join('\n'));
+        lines.push(`  } as ${typeName};`);
+    };
     const lines = [];
     lines.push(`${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {`);
     if (strict) {
@@ -819,7 +853,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         }
         else {
             if (deepGuard) {
-                lines.push(`  if (${deepGuard}) return { ...input } as ${typeName};`);
+                emitDeepGuardReturn(lines);
             }
             for (const assertionLine of assertionLines) {
                 lines.push(assertionLine);
@@ -837,7 +871,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         lines.push(...varDeclLines);
         lines.push(...warnLines);
         if (deepGuard) {
-            lines.push(`  if (${deepGuard}) return { ...input } as ${typeName};`);
+            emitDeepGuardReturn(lines);
         }
         emitReturn(lines, buildObjectLines(false));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",