@amritk/generate-parsers 0.20.0 → 0.21.0

package/dist/generators/generate-schema-checks.js

@@ -1,6 +1,7 @@
 import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
 import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
+import { boundPassExpr } from "@amritk/helpers/numeric-bound-check";
 import { hasOwnCheck } from "@amritk/helpers/safe-accessor";
 import { hasAdditionalProperties, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
 import { maxLengthPassExpr, minLengthPassExpr } from "@amritk/helpers/string-length-check";
@@ -106,16 +107,16 @@ const generateInferredChecks = (accessor, schema, type) => {
     case "number":
       checks.push(`typeof ${accessor} === "number"`);
       if (hasMinimum(schema)) {
-        checks.push(`${accessor} >= ${schema.minimum}`);
+        checks.push(boundPassExpr(accessor, "minimum", schema.minimum));
       }
       if (hasMaximum(schema)) {
-        checks.push(`${accessor} <= ${schema.maximum}`);
+        checks.push(boundPassExpr(accessor, "maximum", schema.maximum));
       }
       if (hasExclusiveMinimum(schema)) {
-        checks.push(`${accessor} > ${schema.exclusiveMinimum}`);
+        checks.push(boundPassExpr(accessor, "minimum", schema.exclusiveMinimum, true));
       }
       if (hasExclusiveMaximum(schema)) {
-        checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
+        checks.push(boundPassExpr(accessor, "maximum", schema.exclusiveMaximum, true));
       }
       if (hasMultipleOf(schema)) {
         checks.push(`${accessor} % ${schema.multipleOf} === 0`);
@@ -191,16 +192,16 @@ const generateSchemaChecks = (accessor, schema) => {
         checks.push(`Number.isInteger(${accessor})`);
       }
       if (hasMinimum(schema)) {
-        checks.push(`${accessor} >= ${schema.minimum}`);
+        checks.push(boundPassExpr(accessor, "minimum", schema.minimum));
       }
       if (hasMaximum(schema)) {
-        checks.push(`${accessor} <= ${schema.maximum}`);
+        checks.push(boundPassExpr(accessor, "maximum", schema.maximum));
       }
       if (hasExclusiveMinimum(schema)) {
-        checks.push(`${accessor} > ${schema.exclusiveMinimum}`);
+        checks.push(boundPassExpr(accessor, "minimum", schema.exclusiveMinimum, true));
       }
       if (hasExclusiveMaximum(schema)) {
-        checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
+        checks.push(boundPassExpr(accessor, "maximum", schema.exclusiveMaximum, true));
       }
       if (hasMultipleOf(schema)) {
         checks.push(multipleOfPassExpr(accessor, schema.multipleOf));

package/dist/generators/generate-strict-assertion.d.ts

@@ -1,3 +1,4 @@
+import type { UnknownKeysStrategy } from '@amritk/helpers/unknown-keys-strategy';
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
 /**
  * Context for assertions that reach beyond the property's own schema: union
@@ -13,6 +14,11 @@ export type StrictAssertionContext = {
     readonly suffix?: string;
     readonly rootSchema?: Record<string, unknown>;
     readonly stripUnknown?: boolean;
+    /**
+     * The parser's `unknownKeys` option, carried so every object parser one of
+     * these contexts reaches counts keys on its fast path the same way.
+     */
+    readonly unknownKeys?: UnknownKeysStrategy;
     /**
      * Whether the parser these assertions run inside also emits the private
      * sub-parsers for its inline object properties (and inline-object array

package/dist/generators/generate-strict-assertion.js

@@ -1,6 +1,7 @@
 import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
 import { multipleOfFailExpr } from "@amritk/helpers/multiple-of-check";
+import { boundFailExpr } from "@amritk/helpers/numeric-bound-check";
 import { quoteJsString } from "@amritk/helpers/quote-js-string";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
 import { hasOwnCheck, missingCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
@@ -156,16 +157,16 @@ const generateConstraintChecks = (acc, propSchema, field, context = {}) => {
   }
   if (t === "number" || t === "integer") {
     if (hasMinimum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && !(${acc} >= ${propSchema.minimum})) ${throwError(`${field} must be >= ${propSchema.minimum}`)};`);
+      lines.push(`  if (typeof ${acc} === "number" && ${boundFailExpr(acc, "minimum", propSchema.minimum)}) ${throwError(`${field} must be >= ${propSchema.minimum}`)};`);
     }
     if (hasMaximum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && !(${acc} <= ${propSchema.maximum})) ${throwError(`${field} must be <= ${propSchema.maximum}`)};`);
+      lines.push(`  if (typeof ${acc} === "number" && ${boundFailExpr(acc, "maximum", propSchema.maximum)}) ${throwError(`${field} must be <= ${propSchema.maximum}`)};`);
     }
     if (hasExclusiveMinimum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && !(${acc} > ${propSchema.exclusiveMinimum})) ${throwError(`${field} must be > ${propSchema.exclusiveMinimum}`)};`);
+      lines.push(`  if (typeof ${acc} === "number" && ${boundFailExpr(acc, "minimum", propSchema.exclusiveMinimum, true)}) ${throwError(`${field} must be > ${propSchema.exclusiveMinimum}`)};`);
     }
     if (hasExclusiveMaximum(propSchema)) {
-      lines.push(`  if (typeof ${acc} === "number" && !(${acc} < ${propSchema.exclusiveMaximum})) ${throwError(`${field} must be < ${propSchema.exclusiveMaximum}`)};`);
+      lines.push(`  if (typeof ${acc} === "number" && ${boundFailExpr(acc, "maximum", propSchema.exclusiveMaximum, true)}) ${throwError(`${field} must be < ${propSchema.exclusiveMaximum}`)};`);
     }
     if (hasMultipleOf(propSchema)) {
       lines.push(`  if (typeof ${acc} === "number" && ${multipleOfFailExpr(acc, propSchema.multipleOf)}) ${throwError(`${field} must be a multiple of ${propSchema.multipleOf}`)};`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -41,7 +41,11 @@
     "types:check": "tsgo -p . --noEmit",
     "test": "NODE_ENV=production vitest run --root ../.. generate-parsers",
     "generate-readme": "bun run ./scripts/generate-readme.ts",
-    "bench": "bun --conditions development ./bench/run.ts"
+    "prebench": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench": "bun --conditions development ./bench/run.ts",
+    "prebench:node": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench:node": "node ./bench/run.ts",
+    "bench:moltar": "bun --conditions development ./bench/moltar.ts"
   },
   "imports": {
     "#generators/*": "./src/generators/*.ts",
@@ -56,12 +60,13 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "^0.17.0"
+    "@amritk/helpers": "^0.19.0"
   },
   "devDependencies": {
-    "@amritk/generate-markdown": "^0.5.0",
+    "@amritk/generate-markdown": "^0.6.0",
     "@sinclair/typebox": "^0.34.49",
     "ajv": "^8.17.1",
+    "benny": "^3.7.1",
     "zod": "^4.4.3"
   }
 }