@amritk/generate-parsers 0.16.2 → 0.17.0

package/dist/helpers/collect-helpers.js

@@ -1,77 +1,64 @@
 const PACKAGE_IMPORTS = {
-    'is-object': "import { isObject } from '@amritk/helpers/is-object';",
-    'validate-array': "import { validateArray } from '@amritk/helpers/validate-array';",
-    'validate-record': "import { validateRecord } from '@amritk/helpers/validate-record';",
-    // hasRef has historically lived in the schema-guards subpath; preserve that for package mode.
-    'has-ref': "import { hasRef } from '@amritk/helpers/schema-guards';",
+  "is-object": "import { isObject } from '@amritk/helpers/is-object';",
+  "validate-array": "import { validateArray } from '@amritk/helpers/validate-array';",
+  "validate-record": "import { validateRecord } from '@amritk/helpers/validate-record';",
+  // hasRef has historically lived in the schema-guards subpath; preserve that for package mode.
+  "has-ref": "import { hasRef } from '@amritk/helpers/schema-guards';"
 };
 const EMBEDDED_NAMED_EXPORTS = {
-    'is-object': 'isObject',
-    'validate-array': 'validateArray',
-    'validate-record': 'validateRecord',
-    'has-ref': 'hasRef',
+  "is-object": "isObject",
+  "validate-array": "validateArray",
+  "validate-record": "validateRecord",
+  "has-ref": "hasRef"
 };
-const embeddedImport = (helper, prefix, ext) => 
-// An explicit extension so the embedded-helper import resolves under Node ESM, not only Bun.
-`import { ${EMBEDDED_NAMED_EXPORTS[helper]} } from '${prefix}_helpers/${helper}.${ext}';`;
-/**
- * Detects which runtime helpers a generated parser body references.
- *
- * @param helpersImportPrefix - Relative path prefix to the shared `_helpers/`
- *   directory in embedded mode. Defaults to `'./'`. The recursive multi-schema
- *   build passes `'../'`, `'../../'`, etc. so nested parsers can reach a single
- *   `_helpers/` directory at the output root.
- * @param importExt - Extension used on embedded-helper import specifiers.
- *   Defaults to `'js'` (the TS NodeNext form); `'ts'` makes the output runnable
- *   under Node's type stripping.
- */
-// One alternation pass over the generated source instead of four full-text
-// `.includes` scans — an absent helper name used to cost a complete rescan
-// each, which showed up at several percent of total generation time.
+const embeddedImport = (helper, prefix, ext) => (
+  // An explicit extension so the embedded-helper import resolves under Node ESM, not only Bun.
+  `import { ${EMBEDDED_NAMED_EXPORTS[helper]} } from '${prefix}_helpers/${helper}.${ext}';`
+);
 const HELPER_USAGE = /validateArray|validateRecord|isObject|hasRef\(/g;
-export const collectHelpers = (parserFunction, mode, helpersImportPrefix = './', importExt = 'js') => {
-    const imports = [];
-    const used = new Set();
-    const importFor = (helper) => mode === 'embedded' ? embeddedImport(helper, helpersImportPrefix, importExt) : PACKAGE_IMPORTS[helper];
-    let sawValidateArray = false;
-    let sawValidateRecord = false;
-    let sawIsObject = false;
-    let sawHasRef = false;
-    HELPER_USAGE.lastIndex = 0;
-    let match = HELPER_USAGE.exec(parserFunction);
-    while (match !== null) {
-        const token = match[0];
-        if (token === 'validateArray')
-            sawValidateArray = true;
-        else if (token === 'validateRecord')
-            sawValidateRecord = true;
-        else if (token === 'isObject')
-            sawIsObject = true;
-        else
-            sawHasRef = true;
-        if (sawValidateArray && sawValidateRecord && sawIsObject && sawHasRef)
-            break;
-        match = HELPER_USAGE.exec(parserFunction);
-    }
-    if (sawValidateArray) {
-        imports.push(importFor('validate-array'));
-        used.add('validate-array');
-    }
-    if (sawValidateRecord) {
-        imports.push(importFor('validate-record'));
-        used.add('validate-record');
-        // The embedded validate-record.ts imports is-object, so it must be shipped too —
-        // but only the `validate-record` line is needed in the parser file unless the
-        // parser body itself references `isObject` (handled below).
-        used.add('is-object');
-    }
-    if (sawIsObject) {
-        imports.push(importFor('is-object'));
-        used.add('is-object');
-    }
-    if (sawHasRef) {
-        imports.push(importFor('has-ref'));
-        used.add('has-ref');
-    }
-    return { imports, used };
+const collectHelpers = (parserFunction, mode, helpersImportPrefix = "./", importExt = "js") => {
+  const imports = [];
+  const used = /* @__PURE__ */ new Set();
+  const importFor = (helper) => mode === "embedded" ? embeddedImport(helper, helpersImportPrefix, importExt) : PACKAGE_IMPORTS[helper];
+  let sawValidateArray = false;
+  let sawValidateRecord = false;
+  let sawIsObject = false;
+  let sawHasRef = false;
+  HELPER_USAGE.lastIndex = 0;
+  let match = HELPER_USAGE.exec(parserFunction);
+  while (match !== null) {
+    const token = match[0];
+    if (token === "validateArray")
+      sawValidateArray = true;
+    else if (token === "validateRecord")
+      sawValidateRecord = true;
+    else if (token === "isObject")
+      sawIsObject = true;
+    else
+      sawHasRef = true;
+    if (sawValidateArray && sawValidateRecord && sawIsObject && sawHasRef)
+      break;
+    match = HELPER_USAGE.exec(parserFunction);
+  }
+  if (sawValidateArray) {
+    imports.push(importFor("validate-array"));
+    used.add("validate-array");
+  }
+  if (sawValidateRecord) {
+    imports.push(importFor("validate-record"));
+    used.add("validate-record");
+    used.add("is-object");
+  }
+  if (sawIsObject) {
+    imports.push(importFor("is-object"));
+    used.add("is-object");
+  }
+  if (sawHasRef) {
+    imports.push(importFor("has-ref"));
+    used.add("has-ref");
+  }
+  return { imports, used };
+};
+export {
+  collectHelpers
 };

package/dist/helpers/collect-imports.js

@@ -1,242 +1,166 @@
-import { refToFilename } from '@amritk/helpers/ref-to-filename';
-import { refToName } from '@amritk/helpers/ref-to-name';
-import { resolveRef } from '@amritk/helpers/resolve-ref';
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasRef } from '@amritk/helpers/schema-guards';
-// Emit an explicit extension on the relative specifier. Node's ESM resolver
-// requires one (extensionless relative imports only work under a bundler or
-// Bun). `./x.js` pointing at a sibling `x.ts` is the standard TS NodeNext form
-// — accepted by Bun, esbuild, webpack, and tsc alike — while `./x.ts` is the
-// literal on-disk path Node's type stripping needs to run the sources directly.
+import { refToFilename } from "@amritk/helpers/ref-to-filename";
+import { refToName } from "@amritk/helpers/ref-to-name";
+import { resolveRef } from "@amritk/helpers/resolve-ref";
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasRef } from "@amritk/helpers/schema-guards";
 const getImportPathForFilename = (filename, ext) => `./${filename}.${ext}`;
-/**
- * Collects all import statements needed for a schema by finding $ref references
- * that are directly used in the type definition (from properties, items, etc.).
- * Does not include refs from nested schema definitions.
- *
- * Generates both type imports and parser function imports for each $ref.
- * The parser imports allow validators to delegate validation to the referenced
- * schema's parser instead of inlining the validation logic.
- *
- * Also detects when helper functions (isObject) and validators (validateRecord,
- * validateArray) are needed based on the schema structure.
- *
- * @param schema - The JSON Schema to collect imports from
- * @param options - Optional settings to control import generation
- * @returns An array of import statements
- *
- * @example
- * ```ts
- * const schema = {
- *   type: 'object',
- *   properties: {
- *     contact: { $ref: '#/$defs/contact' },
- *     server: { $ref: '#/$defs/server' }
- *   }
- * }
- * const imports = collectImports(schema)
- * // imports = [
- * //   "import { type Contact, parseContact } from './contact';",
- * //   "import { type Server, parseServer } from './server';"
- * // ]
- *
- * // With typesOnly, only type imports are generated:
- * const typeImports = collectImports(schema, { typesOnly: true })
- * // typeImports = [
- * //   "import type { Contact } from './contact';",
- * //   "import type { Server } from './server';"
- * // ]
- * ```
- */
-export const collectImports = (schema, options) => {
-    const typesOnly = options?.typesOnly === true;
-    const importExt = options?.importExt ?? 'js';
-    const importMap = new Map();
-    for (const [filename, typeName] of collectImportTargets(schema, options)) {
-        const importPath = getImportPathForFilename(filename, importExt);
-        // In types-only mode, omit the parser function import since there is no parser to call
-        const importStatement = typesOnly
-            ? `import type { ${typeName} } from '${importPath}';`
-            : `import { type ${typeName}, parse${typeName}, validate${typeName}Shape } from '${importPath}';`;
-        importMap.set(filename, importStatement);
-    }
-    return Array.from(importMap.values()).sort();
+const collectImports = (schema, options) => {
+  const typesOnly = options?.typesOnly === true;
+  const importExt = options?.importExt ?? "js";
+  const importMap = /* @__PURE__ */ new Map();
+  for (const [filename, typeName] of collectImportTargets(schema, options)) {
+    const importPath = getImportPathForFilename(filename, importExt);
+    const importStatement = typesOnly ? `import type { ${typeName} } from '${importPath}';` : `import { type ${typeName}, parse${typeName}, validate${typeName}Shape } from '${importPath}';`;
+    importMap.set(filename, importStatement);
+  }
+  return Array.from(importMap.values()).sort();
 };
-/**
- * The type names a generated file will import for its `$ref`s — the same
- * dedup/skip rules as {@link collectImports}. Generators seed their private
- * sub-type naming with this set so a synthesized name (e.g. a root array's
- * `FooItem`) can never shadow an imported identifier.
- */
-export const collectImportTypeNames = (schema, options) => {
-    const names = new Set();
-    for (const [, typeName] of collectImportTargets(schema, options))
-        names.add(typeName);
-    return names;
+const collectImportTypeNames = (schema, options) => {
+  const names = /* @__PURE__ */ new Set();
+  for (const [, typeName] of collectImportTargets(schema, options))
+    names.add(typeName);
+  return names;
 };
-/** Shared `$ref` walk: filename → derived type name for every import target. */
 const collectImportTargets = (schema, options) => {
-    const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : undefined;
-    const rootSchema = options?.rootSchema;
-    const typeSuffix = options?.typeSuffix;
-    const refs = new Set();
-    const collectRefsFromValue = (value) => {
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                collectRefsFromValue(item);
-            }
-            return;
-        }
-        const record = value;
-        // If this is a $ref, add it — but skip:
-        // - Relative path refs (e.g. /components/messages/foo) which point into example data
-        // - URI refs with fragments pointing into `properties` (not standalone definitions)
-        if (hasRef(record)) {
-            const ref = record.$ref;
-            const isInternal = ref.startsWith('#');
-            const isUri = ref.startsWith('http://') || ref.startsWith('https://');
-            const isPropertyFragment = isUri && ref.includes('#/properties/');
-            if (isInternal || (isUri && !isPropertyFragment)) {
-                refs.add(ref);
-            }
-            return; // Don't traverse further into a $ref
-        }
-        // Check if this is an object type with additionalProperties that has a $ref
-        // This pattern requires validateRecord
-        if (hasAdditionalProperties(record) && hasRef(record.additionalProperties)) {
-            collectRefsFromValue(record.additionalProperties);
-            return;
-        }
-        // Check if this is an array type with items that has a $ref
-        // This pattern requires validateArray
-        if (record.type === 'array' && hasItems(record) && hasRef(record.items)) {
-            collectRefsFromValue(record.items);
-            return;
-        }
-        // Traverse nested properties regardless of whether `type` is explicitly set.
-        if ('properties' in record && typeof record.properties === 'object' && record.properties !== null) {
-            const props = record.properties;
-            for (const key in props) {
-                collectRefsFromValue(props[key]);
-            }
-        }
-        // Traverse into type composition keywords
-        if (hasOneOf(record)) {
-            for (const item of record.oneOf) {
-                collectRefsFromValue(item);
-            }
-        }
-        if (hasAnyOf(record)) {
-            for (const item of record.anyOf) {
-                collectRefsFromValue(item);
-            }
-        }
-        if (hasAllOf(record)) {
-            for (const item of record.allOf) {
-                collectRefsFromValue(item);
-            }
-        }
-        // Traverse into array items
-        if (hasItems(record)) {
-            collectRefsFromValue(record.items);
-        }
-        // Traverse into additionalProperties
-        if (hasAdditionalProperties(record)) {
-            collectRefsFromValue(record.additionalProperties);
-        }
-        // Traverse all patternProperties
-        if ('patternProperties' in record &&
-            typeof record.patternProperties === 'object' &&
-            record.patternProperties !== null) {
-            const patternProps = record.patternProperties;
-            for (const key in patternProps) {
-                collectRefsFromValue(patternProps[key]);
-            }
-        }
-        // Traverse into if/then/else branches
-        if ('then' in record) {
-            collectRefsFromValue(record.then);
-        }
-        if ('else' in record) {
-            collectRefsFromValue(record.else);
-        }
-    };
-    // Collect refs from root-level $ref
-    if (typeof schema === 'object' && schema !== null && hasRef(schema)) {
-        const ref = schema.$ref;
-        const isInternal = ref.startsWith('#');
-        const isUri = ref.startsWith('http://') || ref.startsWith('https://');
-        const isPropertyFragment = isUri && ref.includes('#/properties/');
-        if (isInternal || (isUri && !isPropertyFragment)) {
-            refs.add(ref);
-        }
-    }
-    // Collect refs from properties
-    if (typeof schema === 'object' && schema !== null && 'properties' in schema) {
-        const properties = schema.properties;
-        for (const key in properties) {
-            collectRefsFromValue(properties[key]);
-        }
-    }
-    // Collect refs from root-level additionalProperties
-    if (typeof schema === 'object' && schema !== null && 'additionalProperties' in schema) {
-        collectRefsFromValue(schema.additionalProperties);
-    }
-    // Collect refs from root-level patternProperties
-    if (typeof schema === 'object' && schema !== null && 'patternProperties' in schema) {
-        const patternProps = schema.patternProperties;
-        for (const key in patternProps) {
-            collectRefsFromValue(patternProps[key]);
-        }
-    }
-    // Collect refs from root-level items (when the schema itself is an array type)
-    if (typeof schema === 'object' && schema !== null && hasItems(schema)) {
-        collectRefsFromValue(schema.items);
-    }
-    // Collect refs from root-level composition keywords.
-    if (typeof schema === 'object' && schema !== null && hasOneOf(schema)) {
-        for (const item of schema.oneOf) {
-            collectRefsFromValue(item);
-        }
-    }
-    if (typeof schema === 'object' && schema !== null && hasAnyOf(schema)) {
-        for (const item of schema.anyOf) {
-            collectRefsFromValue(item);
-        }
-    }
-    if (typeof schema === 'object' && schema !== null && hasAllOf(schema)) {
-        for (const item of schema.allOf) {
-            collectRefsFromValue(item);
-        }
-    }
-    // Collect refs from root-level conditional branches.
-    if (typeof schema === 'object' && schema !== null && 'if' in schema) {
-        collectRefsFromValue(schema.if);
-    }
-    if (typeof schema === 'object' && schema !== null && 'then' in schema) {
-        collectRefsFromValue(schema.then);
-    }
-    if (typeof schema === 'object' && schema !== null && 'else' in schema) {
-        collectRefsFromValue(schema.else);
-    }
-    // Convert refs to import targets, deduplicating by filename.
-    const targets = new Map();
-    for (const ref of refs) {
-        // For URI refs, skip if the base URI is not resolvable in the root schema.
-        // This prevents generating imports for external schemas that were never generated as files.
-        if (rootSchema !== undefined && (ref.startsWith('http://') || ref.startsWith('https://'))) {
-            if (!resolveRef(ref, rootSchema))
-                continue;
-        }
-        const typeName = refToName(ref, typeSuffix);
-        const filename = refToFilename(ref);
-        // Skip self-referential imports — a file must not import from itself
-        if (selfFilename !== undefined && filename === selfFilename) {
-            continue;
-        }
-        targets.set(filename, typeName);
-    }
-    return targets;
+  const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : void 0;
+  const rootSchema = options?.rootSchema;
+  const typeSuffix = options?.typeSuffix;
+  const refs = /* @__PURE__ */ new Set();
+  const collectRefsFromValue = (value) => {
+    if (typeof value !== "object" || value === null) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        collectRefsFromValue(item);
+      }
+      return;
+    }
+    const record = value;
+    if (hasRef(record)) {
+      const ref = record.$ref;
+      const isInternal = ref.startsWith("#");
+      const isUri = ref.startsWith("http://") || ref.startsWith("https://");
+      const isPropertyFragment = isUri && ref.includes("#/properties/");
+      if (isInternal || isUri && !isPropertyFragment) {
+        refs.add(ref);
+      }
+      return;
+    }
+    if (hasAdditionalProperties(record) && hasRef(record.additionalProperties)) {
+      collectRefsFromValue(record.additionalProperties);
+      return;
+    }
+    if (record.type === "array" && hasItems(record) && hasRef(record.items)) {
+      collectRefsFromValue(record.items);
+      return;
+    }
+    if ("properties" in record && typeof record.properties === "object" && record.properties !== null) {
+      const props = record.properties;
+      for (const key in props) {
+        collectRefsFromValue(props[key]);
+      }
+    }
+    if (hasOneOf(record)) {
+      for (const item of record.oneOf) {
+        collectRefsFromValue(item);
+      }
+    }
+    if (hasAnyOf(record)) {
+      for (const item of record.anyOf) {
+        collectRefsFromValue(item);
+      }
+    }
+    if (hasAllOf(record)) {
+      for (const item of record.allOf) {
+        collectRefsFromValue(item);
+      }
+    }
+    if (hasItems(record)) {
+      collectRefsFromValue(record.items);
+    }
+    if (hasAdditionalProperties(record)) {
+      collectRefsFromValue(record.additionalProperties);
+    }
+    if ("patternProperties" in record && typeof record.patternProperties === "object" && record.patternProperties !== null) {
+      const patternProps = record.patternProperties;
+      for (const key in patternProps) {
+        collectRefsFromValue(patternProps[key]);
+      }
+    }
+    if ("then" in record) {
+      collectRefsFromValue(record.then);
+    }
+    if ("else" in record) {
+      collectRefsFromValue(record.else);
+    }
+  };
+  if (typeof schema === "object" && schema !== null && hasRef(schema)) {
+    const ref = schema.$ref;
+    const isInternal = ref.startsWith("#");
+    const isUri = ref.startsWith("http://") || ref.startsWith("https://");
+    const isPropertyFragment = isUri && ref.includes("#/properties/");
+    if (isInternal || isUri && !isPropertyFragment) {
+      refs.add(ref);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && "properties" in schema) {
+    const properties = schema.properties;
+    for (const key in properties) {
+      collectRefsFromValue(properties[key]);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && "additionalProperties" in schema) {
+    collectRefsFromValue(schema.additionalProperties);
+  }
+  if (typeof schema === "object" && schema !== null && "patternProperties" in schema) {
+    const patternProps = schema.patternProperties;
+    for (const key in patternProps) {
+      collectRefsFromValue(patternProps[key]);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && hasItems(schema)) {
+    collectRefsFromValue(schema.items);
+  }
+  if (typeof schema === "object" && schema !== null && hasOneOf(schema)) {
+    for (const item of schema.oneOf) {
+      collectRefsFromValue(item);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && hasAnyOf(schema)) {
+    for (const item of schema.anyOf) {
+      collectRefsFromValue(item);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && hasAllOf(schema)) {
+    for (const item of schema.allOf) {
+      collectRefsFromValue(item);
+    }
+  }
+  if (typeof schema === "object" && schema !== null && "if" in schema) {
+    collectRefsFromValue(schema.if);
+  }
+  if (typeof schema === "object" && schema !== null && "then" in schema) {
+    collectRefsFromValue(schema.then);
+  }
+  if (typeof schema === "object" && schema !== null && "else" in schema) {
+    collectRefsFromValue(schema.else);
+  }
+  const targets = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    if (rootSchema !== void 0 && (ref.startsWith("http://") || ref.startsWith("https://"))) {
+      if (!resolveRef(ref, rootSchema))
+        continue;
+    }
+    const typeName = refToName(ref, typeSuffix);
+    const filename = refToFilename(ref);
+    if (selfFilename !== void 0 && filename === selfFilename) {
+      continue;
+    }
+    targets.set(filename, typeName);
+  }
+  return targets;
+};
+export {
+  collectImportTypeNames,
+  collectImports
 };

package/dist/helpers/find-discriminator.js

@@ -1,33 +1,27 @@
-import { hasConst, hasEnum, hasProperties, isObjectSchema, isSchemaObject } from '@amritk/helpers/schema-guards';
-/**
- * Attempts to find a discriminator property that can be used to distinguish between union types.
- * Returns the property name if a suitable discriminator is found, otherwise null.
- */
-export const findDiscriminator = (schemas) => {
-    // Look for a property that has different constant/enum values in each schema
-    const propertyValues = new Map();
-    for (const schema of schemas) {
-        if (isObjectSchema(schema) && hasProperties(schema)) {
-            for (const [key, propSchema] of Object.entries(schema.properties)) {
-                if (!propertyValues.has(key)) {
-                    propertyValues.set(key, new Set());
-                }
-                // Check if property has a const value
-                if (isSchemaObject(propSchema) && hasConst(propSchema)) {
-                    propertyValues.get(key)?.add(propSchema.const);
-                }
-                // Check if property has a single enum value
-                else if (isSchemaObject(propSchema) && hasEnum(propSchema) && propSchema.enum.length === 1) {
-                    propertyValues.get(key)?.add(propSchema.enum[0]);
-                }
-            }
+import { hasConst, hasEnum, hasProperties, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
+const findDiscriminator = (schemas) => {
+  const propertyValues = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    if (isObjectSchema(schema) && hasProperties(schema)) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (!propertyValues.has(key)) {
+          propertyValues.set(key, /* @__PURE__ */ new Set());
         }
-    }
-    // Find a property where each schema has a unique value
-    for (const [key, values] of propertyValues.entries()) {
-        if (values.size === schemas.length) {
-            return key;
+        if (isSchemaObject(propSchema) && hasConst(propSchema)) {
+          propertyValues.get(key)?.add(propSchema.const);
+        } else if (isSchemaObject(propSchema) && hasEnum(propSchema) && propSchema.enum.length === 1) {
+          propertyValues.get(key)?.add(propSchema.enum[0]);
         }
+      }
+    }
+  }
+  for (const [key, values] of propertyValues.entries()) {
+    if (values.size === schemas.length) {
+      return key;
     }
-    return null;
+  }
+  return null;
+};
+export {
+  findDiscriminator
 };