@amritk/generate-parsers 0.7.1 → 0.8.0

package/README.md

@@ -132,7 +132,7 @@ Returns: `Promise<GeneratedFile[]>`.
 <td align="center"><code>false</code></td>
 </tr>
 <tr>
-<td colspan="5">Generate parsers that throw on type/shape mismatches (wrong type, missing required property, enum/pattern/min/max violations) instead of coercing invalid input to default values. Unknown extra keys are still allowed.</td>
+<td colspan="5">Generate parsers that throw on type/shape mismatches (wrong type, missing required property, enum/pattern/min/max violations) instead of coercing invalid input to default values. When a schema sets additionalProperties: false, undeclared keys throw too; otherwise they are still allowed.</td>
 </tr>
 </tbody>
 </table>

package/dist/generators/build-schema.d.ts

@@ -74,4 +74,3 @@ export type GeneratedFile = {
  * ```
  */
 export declare const buildSchema: (rootSchema: JSONSchema, rootTypeName: string, extensions?: SchemaExtensions, typesOnly?: boolean, logWarnings?: boolean, strict?: boolean, helpersMode?: HelpersMode, helpersImportPrefix?: string, readonly?: boolean, typeSuffix?: string) => Promise<GeneratedFile[]>;
-//# sourceMappingURL=build-schema.d.ts.map

package/dist/generators/generate-default-from-pattern.d.ts

@@ -3,4 +3,3 @@
  * Recognizes common patterns and returns appropriate defaults.
  */
 export declare const generateDefaultFromPattern: (pattern: string) => string | null;
-//# sourceMappingURL=generate-default-from-pattern.d.ts.map

package/dist/generators/generate-discriminated-union-validation.d.ts

@@ -4,4 +4,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Uses a discriminator property to efficiently choose the correct schema.
  */
 export declare const generateDiscriminatedUnionValidation: (accessor: string, schemas: readonly JSONSchema[], discriminatorKey: string, defaultValue: string, isRequired: boolean) => string;
-//# sourceMappingURL=generate-discriminated-union-validation.d.ts.map

package/dist/generators/generate-enum-check.d.ts

@@ -3,4 +3,3 @@
  * Returns a string that checks if the value is in the allowed enum values.
  */
 export declare const generateEnumCheck: (accessor: string, enumValues: readonly unknown[]) => string;
-//# sourceMappingURL=generate-enum-check.d.ts.map

package/dist/generators/generate-files.d.ts

@@ -91,4 +91,3 @@ export type GeneratedFileContent = {
  */
 export declare const generateFile: (schema: JSONSchema, typeName: string, options?: GenerateFileOptions) => GeneratedFileContent;
 export {};
-//# sourceMappingURL=generate-files.d.ts.map

package/dist/generators/generate-non-discriminated-union-validation.d.ts

@@ -4,4 +4,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Tries each schema in order until one matches.
  */
 export declare const generateNonDiscriminatedUnionValidation: (accessor: string, schemas: readonly JSONSchema[], defaultValue: string, isRequired: boolean) => string;
-//# sourceMappingURL=generate-non-discriminated-union-validation.d.ts.map

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

@@ -17,7 +17,8 @@ type GenerateParserOptions = {
     /**
      * When true, the generated parser throws on type/shape mismatches instead
      * of coercing invalid input to default values. Throws on the first violation
-     * with a path-aware Error. Unknown extra keys are still allowed.
+     * with a path-aware Error. When the schema sets `additionalProperties: false`,
+     * undeclared keys throw too; otherwise they are still allowed.
      */
     readonly strict?: boolean;
     /**
@@ -54,6 +55,5 @@ export declare const shapeValidatorFunctionName: (typeName: string) => string;
  * in additionalProperties). The stub is safe: parents calling it will fall
  * through to the slow path, matching the pre-deep-fast-path behavior.
  */
-export declare const generateShapeValidator: (schema: JSONSchema, typeName: string, useRefImports: boolean, suffix?: string) => string;
+export declare const generateShapeValidator: (schema: JSONSchema, typeName: string, useRefImports: boolean, suffix?: string, exported?: boolean) => string;
 export {};
-//# sourceMappingURL=generate-parser-function.d.ts.map

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

@@ -1,6 +1,7 @@
+import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { refToName } from '@amritk/helpers/ref-to-name';
 import { safeAccessor, safeKey } from '@amritk/helpers/safe-accessor';
-import { hasAllOf, hasAnyOf, hasConst, hasDefault, hasEnum, hasExamples, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasDefault, hasEnum, hasExamples, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
 import { getDefaultValue } from '../helpers/get-default-value.js';
 import { generateObjectStrictAssertion, generateScalarStrictAssertion } from './generate-strict-assertion.js';
 import { generateValidationExpression } from './generate-validation-expression.js';
@@ -251,7 +252,7 @@ const generateFallbackValue = (_, propSchema, useRefImports, suffix) => {
  * Generates a fallback object with required properties filled with default values.
  * This is used when input is not an object (undefined, null, etc.).
  */
-const generateFallbackObject = (schema, useRefImports, typeName, suffix) => {
+const generateFallbackObject = (schema, useRefImports, typeName, suffix, subTypeNames) => {
     if (!hasProperties(schema)) {
         return `{} as ${typeName}`;
     }
@@ -265,7 +266,12 @@ const generateFallbackObject = (schema, useRefImports, typeName, suffix) => {
     for (const [key, propSchema] of Object.entries(schema.properties)) {
         const isRequired = isPropertyRequired(key, schema);
         if (isRequired) {
-            const fallbackValue = generateFallbackValue(key, propSchema, useRefImports, suffix);
+            // Inline nested objects delegate to their sub-parser so the fallback
+            // carries proper deep defaults instead of an empty object literal.
+            const subName = subTypeNames?.get(key);
+            const fallbackValue = subName
+                ? `${generateParserName(subName)}(undefined)`
+                : generateFallbackValue(key, propSchema, useRefImports, suffix);
             if (fallbackValue === 'undefined') {
                 return `{} as ${typeName}`;
             }
@@ -343,6 +349,73 @@ const toVarName = (key) => {
  * whether `input` is already in the shape produced by the parser's fast path.
  */
 const shapeValidatorName = (typeName) => `validate${typeName}Shape`;
+/**
+ * Matches an inline nested object property — an object schema written directly
+ * under `properties` with its own `properties`, rather than referenced via
+ * `$ref`. These get a private sub-parser (and shape predicate) in the same
+ * generated file so their fields are actually parsed; anything involving
+ * composition, conditionals, enums, or record semantics keeps the existing
+ * code paths.
+ */
+const isInlineObjectProperty = (propSchema) => {
+    if (!isSchemaObject(propSchema))
+        return false;
+    if (hasRef(propSchema) || hasEnum(propSchema) || hasConst(propSchema))
+        return false;
+    if (hasOneOf(propSchema) || hasAnyOf(propSchema) || hasAllOf(propSchema))
+        return false;
+    if ('patternProperties' in propSchema || 'not' in propSchema || 'if' in propSchema)
+        return false;
+    // additionalProperties-as-schema records go through the record paths instead
+    if (hasAdditionalProperties(propSchema) && typeof propSchema.additionalProperties !== 'boolean')
+        return false;
+    return isObjectSchema(propSchema) && hasProperties(propSchema);
+};
+/**
+ * Builds the property-key → synthesized-type-name map for every inline nested
+ * object property of a schema, e.g. parent `Order` + key `shipTo` →
+ * `OrderShipTo`. Both the parser and the shape validator derive the map
+ * independently, so the naming (including collision suffixes) is a pure
+ * function of the schema and parent type name.
+ */
+const collectInlineObjectProperties = (schema, typeName) => {
+    const subTypeNames = new Map();
+    if (!hasProperties(schema))
+        return subTypeNames;
+    const used = new Set();
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (!isInlineObjectProperty(propSchema))
+            continue;
+        const pascal = key
+            .replace(/[^a-zA-Z0-9_$]/g, '_')
+            .split('_')
+            .filter((part) => part.length > 0)
+            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+            .join('');
+        let subName = `${typeName}${pascal || 'Value'}`;
+        while (used.has(subName))
+            subName = `${subName}_`;
+        used.add(subName);
+        subTypeNames.set(key, subName);
+    }
+    return subTypeNames;
+};
+/**
+ * True when the parser must reject (strict mode) or strip (coerce mode) every
+ * undeclared key: the schema sets `additionalProperties: false` and nothing
+ * else (key patterns, composition) can legitimately introduce extra keys.
+ */
+const hasStrictKeys = (schema) => {
+    if (!isSchemaObject(schema) || !hasProperties(schema))
+        return false;
+    if (!hasAdditionalProperties(schema) || schema.additionalProperties !== false)
+        return false;
+    if ('patternProperties' in schema)
+        return false;
+    if (hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema))
+        return false;
+    return true;
+};
 /**
  * Generates a fast-path type check expression for a property.
  * Returns null if the schema is too complex for a simple type check
@@ -456,22 +529,48 @@ const shouldCacheVariable = (propSchema, _canFastPath, _useRefImports) => {
  * - Fast path that returns input directly when all properties are already valid
  * - Slow path with optimized expressions
  */
-const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict) => {
+const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true) => {
     const functionName = generateParserName(typeName);
+    const exportPrefix = exported ? 'export ' : '';
     if (!hasProperties(schema)) {
         if (strict) {
-            return `export const ${functionName} = (input: unknown): ${typeName} => {\n  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);\n  return input as ${typeName};\n};`;
+            return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {\n  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);\n  return input as ${typeName};\n};`;
         }
-        return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
+        return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
     }
-    const fallbackObject = generateFallbackObject(schema, useRefImports, typeName, suffix);
     const properties = Object.entries(schema.properties);
+    // Inline nested object properties get a private sub-parser (plus shape
+    // predicate and type alias) in the same file, so their fields are parsed for
+    // real instead of only passing an isObject check. The sub-parser recurses
+    // through this same generator, so nesting works to any depth.
+    const subTypeNames = collectInlineObjectProperties(schema, typeName);
+    const preamble = [];
+    for (const [key, subName] of subTypeNames) {
+        const propSchema = schema.properties[key];
+        preamble.push(`type ${subName} = ${typeName}[${JSON.stringify(key)}];`);
+        preamble.push(generateShapeValidator(propSchema, subName, useRefImports, suffix, false));
+        preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false));
+    }
+    // additionalProperties: false — hoist the declared-keys Set so the per-call
+    // sweep is one Set lookup per key. The predicate form is shared by the fast
+    // path and the shape validator; strict mode throws with the offending key.
+    const strictKeys = hasStrictKeys(schema);
+    if (strictKeys) {
+        preamble.push(`const _knownKeys${typeName} = new Set(${JSON.stringify(properties.map(([key]) => key))});`);
+        preamble.push(`const _hasOnlyKnownKeys${typeName} = (input: Record<string, unknown>): boolean => {\n  for (const _k in input) if (!_knownKeys${typeName}.has(_k)) return false;\n  return true;\n};`);
+    }
+    const fallbackObject = generateFallbackObject(schema, useRefImports, typeName, suffix, subTypeNames);
     const lines = [];
-    lines.push(`export const ${functionName} = (input: unknown): ${typeName} => {`);
+    lines.push(`${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {`);
     if (strict) {
         for (const assertionLine of generateObjectStrictAssertion(schema, typeName)) {
             lines.push(assertionLine);
         }
+        if (strictKeys) {
+            lines.push(`  for (const _k in input) {`);
+            lines.push(`    if (!_knownKeys${typeName}.has(_k)) throw new Error(\`[${typeName}] unknown property "\${_k}"\`);`);
+            lines.push(`  }`);
+        }
     }
     else {
         lines.push(`  if (!isObject(input)) return ${fallbackObject};`);
@@ -498,7 +597,12 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
                 canFastPath = false;
             }
             else {
-                const check = generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
+                const subName = subTypeNames.get(key);
+                // Inline nested objects fast-path through their private shape
+                // predicate, the same way $ref properties use the imported one.
+                const check = subName
+                    ? `${shapeValidatorName(subName)}(${varName})`
+                    : generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
                 if (check === null) {
                     canFastPath = false;
                 }
@@ -513,6 +617,12 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
             }
         }
     }
+    // The fast path returns `{ ...input }`, so with additionalProperties: false
+    // it must only fire when no undeclared keys are present. Strict mode already
+    // threw on them above.
+    if (strictKeys && !strict) {
+        fastPathChecks.push(`_hasOnlyKnownKeys${typeName}(input)`);
+    }
     // Second pass: generate variable declarations only for properties that need them
     for (const { key, varName, propSchema } of propInfo) {
         if (shouldCacheVariable(propSchema, canFastPath, useRefImports)) {
@@ -537,9 +647,13 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         }
         lines.push(`  if (${fastPathExpr}) return { ...input } as ${typeName};`);
     }
-    // Generate slow-path object construction
+    // Generate slow-path object construction. The input spread preserves
+    // undeclared keys, so it is dropped when additionalProperties: false —
+    // building from the declared properties alone strips them from the result.
     const objectLines = [];
-    objectLines.push('    ...input,');
+    if (!strictKeys) {
+        objectLines.push('    ...input,');
+    }
     // Spread allOf $ref parsers so their field coercions are applied before
     // the explicit property validations below.
     if (useRefImports && isSchemaObject(schema) && hasAllOf(schema)) {
@@ -553,6 +667,19 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
     for (const { key, varName, isRequired, propSchema } of propInfo) {
         const shouldCache = shouldCacheVariable(propSchema, canFastPath, useRefImports);
         const accessor = shouldCache ? varName : safeAccessor('input', key);
+        // Handle inline nested objects via their private sub-parser, mirroring
+        // how $ref properties delegate to the imported parser.
+        const subName = subTypeNames.get(key);
+        if (subName) {
+            const subParserName = generateParserName(subName);
+            if (isRequired) {
+                objectLines.push(`    ${safeKey(key)}: ${subParserName}(${accessor}),`);
+            }
+            else {
+                objectLines.push(`    ...(${accessor} !== undefined && { ${safeKey(key)}: ${subParserName}(${accessor}) }),`);
+            }
+            continue;
+        }
         // Handle direct $ref properties via imported parsers
         if (shouldUseRefImport(propSchema, useRefImports)) {
             const ref = propSchema.$ref;
@@ -612,20 +739,13 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         }
     }
     lines.push(`  return {`);
-    // objectLines[0] is safe: objectLines is always non-empty (has at least the closing brace line)
-    let objectBody = objectLines[0];
-    for (let i = 1; i < objectLines.length; i++) {
-        objectBody += '\n' + objectLines[i];
-    }
-    lines.push(objectBody);
+    lines.push(objectLines.join('\n'));
     lines.push(`  } as unknown as ${typeName};`);
     lines.push(`}`);
-    // lines[0] is safe: lines is always non-empty (it always has the function declaration)
-    let result = lines[0];
-    for (let i = 1; i < lines.length; i++) {
-        result += '\n' + lines[i];
-    }
-    return result;
+    const fn = lines.join('\n');
+    if (preamble.length === 0)
+        return fn;
+    return `${preamble.join('\n\n')}\n\n${fn}`;
 };
 /**
  * Generates a parser for schemas that have both properties AND patternProperties.
@@ -742,14 +862,6 @@ const generateInlineValueParser = (schema) => {
             return null;
     }
 };
-/**
- * Escapes special regex characters in a pattern string for use in a regex literal.
- * This escapes backslashes and forward slashes for safe inclusion in /pattern/ syntax.
- */
-const escapeRegexPattern = (pattern) => {
-    // Escape backslashes first, then forward slashes
-    return pattern.replace(/\\/g, '\\\\').replace(/\//g, '\\/');
-};
 /**
  * Generates a parser for schemas with patternProperties.
  * Handles both patternProperties and specification-extensions (x- prefix).
@@ -1018,9 +1130,10 @@ export const shapeValidatorFunctionName = (typeName) => shapeValidatorName(typeN
  * in additionalProperties). The stub is safe: parents calling it will fall
  * through to the slow path, matching the pre-deep-fast-path behavior.
  */
-export const generateShapeValidator = (schema, typeName, useRefImports, suffix = '') => {
+export const generateShapeValidator = (schema, typeName, useRefImports, suffix = '', exported = true) => {
     const fnName = shapeValidatorName(typeName);
-    const stub = `export const ${fnName} = (_input: unknown): boolean => false;`;
+    const exportPrefix = exported ? 'export ' : '';
+    const stub = `${exportPrefix}const ${fnName} = (_input: unknown): boolean => false;`;
     if (!isSchemaObject(schema))
         return stub;
     if (!hasProperties(schema))
@@ -1037,6 +1150,12 @@ export const generateShapeValidator = (schema, typeName, useRefImports, suffix =
         return stub;
     }
     const properties = Object.entries(schema.properties);
+    // Same deterministic naming as the parser's sub-parser generation, so the
+    // referenced private shape predicates exist in the same file.
+    const subTypeNames = collectInlineObjectProperties(schema, typeName);
+    // With additionalProperties: false the shape only matches when every key is
+    // declared, so the parser's fast path will not smuggle extras through.
+    const strictKeysGuard = hasStrictKeys(schema) ? `\n  if (!_hasOnlyKnownKeys${typeName}(input)) return false;` : '';
     const checks = [];
     for (const [key, propSchema] of properties) {
         // Records of refs require iterating every value — too expensive for the fast path.
@@ -1045,7 +1164,10 @@ export const generateShapeValidator = (schema, typeName, useRefImports, suffix =
         }
         const accessor = safeAccessor('input', key);
         const isRequired = isPropertyRequired(key, schema);
-        const check = generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
+        const subName = subTypeNames.get(key);
+        const check = subName
+            ? `${shapeValidatorName(subName)}(${accessor})`
+            : generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
         if (check === null) {
             return stub;
         }
@@ -1057,14 +1179,20 @@ export const generateShapeValidator = (schema, typeName, useRefImports, suffix =
         }
     }
     if (checks.length === 0) {
-        return `export const ${fnName} = (input: unknown): boolean => isObject(input);`;
+        if (strictKeysGuard) {
+            return `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
+  if (!isObject(input)) return false;${strictKeysGuard}
+  return true;
+};`;
+        }
+        return `${exportPrefix}const ${fnName} = (input: unknown): boolean => isObject(input);`;
     }
     let body = checks[0];
     for (let i = 1; i < checks.length; i++) {
         body += '\n    && ' + checks[i];
     }
-    return `export const ${fnName} = (input: unknown): boolean => {
-  if (!isObject(input)) return false;
+    return `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
+  if (!isObject(input)) return false;${strictKeysGuard}
   return ${body};
 };`;
 };

package/dist/generators/generate-schema-checks.d.ts

@@ -3,4 +3,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Generates validation checks for a single schema (used in union validation).
  */
 export declare const generateSchemaChecks: (accessor: string, schema: JSONSchema) => string[];
-//# sourceMappingURL=generate-schema-checks.d.ts.map

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

@@ -1,3 +1,4 @@
+import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
 import { hasAdditionalProperties, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, } from '@amritk/helpers/schema-guards';
 import { generateEnumCheck } from './generate-enum-check.js';
@@ -23,7 +24,7 @@ export const generateSchemaChecks = (accessor, schema) => {
         case 'string': {
             checks.push(`typeof ${accessor} === "string"`);
             if (hasPattern(schema)) {
-                checks.push(`/${schema.pattern.replace(/\//g, '\\/')}/.test(${accessor})`);
+                checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${accessor})`);
             }
             if (hasMinLength(schema)) {
                 checks.push(`${accessor}.length >= ${schema.minLength}`);

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

@@ -16,4 +16,3 @@ export declare const generateObjectStrictAssertion: (schema: JSONSchema, typeNam
  * Returns null when the schema has no type information to assert on.
  */
 export declare const generateScalarStrictAssertion: (schema: JSONSchema, typeName: string) => string | null;
-//# sourceMappingURL=generate-strict-assertion.d.ts.map

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

@@ -1,3 +1,4 @@
+import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
 import { safeAccessor } from '@amritk/helpers/safe-accessor';
 import { hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaximum, hasMaxLength, hasMinimum, hasMinLength, hasMultipleOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, isSchemaObject, } from '@amritk/helpers/schema-guards';
@@ -27,12 +28,6 @@ const wrongTypeCondition = (accessor, type) => {
  * `integer` collapses to `number` since both are validated via `typeof === "number"`.
  */
 const typeLabel = (type) => (type === 'integer' ? 'number' : type);
-/**
- * Escapes special regex characters in a pattern string for use in a regex literal.
- */
-const escapeRegexPattern = (pattern) => {
-    return pattern.replace(/\\/g, '\\\\').replace(/\//g, '\\/');
-};
 /**
  * Generates strict-mode constraint checks for a typed property
  * (pattern, length, min/max, multipleOf).

package/dist/generators/generate-validation-expression.d.ts

@@ -5,4 +5,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Supports type checking, pattern validation, enum validation, union types, and $ref resolution.
  */
 export declare const generateValidationExpression: (key: string, schema: JSONSchema, defaultValue: string, isRequired: boolean, rootSchema?: Record<string, unknown>, visitedRefs?: Set<string>, accessorOverride?: string, knownNotUndefined?: boolean) => string;
-//# sourceMappingURL=generate-validation-expression.d.ts.map

package/dist/generators/generate-validation-expression.js

@@ -1,3 +1,4 @@
+import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
 import { resolveRef } from '@amritk/helpers/resolve-ref';
 import { safeAccessor } from '@amritk/helpers/safe-accessor';
@@ -153,7 +154,7 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
             case 'string': {
                 checks.push(`typeof ${accessor} === "string"`);
                 if (hasPattern(schema)) {
-                    checks.push(`/${schema.pattern.replace(/\//g, '\\/')}/.test(${accessor})`);
+                    checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${accessor})`);
                 }
                 if (hasMinLength(schema)) {
                     checks.push(`${accessor}.length >= ${schema.minLength}`);

package/dist/helpers/apply-schema-extensions.d.ts

@@ -33,4 +33,3 @@ import type { SchemaExtensions } from '../types/schema-extensions.js';
  * ```
  */
 export declare const applySchemaExtensions: (schema: JSONSchema, definitionName: string, extensions: SchemaExtensions) => JSONSchema;
-//# sourceMappingURL=apply-schema-extensions.d.ts.map

package/dist/helpers/collect-helpers.d.ts

@@ -21,4 +21,3 @@ export type CollectedHelpers = {
  *   `_helpers/` directory at the output root.
  */
 export declare const collectHelpers: (parserFunction: string, mode: HelpersMode, helpersImportPrefix?: string) => CollectedHelpers;
-//# sourceMappingURL=collect-helpers.d.ts.map

package/dist/helpers/collect-imports.d.ts

@@ -68,4 +68,3 @@ type CollectImportsOptions = {
  */
 export declare const collectImports: (schema: JSONSchema, options?: CollectImportsOptions) => string[];
 export {};
-//# sourceMappingURL=collect-imports.d.ts.map

package/dist/helpers/find-discriminator.d.ts

@@ -4,4 +4,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Returns the property name if a suitable discriminator is found, otherwise null.
  */
 export declare const findDiscriminator: (schemas: readonly JSONSchema[]) => string | null;
-//# sourceMappingURL=find-discriminator.d.ts.map

package/dist/helpers/get-default-value.d.ts

@@ -5,4 +5,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * These defaults ensure that parsing never fails, even with missing data.
  */
 export declare const getDefaultValue: (schema: JSONSchema) => string;
-//# sourceMappingURL=get-default-value.d.ts.map

package/dist/helpers/get-discriminator-value.d.ts

@@ -4,4 +4,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Returns the const value or single enum value if available.
  */
 export declare const getDiscriminatorValue: (schema: JSONSchema, discriminatorKey: string) => unknown | null;
-//# sourceMappingURL=get-discriminator-value.d.ts.map

package/dist/index.d.ts

@@ -1,2 +1 @@
 export { buildSchema, type GeneratedFile } from './generators/build-schema.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/schema-extensions.d.ts

@@ -32,4 +32,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * ```
  */
 export type SchemaExtensions = Record<string, Record<string, JSONSchema>>;
-//# sourceMappingURL=schema-extensions.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -23,8 +23,7 @@
     "url": "https://github.com/amritk/mjst/issues"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
@@ -42,14 +41,13 @@
   },
   "exports": {
     ".": {
-      "development": "./src/index.ts",
       "default": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.7.1",
+    "@amritk/helpers": "0.9.0",
     "@amritk/generate-markdown": "0.2.4"
   }
 }

package/dist/generators/build-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-schema.d.ts","sourceRoot":"","sources":["../../src/generators/build-schema.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAEjE,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,0BAA0B,CAAA;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAahE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,eAAO,MAAM,WAAW,eACV,UAAU,gBACR,MAAM,eACP,gBAAgB,cACjB,OAAO,gBACL,OAAO,WACZ,OAAO,gBACH,WAAW,4EAIvB,OAAO,CAAC,aAAa,EAAE,CAyCzB,CAAA"}

package/dist/generators/generate-default-from-pattern.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-default-from-pattern.d.ts","sourceRoot":"","sources":["../../src/generators/generate-default-from-pattern.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,0BAA0B,YAAa,MAAM,KAAG,MAAM,GAAG,IAkCrE,CAAA"}

package/dist/generators/generate-discriminated-union-validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-discriminated-union-validation.d.ts","sourceRoot":"","sources":["../../src/generators/generate-discriminated-union-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAMjE;;;GAGG;AACH,eAAO,MAAM,oCAAoC,aACrC,MAAM,WACP,SAAS,UAAU,EAAE,oBACZ,MAAM,gBACV,MAAM,cACR,OAAO,KAClB,MAqCF,CAAA"}

package/dist/generators/generate-enum-check.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-enum-check.d.ts","sourceRoot":"","sources":["../../src/generators/generate-enum-check.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,aAAc,MAAM,cAAc,SAAS,OAAO,EAAE,KAAG,MAGpF,CAAA"}

package/dist/generators/generate-files.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-files.d.ts","sourceRoot":"","sources":["../../src/generators/generate-files.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACvB,MAAM,0BAA0B,CAAA;AAKjC;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7C;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAA;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IACrC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED,iDAAiD;AACjD,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAA;CACrD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,YAAY,WACf,UAAU,YACR,MAAM,YACN,mBAAmB,KAC5B,oBA+CF,CAAA"}

package/dist/generators/generate-non-discriminated-union-validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-non-discriminated-union-validation.d.ts","sourceRoot":"","sources":["../../src/generators/generate-non-discriminated-union-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAIjE;;;GAGG;AACH,eAAO,MAAM,uCAAuC,aACxC,MAAM,WACP,SAAS,UAAU,EAAE,gBAChB,MAAM,cACR,OAAO,KAClB,MA0BF,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"generate-parser-function.d.ts","sourceRoot":"","sources":["../../src/generators/generate-parser-function.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAMjE;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;IAChC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAqqCD;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,WACzB,UAAU,YACR,MAAM,YACN,qBAAqB,KAC9B,MAEF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,aAAc,MAAM,KAAG,MAAsC,CAAA;AAEpG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,WACzB,UAAU,YACR,MAAM,iBACD,OAAO,sBAErB,MAyDF,CAAA"}

package/dist/generators/generate-schema-checks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-schema-checks.d.ts","sourceRoot":"","sources":["../../src/generators/generate-schema-checks.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAIjE;;GAEG;AACH,eAAO,MAAM,oBAAoB,aAAc,MAAM,UAAU,UAAU,KAAG,MAAM,EAkGjF,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"generate-strict-assertion.d.ts","sourceRoot":"","sources":["../../src/generators/generate-strict-assertion.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAsLjE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,WAAY,UAAU,YAAY,MAAM,KAAG,MAAM,EAe1F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,6BAA6B,WAAY,UAAU,YAAY,MAAM,KAAG,MAAM,GAAG,IAgB7F,CAAA"}

package/dist/generators/generate-validation-expression.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-validation-expression.d.ts","sourceRoot":"","sources":["../../src/generators/generate-validation-expression.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAgDjE;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,QAClC,MAAM,UACH,UAAU,gBACJ,MAAM,cACR,OAAO,eACN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,gBACtB,GAAG,CAAC,MAAM,CAAC,qBACN,MAAM,sBACL,OAAO,KAC1B,MA0OF,CAAA"}

package/dist/helpers/apply-schema-extensions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"apply-schema-extensions.d.ts","sourceRoot":"","sources":["../../src/helpers/apply-schema-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,qBAAqB,WACxB,UAAU,kBACF,MAAM,cACV,gBAAgB,KAC3B,UAuBF,CAAA"}

package/dist/helpers/collect-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collect-helpers.d.ts","sourceRoot":"","sources":["../../src/helpers/collect-helpers.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,SAAS,CAAA;AAE9F,sEAAsE;AACtE,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,UAAU,CAAA;AAEhD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAA;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAA;CACtC,CAAA;AAoBD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,mBACT,MAAM,QAChB,WAAW,mCAEhB,gBA+BF,CAAA"}

package/dist/helpers/collect-imports.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collect-imports.d.ts","sourceRoot":"","sources":["../../src/helpers/collect-imports.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAIjE;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC3B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACrC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;IACzD;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,cAAc,WAAY,UAAU,YAAY,qBAAqB,KAAG,MAAM,EAsM1F,CAAA"}

package/dist/helpers/find-discriminator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find-discriminator.d.ts","sourceRoot":"","sources":["../../src/helpers/find-discriminator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAEjE;;;GAGG;AACH,eAAO,MAAM,iBAAiB,YAAa,SAAS,UAAU,EAAE,KAAG,MAAM,GAAG,IA+B3E,CAAA"}

package/dist/helpers/get-default-value.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-default-value.d.ts","sourceRoot":"","sources":["../../src/helpers/get-default-value.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAGjE;;;;GAIG;AACH,eAAO,MAAM,eAAe,WAAY,UAAU,KAAG,MA0EpD,CAAA"}

package/dist/helpers/get-discriminator-value.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-discriminator-value.d.ts","sourceRoot":"","sources":["../../src/helpers/get-discriminator-value.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAEjE;;;GAGG;AACH,eAAO,MAAM,qBAAqB,WAAY,UAAU,oBAAoB,MAAM,KAAG,OAAO,GAAG,IAa9F,CAAA"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,aAAa,EAAE,MAAM,2BAA2B,CAAA"}

package/dist/types/schema-extensions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-extensions.d.ts","sourceRoot":"","sources":["../../src/types/schema-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA"}