@amritk/generate-parsers 0.23.0 → 0.25.0

package/dist/generators/unevaluated-match.js

@@ -1,206 +0,0 @@
-import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
-import { resolveRef } from "@amritk/helpers/resolve-ref";
-import { isSchemaObject } from "@amritk/helpers/schema-guards";
-const NONE = { all: false, terms: [] };
-const orJoin = (terms) => terms.length === 1 ? terms[0] : `(${terms.join(" || ")})`;
-const depthOf = (ctx) => ctx.depth ?? 0;
-const nest = (ctx) => ({ ...ctx, depth: depthOf(ctx) + 1 });
-const conditioned = (coverage, cond) => {
-  if (coverage.all)
-    return { all: false, terms: [cond] };
-  if (coverage.terms.length === 0)
-    return NONE;
-  return { all: false, terms: [`(${cond} && ${orJoin(coverage.terms)})`] };
-};
-const merge = (into, from) => into.all || from.all ? { all: true, terms: [] } : { all: false, terms: [...into.terms, ...from.terms] };
-const ownPropertyCoverage = (schema, keyVar, ignoreOwnUnevaluated) => {
-  if ("additionalProperties" in schema)
-    return { all: true, terms: [] };
-  if (!ignoreOwnUnevaluated && "unevaluatedProperties" in schema && schema["unevaluatedProperties"] !== false) {
-    return { all: true, terms: [] };
-  }
-  const terms = [];
-  const properties = schema["properties"];
-  if (typeof properties === "object" && properties !== null && !Array.isArray(properties)) {
-    const keys = Object.keys(properties);
-    if (keys.length > 0)
-      terms.push(`${JSON.stringify(keys)}.includes(${keyVar})`);
-  }
-  const patterns = schema["patternProperties"];
-  if (typeof patterns === "object" && patterns !== null && !Array.isArray(patterns)) {
-    for (const pattern of Object.keys(patterns)) {
-      terms.push(`${regexLiteral(pattern)}.test(${keyVar})`);
-    }
-  }
-  return { all: false, terms };
-};
-const ownItemCoverage = (schema, indexVar, ignoreOwnUnevaluated) => {
-  const tupleItems = Array.isArray(schema["items"]);
-  if (!tupleItems && "items" in schema)
-    return { all: true, terms: [] };
-  if (tupleItems && "additionalItems" in schema)
-    return { all: true, terms: [] };
-  if (!ignoreOwnUnevaluated && "unevaluatedItems" in schema && schema["unevaluatedItems"] !== false) {
-    return { all: true, terms: [] };
-  }
-  const terms = [];
-  const prefix = Array.isArray(schema["prefixItems"]) ? schema["prefixItems"] : tupleItems ? schema["items"] : null;
-  if (prefix && prefix.length > 0)
-    terms.push(`${indexVar} < ${prefix.length}`);
-  return { all: false, terms };
-};
-const containsCoverage = (schema, indexVar, acc, ctx, match) => {
-  if (!("contains" in schema))
-    return NONE;
-  const itemMatch = match(`(${acc} as any[])[${indexVar}]`, schema["contains"], nest(ctx));
-  if (itemMatch === null)
-    return null;
-  if (itemMatch === "true")
-    return { all: true, terms: [] };
-  return { all: false, terms: [itemMatch] };
-};
-const coverageOf = (kind, schema, varName, acc, ctx, match, ignoreOwnUnevaluated = false) => {
-  if (typeof schema === "boolean")
-    return NONE;
-  if (!isSchemaObject(schema))
-    return null;
-  if (depthOf(ctx) > 8)
-    return null;
-  const s = schema;
-  let coverage = kind === "properties" ? ownPropertyCoverage(s, varName, ignoreOwnUnevaluated) : ownItemCoverage(s, varName, ignoreOwnUnevaluated);
-  if (kind === "items") {
-    const contains = containsCoverage(s, varName, acc, ctx, match);
-    if (contains === null)
-      return null;
-    coverage = merge(coverage, contains);
-  }
-  const ref = s["$ref"];
-  if (typeof ref === "string") {
-    if (ctx.rootSchema === void 0 || ctx.seen?.has(ref))
-      return null;
-    const target = resolveRef(ref, ctx.rootSchema);
-    if (target === void 0)
-      return null;
-    const seen = new Set(ctx.seen ?? []);
-    seen.add(ref);
-    const refCoverage = coverageOf(kind, target, varName, acc, { ...nest(ctx), seen }, match);
-    if (refCoverage === null)
-      return null;
-    coverage = merge(coverage, refCoverage);
-  }
-  if (Array.isArray(s["allOf"])) {
-    for (const member of s["allOf"]) {
-      const memberCoverage = coverageOf(kind, member, varName, acc, nest(ctx), match);
-      if (memberCoverage === null)
-        return null;
-      coverage = merge(coverage, memberCoverage);
-    }
-  }
-  for (const keyword of ["anyOf", "oneOf"]) {
-    if (!Array.isArray(s[keyword]))
-      continue;
-    for (const branch of s[keyword]) {
-      const branchCoverage = coverageOf(kind, branch, varName, acc, nest(ctx), match);
-      if (branchCoverage === null)
-        return null;
-      if (branchCoverage.all === false && branchCoverage.terms.length === 0)
-        continue;
-      const branchMatch = match(acc, branch, nest(ctx));
-      if (branchMatch === null)
-        return null;
-      coverage = merge(coverage, conditioned(branchCoverage, branchMatch));
-    }
-  }
-  if ("if" in s) {
-    const ifMatch = match(acc, s["if"], nest(ctx));
-    if (ifMatch === null)
-      return null;
-    for (const [keyword, cond] of [
-      ["if", ifMatch],
-      ["then", ifMatch],
-      ["else", `!(${ifMatch})`]
-    ]) {
-      if (!(keyword in s))
-        continue;
-      const branchCoverage = coverageOf(kind, s[keyword], varName, acc, nest(ctx), match);
-      if (branchCoverage === null)
-        return null;
-      coverage = merge(coverage, conditioned(branchCoverage, cond));
-    }
-  }
-  const dependentSchemas = s["dependentSchemas"];
-  if (typeof dependentSchemas === "object" && dependentSchemas !== null && !Array.isArray(dependentSchemas)) {
-    for (const [trigger, sub] of Object.entries(dependentSchemas)) {
-      const subCoverage = coverageOf(kind, sub, varName, acc, nest(ctx), match);
-      if (subCoverage === null)
-        return null;
-      coverage = merge(coverage, conditioned(subCoverage, `${JSON.stringify(trigger)} in (${acc} as object)`));
-    }
-  }
-  return coverage;
-};
-const unevaluatedPropertiesExpr = (acc, schema, ctx, match) => {
-  if (!isSchemaObject(schema))
-    return void 0;
-  const s = schema;
-  if (!("unevaluatedProperties" in s))
-    return void 0;
-  const unevaluated = s["unevaluatedProperties"];
-  if (unevaluated === true)
-    return void 0;
-  const d = depthOf(ctx);
-  const keyVar = `_uk${d}`;
-  const coverage = coverageOf("properties", schema, keyVar, acc, ctx, match, true);
-  if (coverage === null)
-    return null;
-  if (coverage.all)
-    return void 0;
-  const rec = `(${acc} as Record<string, unknown>)`;
-  const covered = coverage.terms.length > 0 ? orJoin(coverage.terms) : null;
-  if (unevaluated === false) {
-    if (covered === null)
-      return `Object.keys(${rec}).length === 0`;
-    return `Object.keys(${rec}).every((${keyVar}) => ${covered})`;
-  }
-  const valueMatch = match(`${rec}[${keyVar}]`, unevaluated, nest(ctx));
-  if (valueMatch === null)
-    return null;
-  if (valueMatch === "true")
-    return void 0;
-  return covered === null ? `Object.keys(${rec}).every((${keyVar}) => ${valueMatch})` : `Object.keys(${rec}).every((${keyVar}) => ${covered} || ${valueMatch})`;
-};
-const unevaluatedItemsExpr = (acc, schema, ctx, match) => {
-  if (!isSchemaObject(schema))
-    return void 0;
-  const s = schema;
-  if (!("unevaluatedItems" in s))
-    return void 0;
-  const unevaluated = s["unevaluatedItems"];
-  if (unevaluated === true)
-    return void 0;
-  const d = depthOf(ctx);
-  const indexVar = `_un${d}`;
-  const itemVar = `_ue${d}`;
-  const coverage = coverageOf("items", schema, indexVar, acc, ctx, match, true);
-  if (coverage === null)
-    return null;
-  if (coverage.all)
-    return void 0;
-  const elements = `(${acc} as any[])`;
-  const covered = coverage.terms.length > 0 ? orJoin(coverage.terms) : null;
-  if (unevaluated === false) {
-    if (covered === null)
-      return `${acc}.length === 0`;
-    return `${elements}.every((_, ${indexVar}) => ${covered})`;
-  }
-  const valueMatch = match(itemVar, unevaluated, nest(ctx));
-  if (valueMatch === null)
-    return null;
-  if (valueMatch === "true")
-    return void 0;
-  return covered === null ? `${elements}.every((${itemVar}) => ${valueMatch})` : `${elements}.every((${itemVar}, ${indexVar}) => ${covered} || ${valueMatch})`;
-};
-export {
-  unevaluatedItemsExpr,
-  unevaluatedPropertiesExpr
-};

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

@@ -1,35 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-import type { SchemaExtensions } from '../types/schema-extensions.js';
-/**
- * Merges custom extension properties into a schema's properties based on the
- * definition name. Extension properties are added as optional (not included
- * in the required array) since they are custom additions that may not always
- * be present.
- *
- * If the schema is not an object, has no matching extensions, or the
- * extensions record is empty, the original schema is returned unchanged.
- *
- * @param schema - The JSON Schema to extend
- * @param definitionName - The name of the definition (e.g., "parameter")
- * @param extensions - The extensions configuration mapping definition names to properties
- * @returns A new schema with extension properties merged in, or the original if unchanged
- *
- * @example
- * ```typescript
- * const schema = {
- *   type: 'object',
- *   properties: { name: { type: 'string' } },
- *   required: ['name'],
- * }
- *
- * const extensions = {
- *   parameter: {
- *     'x-enabled': { type: 'boolean' },
- *   },
- * }
- *
- * const extended = applySchemaExtensions(schema, 'parameter', extensions)
- * // extended.properties now includes 'x-enabled' alongside 'name'
- * ```
- */
-export declare const applySchemaExtensions: (schema: JSONSchema, definitionName: string, extensions: SchemaExtensions) => JSONSchema;

package/dist/helpers/apply-schema-extensions.js

@@ -1,20 +0,0 @@
-const applySchemaExtensions = (schema, definitionName, extensions) => {
-  const extensionProperties = extensions[definitionName];
-  if (!extensionProperties || Object.keys(extensionProperties).length === 0) {
-    return schema;
-  }
-  if (typeof schema !== "object" || schema === null) {
-    return schema;
-  }
-  const existingProperties = "properties" in schema && typeof schema.properties === "object" && schema.properties !== null ? schema.properties : {};
-  return {
-    ...schema,
-    properties: {
-      ...existingProperties,
-      ...extensionProperties
-    }
-  };
-};
-export {
-  applySchemaExtensions
-};

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

@@ -1,15 +0,0 @@
-/** Names (without `.ts`) of runtime helpers that can be embedded into generated output. */
-export type RuntimeHelperName = 'is-object' | 'validate-array' | 'validate-record' | 'has-ref';
-/** Controls how generated parsers reference their runtime helpers. */
-export type HelpersMode = 'package' | 'embedded';
-export type CollectedHelpers = {
-    /** Import lines to splice into the generated file. */
-    readonly imports: string[];
-    /**
-     * Helper names that need to ship alongside the generated file in embedded mode.
-     * Includes transitive deps (e.g. `validate-record` pulls in `is-object`) so the
-     * orchestrator can emit a complete `_helpers/` directory.
-     */
-    readonly used: Set<RuntimeHelperName>;
-};
-export declare const collectHelpers: (parserFunction: string, mode: HelpersMode, helpersImportPrefix?: string, importExt?: 'js' | 'ts') => CollectedHelpers;

package/dist/helpers/collect-helpers.js

@@ -1,64 +0,0 @@
-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';"
-};
-const EMBEDDED_NAMED_EXPORTS = {
-  "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}';`
-);
-const HELPER_USAGE = /validateArray|validateRecord|isObject|hasRef\(/g;
-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.d.ts

@@ -1,93 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-/** Extension emitted on every relative import specifier in generated code. */
-export type ImportExtension = 'js' | 'ts';
-/**
- * Options for controlling how imports are collected.
- */
-type CollectImportsOptions = {
-    /**
-     * When true, only generate type-only imports (no parser function imports).
-     * Use this when generating types-only files that do not include parser functions.
-     */
-    readonly typesOnly?: boolean;
-    /**
-     * The $ref path of the schema being generated (e.g. `#/$defs/encoding`).
-     * When provided, any $ref that resolves to the same filename is excluded from
-     * the import list, preventing a file from importing itself.
-     */
-    readonly selfRef?: string | undefined;
-    /**
-     * The filename this file is being written as, without extension. Takes
-     * precedence over `selfRef` for self-import detection, and covers the case
-     * `selfRef` cannot: the root document has no ref of its own, so a definition
-     * whose name collides with the root type name (root `Contact` + `$defs.contact`)
-     * used to make the root file import its own type from itself.
-     */
-    readonly selfFilename?: string | undefined;
-    /**
-     * The root schema document. When provided, URI refs that cannot be resolved
-     * within the root schema's $defs are excluded from the import list, preventing
-     * imports for external schemas that were never generated as files.
-     */
-    readonly rootSchema?: Record<string, unknown> | undefined;
-    /**
-     * Suffix appended to every type name derived from a `$ref`. Must match the
-     * suffix used when generating the referenced files so imports resolve.
-     * Defaults to `''` (no suffix).
-     */
-    readonly typeSuffix?: string;
-    /**
-     * Extension used on every relative import specifier. Defaults to `'js'`
-     * (the TS NodeNext form); `'ts'` makes the output runnable under Node's
-     * type stripping.
-     */
-    readonly importExt?: ImportExtension;
-};
-/**
- * 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 declare const collectImports: (schema: JSONSchema, options?: CollectImportsOptions) => string[];
-/**
- * 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 declare const collectImportTypeNames: (schema: JSONSchema, options?: CollectImportsOptions) => Set<string>;
-export {};

package/dist/helpers/collect-imports.js

@@ -1,197 +0,0 @@
-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}`;
-const collectImports = (schema, options) => {
-  const typesOnly = options?.typesOnly === true;
-  const importExt = options?.importExt ?? "js";
-  const importMap = /* @__PURE__ */ new Map();
-  for (const [filename, { typeName, typeOnly }] of collectImportTargets(schema, options)) {
-    const importPath = getImportPathForFilename(filename, importExt);
-    const importStatement = typesOnly || typeOnly ? `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 collectImportTypeNames = (schema, options) => {
-  const names = /* @__PURE__ */ new Set();
-  for (const [, target] of collectImportTargets(schema, options))
-    names.add(target.typeName);
-  return names;
-};
-const collectImportTargets = (schema, options) => {
-  const selfFilename = options?.selfFilename ?? (options?.selfRef ? refToFilename(options.selfRef) : void 0);
-  const rootSchema = options?.rootSchema;
-  const typeSuffix = options?.typeSuffix;
-  const refs = /* @__PURE__ */ new Set();
-  const valueRefs = /* @__PURE__ */ new Set();
-  let typeOnlyDepth = 0;
-  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);
-        if (typeOnlyDepth === 0)
-          valueRefs.add(ref);
-      }
-      return;
-    }
-    for (const keyword of ["prefixItems", "items"]) {
-      const positions = Object.hasOwn(record, keyword) ? record[keyword] : void 0;
-      if (!Array.isArray(positions))
-        continue;
-      typeOnlyDepth++;
-      for (const item of positions) {
-        collectRefsFromValue(item);
-      }
-      if (Object.hasOwn(record, "additionalItems"))
-        collectRefsFromValue(record["additionalItems"]);
-      typeOnlyDepth--;
-    }
-    if (hasAdditionalProperties(record) && hasRef(record.additionalProperties)) {
-      collectRefsFromValue(record.additionalProperties);
-      return;
-    }
-    if (record.type === "array" && hasItems(record) && !Array.isArray(record.items) && hasRef(record.items)) {
-      collectRefsFromValue(record.items);
-      return;
-    }
-    if (Object.hasOwn(record, "properties") && typeof record.properties === "object" && record.properties !== null) {
-      for (const value2 of Object.values(record.properties)) {
-        collectRefsFromValue(value2);
-      }
-    }
-    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) && !Array.isArray(record.items)) {
-      collectRefsFromValue(record.items);
-    }
-    if (hasAdditionalProperties(record)) {
-      collectRefsFromValue(record.additionalProperties);
-    }
-    if (Object.hasOwn(record, "patternProperties") && typeof record.patternProperties === "object" && record.patternProperties !== null) {
-      for (const value2 of Object.values(record.patternProperties)) {
-        collectRefsFromValue(value2);
-      }
-    }
-    if (Object.hasOwn(record, "if")) {
-      collectRefsFromValue(record.if);
-    }
-    if (Object.hasOwn(record, "then")) {
-      collectRefsFromValue(record.then);
-    }
-    if (Object.hasOwn(record, "else")) {
-      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);
-      valueRefs.add(ref);
-    }
-  }
-  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "properties") && typeof schema.properties === "object" && schema.properties !== null) {
-    for (const value of Object.values(schema.properties)) {
-      collectRefsFromValue(value);
-    }
-  }
-  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "additionalProperties")) {
-    collectRefsFromValue(schema.additionalProperties);
-  }
-  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "patternProperties") && typeof schema.patternProperties === "object" && schema.patternProperties !== null) {
-    for (const value of Object.values(schema.patternProperties)) {
-      collectRefsFromValue(value);
-    }
-  }
-  if (typeof schema === "object" && schema !== null && hasItems(schema) && !Array.isArray(schema.items)) {
-    collectRefsFromValue(schema.items);
-  }
-  if (typeof schema === "object" && schema !== null) {
-    const record = schema;
-    for (const keyword of ["prefixItems", "items"]) {
-      const positions = Object.hasOwn(record, keyword) ? record[keyword] : void 0;
-      if (!Array.isArray(positions))
-        continue;
-      typeOnlyDepth++;
-      for (const item of positions)
-        collectRefsFromValue(item);
-      if (Object.hasOwn(record, "additionalItems"))
-        collectRefsFromValue(record["additionalItems"]);
-      typeOnlyDepth--;
-    }
-  }
-  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 && Object.hasOwn(schema, "if")) {
-    collectRefsFromValue(schema.if);
-  }
-  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "then")) {
-    collectRefsFromValue(schema.then);
-  }
-  if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "else")) {
-    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;
-    }
-    const typeOnly = !valueRefs.has(ref) && (targets.get(filename)?.typeOnly ?? true);
-    targets.set(filename, { typeName, typeOnly });
-  }
-  return targets;
-};
-export {
-  collectImportTypeNames,
-  collectImports
-};

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

@@ -1,6 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-/**
- * 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 declare const findDiscriminator: (schemas: readonly JSONSchema[]) => string | null;

package/dist/helpers/find-discriminator.js

@@ -1,27 +0,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());
-        }
-        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;
-};
-export {
-  findDiscriminator
-};

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

@@ -1,7 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-/**
- * Returns the default value for a JSON Schema property.
- * Priority order: explicit default > first enum value > first example > union first schema > pattern-based > type-based.
- * These defaults ensure that parsing never fails, even with missing data.
- */
-export declare const getDefaultValue: (schema: JSONSchema) => string;