@amritk/generate-parsers 0.19.5 → 0.20.0

package/README.md

@@ -311,6 +311,15 @@ still — ~51M ops/s strict, ~127M safe — but at that size the numbers swing e
 run-to-run that the ratio, not the absolute, is the honest signal: mjst lands
 ~5–29× ahead of zod across every case above.
 
+What is replicated upstream is the *cases* — the two parse modes and their
+shapes — not the harness. These numbers come from this repo's own measurement
+core (direct calls over a pool of distinct inputs, median of many trials) and
+are not comparable with the public leaderboard, which measures every operation
+through benny and reports something an order of magnitude smaller for the same
+function. `@amritk/generate-validators` carries the side-by-side and a
+reproducible run of both harnesses:
+[Against the moltar harness](../generate-validators#against-the-moltar-harness).
+
 The trade is a one-shot **prepare** cost that only mjst pays — generating the
 parser source — which measures **~0.2–0.8 ms** per schema here (zod and TypeBox
 author or interpret their parsers with no separate build step, so there is

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

@@ -551,6 +551,54 @@ const exactKeyCountOf = (schema) => {
 const shouldCacheVariable = (propSchema) => {
   return isSchemaObject(propSchema);
 };
+const INLINE_NESTED_MAX_PROPERTIES = 12;
+const INLINE_NESTED_MAX_SITES = 4;
+const INLINE_NESTED_MAX_TOTAL_PROPERTIES = 24;
+const inlineNestedFastPath = (childSchema, childTypeName, objectExpr, useRefImports, suffix, stripUnknown, reservedNames) => {
+  if (!isSchemaObject(childSchema) || !hasProperties(childSchema))
+    return null;
+  if (!stripUnknown)
+    return null;
+  if (hasAdditionalProperties(childSchema) && childSchema.additionalProperties === false)
+    return null;
+  if (hasAllOf(childSchema) || hasOneOf(childSchema) || hasAnyOf(childSchema))
+    return null;
+  if (hasFastPathBlockingKeyword(childSchema))
+    return null;
+  if (hasMinProperties(childSchema) || hasMaxProperties(childSchema))
+    return null;
+  if (exactKeyCountOf(childSchema) === null)
+    return null;
+  const { objects, arrayItems } = collectInlineSubTypes(childSchema, childTypeName, reservedNames);
+  if (objects.size > 0 || arrayItems.size > 0)
+    return null;
+  const props = childSchema.properties;
+  const keys = Object.keys(props);
+  if (keys.length === 0 || keys.length > INLINE_NESTED_MAX_PROPERTIES)
+    return null;
+  const checks = [];
+  const fields = [];
+  const readRoot = `(${objectExpr} as Record<string, any>)`;
+  for (const key of keys) {
+    const propSchema = props[key];
+    if (shouldUseRefImport(propSchema, useRefImports) || shouldUseArrayRefImport(propSchema, useRefImports) || shouldUseRecordRefImport(propSchema, useRefImports)) {
+      return null;
+    }
+    const accessor = safeAccessor(readRoot, key);
+    const check = generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
+    if (check === null)
+      return null;
+    checks.push(check);
+    fields.push(`${safeLiteralKey(key)}: ${accessor}`);
+  }
+  const condition = [
+    `typeof ${objectExpr} === "object"`,
+    `${objectExpr} !== null`,
+    `!Array.isArray(${objectExpr})`,
+    ...checks
+  ].join(" && ");
+  return { condition, literal: `{ ${fields.join(", ")} }`, propertyCount: keys.length };
+};
 const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true, stripUnknown = false, rootSchema, reservedNames = NO_RESERVED_NAMES, caseInsensitive = false, shapeValidatorSource) => {
   const functionName = generateParserName(typeName);
   const exportPrefix = exported ? "export " : "";
@@ -590,9 +638,13 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
   const stripKeys = strictKeys || stripUnknown;
   const rejectsUnknownKeys = strict && isSchemaObject(schema) && hasAdditionalProperties(schema) && schema.additionalProperties === false && !("patternProperties" in schema) || false;
   const guardKeys = stripKeys || rejectsUnknownKeys;
+  const fastPathBuildsDeclaredLiteral = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema));
+  const fastPathNeedsKnownKeys = guardKeys && (rejectsUnknownKeys || !fastPathBuildsDeclaredLiteral);
+  const droppedKnownKeysTerm = guardKeys && !fastPathNeedsKnownKeys;
   const exactKeyCount = guardKeys ? exactKeyCountOf(schema) : null;
   const strictKeyCheck = unknownKeyCheck(propertyKeys, `_knownKeys${typeName}`);
-  if (guardKeys && exactKeyCount === null) {
+  const shapeValidatorNeedsKnownKeys = shapeValidatorSource?.includes(`_hasOnlyKnownKeys${typeName}(`) ?? false;
+  if ((fastPathNeedsKnownKeys || shapeValidatorNeedsKnownKeys) && exactKeyCount === null) {
     for (const declaration of strictKeyCheck.declarations) {
       preamble.push(`${declaration};`);
     }
@@ -659,13 +711,13 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       fastPathAccessorChecks.push(`Object.keys(input).length <= ${schema.maxProperties}`);
     }
   }
-  if (guardKeys) {
+  if (fastPathNeedsKnownKeys) {
     fastPathChecks.push(exactKeyCount !== null ? `Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length === ${exactKeyCount}` : `_hasOnlyKnownKeys${typeName}(input)`);
   }
   const deepGuard = canFastPath && fastPathChecks.length > 0 ? fastPathChecks.join(" && ") : null;
   const literalReturnUsesVars = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema)) && exported;
   let deepGuardExpr = deepGuard;
-  if (deepGuard !== null && shapeValidatorSource !== void 0 && !literalReturnUsesVars) {
+  if (deepGuard !== null && shapeValidatorSource !== void 0 && !literalReturnUsesVars && !droppedKnownKeysTerm) {
     const shapeFnName = shapeValidatorName(typeName);
     const shapeStrictKeysGuard = stripKeys && exactKeyCount === null ? `
   if (!_hasOnlyKnownKeys${typeName}(input)) return false;` : "";
@@ -726,6 +778,8 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
   }
   const buildObjectLines = (directAssign) => {
     const objectLines = [];
+    let inlinedSites = 0;
+    let inlinedProperties = 0;
     if (!stripKeys) {
       objectLines.push("    ...input,");
     }
@@ -744,6 +798,15 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       if (subName) {
         const subParserName = generateParserName(subName);
         if (isRequired) {
+          const inlined = directAssign && !logWarnings && inlinedSites < INLINE_NESTED_MAX_SITES ? inlineNestedFastPath(propSchema, subName, accessor, useRefImports, suffix, stripUnknown, reservedNames) : null;
+          if (inlined !== null && inlinedProperties + inlined.propertyCount <= INLINE_NESTED_MAX_TOTAL_PROPERTIES) {
+            inlinedSites++;
+            inlinedProperties += inlined.propertyCount;
+            objectLines.push(`    ${safeLiteralKey(key)}: (${inlined.condition})
+      ? ${inlined.literal}
+      : ${subParserName}(${accessor}),`);
+            continue;
+          }
           objectLines.push(`    ${safeLiteralKey(key)}: ${subParserName}(${accessor}),`);
         } else {
           objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${subParserName}(${accessor}) }),`);
@@ -826,12 +889,11 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
     lines2.push(`  } as unknown as ${typeName};`);
   };
   const emitDeepGuardReturn = (lines2) => {
-    const canLiteral = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema));
-    if (!canLiteral) {
+    if (!fastPathBuildsDeclaredLiteral) {
       lines2.push(`  if (${deepGuardExpr}) return { ...input } as ${typeName};`);
       return;
     }
-    if (!exported) {
+    if (!exported && fastPathNeedsKnownKeys) {
       lines2.push(`  if (${deepGuardExpr}) return input as ${typeName};`);
       return;
     }
@@ -868,7 +930,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       ...rootSchema !== void 0 ? { rootSchema } : {}
     }).slice(1);
     if (shallowGuard) {
-      if (!exported && deepGuard) {
+      if (!exported && deepGuard && fastPathNeedsKnownKeys) {
         const residual = [];
         for (let i = 0; i < fastPathChecks.length; i++) {
           const deep = fastPathChecks[i];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.19.5",
+  "version": "0.20.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -56,7 +56,7 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "^0.16.0"
+    "@amritk/helpers": "^0.17.0"
   },
   "devDependencies": {
     "@amritk/generate-markdown": "^0.5.0",