@amritk/generate-parsers 0.24.0 → 0.25.0

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

@@ -1,79 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-/**
- * A boolean type check for an array element whose schema is a single scalar type
- * (the cases the element coercion below can handle). `integer` is treated as
- * `number` because the generated TS element type is `number`. Returns `null` for
- * objects, arrays, unions, `$ref`s, and anything richer.
- */
-export declare const scalarItemTypeCheck: (itemSchema: JSONSchema, accessor: string) => string | null;
-/**
- * {@link scalarItemTypeCheck}, but only for an item schema whose `type` is the
- * *whole* constraint — the one case where the bare `typeof` test is an exact
- * match rather than a weakening of it. Emit sites that need a check they can
- * trust in both directions (a true-sound fast-path guard, a strict assertion
- * that throws) take this one; the coercion path keeps the looser
- * {@link isCoercibleItemSchema}, which coerces each element through the full
- * per-element expression and so applies the constraints anyway.
- */
-export declare const plainScalarItemCheck: (itemSchema: JSONSchema, accessor: string) => string | null;
-/**
- * True when an array's `items` schema can be coerced element-by-element by the
- * mapping slow path: single scalar types (via {@link scalarItemTypeCheck}) and
- * enums (whose validation expression coerces a non-member to the first member).
- * Anything richer (objects, unions, `$ref`s) needs a real item parser instead.
- */
-export declare const isCoercibleItemSchema: (itemSchema: JSONSchema) => boolean;
-/**
- * The tuple positions a schema declares, else `null`. `prefixItems` (JSON
- * Schema 2020-12) positions each element against its own subschema; draft-07
- * spelled the same construct as an array-valued `items`, which every other item
- * path skips (they all read `items` as a single schema), so it is normalized
- * here rather than left unchecked.
- */
-export declare const getPrefixItems: (schema: JSONSchema) => readonly JSONSchema[] | null;
-/**
- * Wraps a per-element boolean check into the `.every(...)` call that proves it
- * for a whole array, skipping the positions `prefixItems` already owns.
- *
- * In 2020-12 `items` is only the *tail* schema: it applies from
- * `prefixItems.length` onward. Checking every element against it made
- * `{ prefixItems: [{type:'string'}], items: {type:'number'} }` reject
- * `["a", 1, 2]` — a value Ajv accepts, and one the `[string?, ...number[]]` type
- * this generator emits admits, so the strict parser threw on its own declared
- * type. The index guard is short-circuited rather than sliced so the check stays
- * allocation-free on the hot path.
- *
- * The draft-07 tuple spelling needs no guard: there `items` *is* the tuple and
- * the tail lives in `additionalItems`, which no item check reads.
- */
-export declare const everyTailItem: (accessor: string, itemCheck: string, schema: JSONSchema) => string;
-/**
- * True when a sibling `items: false` (2020-12) or `additionalItems: false`
- * (draft) caps a tuple's length — any element past the declared prefix is
- * disallowed, so the coercer drops it and strict mode rejects it.
- */
-export declare const prefixItemsCapsLength: (schema: JSONSchema) => boolean;
-/**
- * A boolean type check for a single JSON Schema primitive type name. Unlike
- * {@link scalarItemTypeCheck} this also covers `array`/`object` (as inline shape
- * checks, so no `isObject` import is assumed) and enforces `integer` with
- * `Number.isInteger` — a bare `typeof === "number"` accepts `1.5`. Used to build
- * the disjunction for an array-form `type` (e.g. `["string","null"]`).
- */
-export declare const singleTypeCheck: (accessor: string, type: string) => string | null;
-/**
- * Generates a validation expression that checks if a value matches the expected type.
- * Returns the value if valid, coerces to the correct type if invalid, or uses default if required and missing.
- * 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, caseInsensitive?: boolean) => string;
-/**
- * Builds the coercion transform for a tuple `prefixItems` array: an index-matched
- * `.map` where each declared position runs through its own subschema's coercion
- * (present positions only — a shorter input keeps its absent trailing positions),
- * and every element past the tuple passes through unchanged. When `capLength` is
- * set (a sibling `items: false`), a trailing `.slice(0, N)` drops those extras.
- * `accessor` must already be known to be an array (the caller guards with
- * `Array.isArray`). `$ref` positions resolve against `rootSchema` when provided.
- */
-export declare const generatePrefixItemsMap: (accessor: string, prefix: readonly JSONSchema[], capLength: boolean, rootSchema?: Record<string, unknown>, visitedRefs?: Set<string>, caseInsensitive?: boolean) => string;

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

@@ -1,416 +0,0 @@
-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 { resolveRef } from "@amritk/helpers/resolve-ref";
-import { hasOwnCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
-import { maxLengthPassExpr, minLengthPassExpr } from "@amritk/helpers/string-length-check";
-import { findDiscriminator } from "../helpers/find-discriminator.js";
-import { getDefaultValue } from "../helpers/get-default-value.js";
-import { generateDiscriminatedUnionValidation } from "./generate-discriminated-union-validation.js";
-import { generateEnumCaseInsensitiveCoercion, generateEnumCheck } from "./generate-enum-check.js";
-import { generateNonDiscriminatedUnionValidation } from "./generate-non-discriminated-union-validation.js";
-import { generateSchemaChecks } from "./generate-schema-checks.js";
-import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
-const getInstanceCoercion = (accessor, instanceOf, defaultValue) => {
-  if (instanceOf === "Date")
-    return `((_d) => Number.isNaN(_d.getTime()) ? ${defaultValue} : _d)(new Date(${accessor} as string | number | Date))`;
-  return null;
-};
-const scalarItemTypeCheck = (itemSchema, accessor) => {
-  if (!isSchemaObject(itemSchema) || !hasType(itemSchema) || hasEnum(itemSchema))
-    return null;
-  switch (itemSchema.type) {
-    case "string":
-      return `typeof ${accessor} === "string"`;
-    case "number":
-      return `typeof ${accessor} === "number"`;
-    case "integer":
-      return `typeof ${accessor} === "number" && Number.isInteger(${accessor})`;
-    case "boolean":
-      return `typeof ${accessor} === "boolean"`;
-    case "null":
-      return `${accessor} === null`;
-    default:
-      return null;
-  }
-};
-const SCALAR_ITEM_CONSTRAINTS = [
-  "pattern",
-  "minLength",
-  "maxLength",
-  "minimum",
-  "maximum",
-  "exclusiveMinimum",
-  "exclusiveMaximum",
-  "multipleOf",
-  "const",
-  "$ref",
-  "not",
-  "allOf",
-  "anyOf",
-  "oneOf",
-  "if"
-];
-const plainScalarItemCheck = (itemSchema, accessor) => {
-  if (!isSchemaObject(itemSchema))
-    return null;
-  const record = itemSchema;
-  if (SCALAR_ITEM_CONSTRAINTS.some((keyword) => keyword in record))
-    return null;
-  return scalarItemTypeCheck(itemSchema, accessor);
-};
-const isCoercibleItemSchema = (itemSchema) => {
-  if (scalarItemTypeCheck(itemSchema, "_it") !== null)
-    return true;
-  if (!isSchemaObject(itemSchema))
-    return false;
-  const itemTypes = itemSchema["type"];
-  if (Array.isArray(itemTypes) && itemTypes.length > 0) {
-    return itemTypes.every((type) => typeof type === "string" && scalarItemTypeCheck({ type }, "_it") !== null);
-  }
-  if (hasConst(itemSchema))
-    return true;
-  return hasEnum(itemSchema) && itemSchema.enum.length > 0;
-};
-const getPrefixItems = (schema) => {
-  if (!isSchemaObject(schema))
-    return null;
-  const prefix = schema["prefixItems"];
-  if (Array.isArray(prefix))
-    return prefix;
-  return Array.isArray(schema.items) ? schema.items : null;
-};
-const everyTailItem = (accessor, itemCheck, schema) => {
-  const prefix = isSchemaObject(schema) ? schema["prefixItems"] : void 0;
-  const tailStart = Array.isArray(prefix) ? prefix.length : 0;
-  return tailStart === 0 ? `${accessor}.every((_it: unknown) => ${itemCheck})` : `${accessor}.every((_it: unknown, _ix: number) => _ix < ${tailStart} || (${itemCheck}))`;
-};
-const prefixItemsCapsLength = (schema) => {
-  if (!isSchemaObject(schema))
-    return false;
-  const s = schema;
-  return (Object.hasOwn(s, "items") ? s["items"] : void 0) === false || (Object.hasOwn(s, "additionalItems") ? s["additionalItems"] : void 0) === false;
-};
-const singleTypeCheck = (accessor, type) => {
-  switch (type) {
-    case "string":
-      return `typeof ${accessor} === "string"`;
-    case "number":
-      return `typeof ${accessor} === "number"`;
-    case "integer":
-      return `typeof ${accessor} === "number" && Number.isInteger(${accessor})`;
-    case "boolean":
-      return `typeof ${accessor} === "boolean"`;
-    case "null":
-      return `${accessor} === null`;
-    case "array":
-      return `Array.isArray(${accessor})`;
-    case "object":
-      return `typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`;
-    default:
-      return null;
-  }
-};
-const getTypeArray = (schema) => {
-  if (!isSchemaObject(schema) || !("type" in schema) || !Array.isArray(schema.type))
-    return null;
-  return schema.type;
-};
-const stringBoundChecks = (valueExpr, schema) => {
-  const checks = [];
-  if (hasPattern(schema))
-    checks.push(`${regexLiteral(schema.pattern)}.test(${valueExpr})`);
-  if (hasMinLength(schema))
-    checks.push(minLengthPassExpr(valueExpr, schema.minLength));
-  if (hasMaxLength(schema))
-    checks.push(maxLengthPassExpr(valueExpr, schema.maxLength));
-  return checks;
-};
-const numberBoundChecks = (valueExpr, schema) => {
-  const checks = [];
-  if (hasMinimum(schema))
-    checks.push(`${valueExpr} >= ${schema.minimum}`);
-  if (hasMaximum(schema))
-    checks.push(`${valueExpr} <= ${schema.maximum}`);
-  if (hasExclusiveMinimum(schema))
-    checks.push(`${valueExpr} > ${schema.exclusiveMinimum}`);
-  if (hasExclusiveMaximum(schema))
-    checks.push(`${valueExpr} < ${schema.exclusiveMaximum}`);
-  if (hasMultipleOf(schema))
-    checks.push(multipleOfPassExpr(valueExpr, schema.multipleOf));
-  return checks;
-};
-const BOOLEAN_TRUE_TOKENS = ["true", "yes", "y", "on", "1"];
-const BOOLEAN_FALSE_TOKENS = ["false", "no", "n", "off", "0", ""];
-const getBooleanCoercion = (accessor, defaultValue) => {
-  const side = (tokens, literals) => [...tokens.map((token) => `"${token}"`), ...literals].map((term) => `_b === ${term}`).join(" || ");
-  const normalized = `typeof ${accessor} === "string" ? ${accessor}.trim().toLowerCase() : ${accessor}`;
-  const truthy = side(BOOLEAN_TRUE_TOKENS, ["1", "true"]);
-  const falsy = side(BOOLEAN_FALSE_TOKENS, ["0", "false"]);
-  return `((_b) => ${truthy} ? true : ${falsy} ? false : ${defaultValue})(${normalized})`;
-};
-const getTypeCoercion = (accessor, schema, defaultValue) => {
-  if (!hasType(schema)) {
-    return null;
-  }
-  switch (schema.type) {
-    case "string": {
-      const coerced = `String(${accessor})`;
-      const bounds = stringBoundChecks("_s", schema);
-      if (bounds.length === 0)
-        return coerced;
-      return `((_s) => ${bounds.join(" && ")} ? _s : ${defaultValue})(${coerced})`;
-    }
-    case "number":
-    case "integer": {
-      const wellFormed = schema.type === "integer" ? "Number.isInteger" : "Number.isFinite";
-      const bounds = numberBoundChecks("_n", schema);
-      const n = `Number(${accessor})`;
-      if (bounds.length === 0)
-        return `(${wellFormed}(${n}) ? ${n} : ${defaultValue})`;
-      return `((_n) => ${[`${wellFormed}(_n)`, ...bounds].join(" && ")} ? _n : ${defaultValue})(${n})`;
-    }
-    case "boolean":
-      return getBooleanCoercion(accessor, defaultValue);
-    case "array":
-      return defaultValue;
-    case "object":
-      return `typeof ${accessor} === "object" && ${accessor} !== null ? ${accessor} : ${defaultValue}`;
-    default:
-      return null;
-  }
-};
-const generateValidationExpression = (key, schema, defaultValue, isRequired, rootSchema, visitedRefs, accessorOverride, knownNotUndefined, caseInsensitive) => {
-  const accessor = accessorOverride ?? safeAccessor("input?", key);
-  const checks = [];
-  if (!isSchemaObject(schema)) {
-    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
-  }
-  const instanceOf = getMjstInstanceOf(schema);
-  if (instanceOf) {
-    const valid = `${accessor} instanceof ${instanceOf}`;
-    if (isRequired) {
-      const coercion2 = getInstanceCoercion(accessor, instanceOf, defaultValue);
-      return coercion2 ? `${valid} ? ${accessor} : (${accessor} !== undefined ? ${coercion2} : ${defaultValue})` : `${valid} ? ${accessor} : ${defaultValue}`;
-    }
-    const coercion = getInstanceCoercion(accessor, instanceOf, "undefined");
-    return coercion ? `${valid} ? ${accessor} : (${accessor} !== undefined ? ${coercion} : undefined)` : `${valid} ? ${accessor} : undefined`;
-  }
-  const primitive = getMjstPrimitive(schema);
-  if (primitive) {
-    const valid = `typeof ${accessor} === "${primitive}"`;
-    return isRequired ? `${valid} ? ${accessor} : ${defaultValue}` : `${valid} ? ${accessor} : undefined`;
-  }
-  if (hasRef(schema) && rootSchema) {
-    const ref = schema.$ref;
-    if (visitedRefs?.has(ref)) {
-      return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
-    }
-    const resolvedSchema = resolveRef(ref, rootSchema);
-    if (resolvedSchema) {
-      const visited = new Set(visitedRefs);
-      visited.add(ref);
-      return generateValidationExpression(key, resolvedSchema, defaultValue, isRequired, rootSchema, visited, void 0, void 0, caseInsensitive);
-    }
-  }
-  if (hasOneOf(schema) && schema.oneOf.length > 0) {
-    const discriminator = findDiscriminator(schema.oneOf);
-    if (discriminator) {
-      return generateDiscriminatedUnionValidation(accessor, schema.oneOf, discriminator, defaultValue, isRequired);
-    }
-    return generateNonDiscriminatedUnionValidation(accessor, schema.oneOf, defaultValue, isRequired);
-  }
-  if (hasAnyOf(schema) && schema.anyOf.length > 0) {
-    const discriminator = findDiscriminator(schema.anyOf);
-    if (discriminator) {
-      return generateDiscriminatedUnionValidation(accessor, schema.anyOf, discriminator, defaultValue, isRequired);
-    }
-    return generateNonDiscriminatedUnionValidation(accessor, schema.anyOf, defaultValue, isRequired);
-  }
-  if (hasAllOf(schema) && schema.allOf.length > 0) {
-    const allChecks = [];
-    for (const subSchema of schema.allOf) {
-      const subChecks = generateSchemaChecks(accessor, subSchema);
-      allChecks.push(...subChecks);
-    }
-    if (allChecks.length > 0) {
-      let combinedCheck2 = allChecks[0];
-      for (let i = 1; i < allChecks.length; i++) {
-        combinedCheck2 += " && " + allChecks[i];
-      }
-      return `${combinedCheck2} ? ${accessor} : ${isRequired ? defaultValue : "undefined"}`;
-    }
-    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
-  }
-  if ("not" in schema && schema.not) {
-    const notChecks = generateSchemaChecks(accessor, schema.not);
-    if (notChecks.length > 0) {
-      let combinedNotCheck = notChecks[0];
-      for (let i = 1; i < notChecks.length; i++) {
-        combinedNotCheck += " && " + notChecks[i];
-      }
-      return `!(${combinedNotCheck}) ? ${accessor} : ${isRequired ? defaultValue : "undefined"}`;
-    }
-  }
-  if (hasConst(schema)) {
-    const constLiteral = JSON.stringify(schema.const);
-    return isRequired ? `${accessor} === ${constLiteral} ? ${accessor} : ${constLiteral}` : `${accessor} === ${constLiteral} ? ${accessor} : (${accessor} !== undefined ? ${constLiteral} : undefined)`;
-  }
-  const typeArray = getTypeArray(schema);
-  if (typeArray && !hasEnum(schema)) {
-    const checks2 = typeArray.map((t) => singleTypeCheck(accessor, t)).filter((c) => c !== null);
-    if (checks2.length > 0) {
-      const combined = checks2.map((c) => `(${c})`).join(" || ");
-      return isRequired ? `${combined} ? ${accessor} : ${defaultValue}` : `${combined} ? ${accessor} : undefined`;
-    }
-  }
-  if (!hasType(schema) && !hasEnum(schema)) {
-    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
-  }
-  const prefixItems = getPrefixItems(schema);
-  if (hasType(schema) && schema.type === "array" && prefixItems) {
-    const mapped = generatePrefixItemsMap(accessor, prefixItems, prefixItemsCapsLength(schema), rootSchema, visitedRefs, caseInsensitive);
-    const built = `(Array.isArray(${accessor}) ? ${mapped} : ${defaultValue})`;
-    return isRequired ? built : `(${accessor} !== undefined ? ${built} : undefined)`;
-  }
-  if (hasType(schema) && schema.type === "array" && hasItems(schema) && !Array.isArray(schema.items) && isCoercibleItemSchema(schema.items)) {
-    const itemSchema = schema.items;
-    const itemExpr = generateValidationExpression("", itemSchema, getDefaultValue(itemSchema), true, rootSchema, visitedRefs, "_it", true, caseInsensitive);
-    const mapped = `(Array.isArray(${accessor}) ? (${accessor} as unknown[]).map((_it) => ${itemExpr}) : ${defaultValue})`;
-    return isRequired ? mapped : `(${accessor} !== undefined ? ${mapped} : undefined)`;
-  }
-  if (hasType(schema)) {
-    switch (schema.type) {
-      case "string": {
-        checks.push(`typeof ${accessor} === "string"`);
-        if (hasPattern(schema)) {
-          checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
-        }
-        if (hasMinLength(schema)) {
-          checks.push(minLengthPassExpr(accessor, schema.minLength));
-        }
-        if (hasMaxLength(schema)) {
-          checks.push(maxLengthPassExpr(accessor, schema.maxLength));
-        }
-        break;
-      }
-      case "number":
-      case "integer": {
-        checks.push(`typeof ${accessor} === "number"`);
-        if (schema.type === "integer") {
-          checks.push(`Number.isInteger(${accessor})`);
-        }
-        if (hasMinimum(schema)) {
-          checks.push(`${accessor} >= ${schema.minimum}`);
-        }
-        if (hasMaximum(schema)) {
-          checks.push(`${accessor} <= ${schema.maximum}`);
-        }
-        if (hasExclusiveMinimum(schema)) {
-          checks.push(`${accessor} > ${schema.exclusiveMinimum}`);
-        }
-        if (hasExclusiveMaximum(schema)) {
-          checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
-        }
-        if (hasMultipleOf(schema)) {
-          checks.push(multipleOfPassExpr(accessor, schema.multipleOf));
-        }
-        break;
-      }
-      case "boolean":
-        checks.push(`typeof ${accessor} === "boolean"`);
-        break;
-      case "null":
-        checks.push(`${accessor} === null`);
-        break;
-      case "array": {
-        checks.push(`Array.isArray(${accessor})`);
-        if (hasMinItems(schema)) {
-          checks.push(`${accessor}.length >= ${schema.minItems}`);
-        }
-        if (hasMaxItems(schema)) {
-          checks.push(`${accessor}.length <= ${schema.maxItems}`);
-        }
-        if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-          checks.push(generateUniqueItemsCheck(accessor, schema));
-        }
-        break;
-      }
-      case "object": {
-        checks.push(`isObject(${accessor})`);
-        if (hasRequired(schema) && schema.required.length > 0) {
-          for (const requiredKey of schema.required) {
-            checks.push(hasOwnCheck(accessor, requiredKey));
-          }
-        }
-        if (hasMinProperties(schema)) {
-          checks.push(`Object.keys(${accessor}).length >= ${schema.minProperties}`);
-        }
-        if (hasMaxProperties(schema)) {
-          checks.push(`Object.keys(${accessor}).length <= ${schema.maxProperties}`);
-        }
-        if (hasAdditionalProperties(schema) && schema.additionalProperties === false && hasProperties(schema)) {
-          const allowedKeys = Object.keys(schema.properties);
-          const allowedKeysStr = JSON.stringify(allowedKeys);
-          checks.push(`Object.keys(${accessor}).every(k => ${allowedKeysStr}.includes(k))`);
-        }
-        break;
-      }
-    }
-  }
-  if (hasEnum(schema) && schema.enum.length > 0) {
-    checks.push(generateEnumCheck(accessor, schema.enum));
-  }
-  if (checks.length === 0) {
-    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
-  }
-  let combinedCheck = checks[0];
-  for (let i = 1; i < checks.length; i++) {
-    combinedCheck += " && " + checks[i];
-  }
-  const typeCoercion = hasEnum(schema) ? null : getTypeCoercion(accessor, schema, defaultValue);
-  const enumFallback = (fallback) => (caseInsensitive && hasEnum(schema) && schema.enum.length > 0 ? generateEnumCaseInsensitiveCoercion(accessor, schema.enum, fallback) : null) ?? fallback;
-  if (isRequired) {
-    if (typeCoercion) {
-      if (knownNotUndefined) {
-        return `${combinedCheck} ? ${accessor} : ${typeCoercion}`;
-      }
-      return `${combinedCheck} ? ${accessor} : (${accessor} !== undefined ? ${typeCoercion} : ${defaultValue})`;
-    }
-    return `${combinedCheck} ? ${accessor} : ${enumFallback(defaultValue)}`;
-  } else {
-    if (typeCoercion) {
-      if (knownNotUndefined) {
-        return `${combinedCheck} ? ${accessor} : ${typeCoercion}`;
-      }
-      return `${combinedCheck} ? ${accessor} : (${accessor} !== undefined ? ${typeCoercion} : undefined)`;
-    }
-    return `${combinedCheck} ? ${accessor} : ${enumFallback("undefined")}`;
-  }
-};
-const generatePrefixItemsMap = (accessor, prefix, capLength, rootSchema, visitedRefs, caseInsensitive) => {
-  const branches = prefix.map((rawPos, i) => {
-    let pos = rawPos;
-    if (isSchemaObject(pos) && hasRef(pos) && rootSchema) {
-      const resolved = resolveRef(pos.$ref, rootSchema);
-      if (resolved)
-        pos = resolved;
-    }
-    const posExpr = generateValidationExpression("", pos, getDefaultValue(pos), true, rootSchema, visitedRefs, "_el", true, caseInsensitive);
-    return `_i === ${i} ? ${posExpr}`;
-  });
-  const mapped = `(${accessor} as unknown[]).map((_el, _i) => ${[...branches, "_el"].join(" : ")})`;
-  return capLength ? `${mapped}.slice(0, ${prefix.length})` : mapped;
-};
-export {
-  everyTailItem,
-  generatePrefixItemsMap,
-  generateValidationExpression,
-  getPrefixItems,
-  isCoercibleItemSchema,
-  plainScalarItemCheck,
-  prefixItemsCapsLength,
-  scalarItemTypeCheck,
-  singleTypeCheck
-};

package/dist/generators/subschema-match.d.ts

@@ -1,48 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-/**
- * What the matcher needs beyond the schema node itself: the root document (to
- * resolve `$ref`), the recursion depth (which seeds collision-free loop variable
- * names and caps expression growth), and the `$ref` pointers already open on this
- * path (a cycle cannot be inlined, so it bails rather than recursing forever).
- */
-export type MatchContext = {
-    readonly rootSchema?: Record<string, unknown>;
-    readonly depth?: number;
-    readonly seen?: ReadonlySet<string>;
-};
-/**
- * Builds a boolean expression that is `true` *exactly* when `accessor` matches
- * `schema` — sound in **both** directions (true ⇒ valid, false ⇒ invalid) — or
- * `null` when the schema uses a form this generator cannot prove inline.
- *
- * This is deliberately self-contained: it never emits a `$ref` shape-validator
- * call (those can be conservative `=> false` stubs, which would break false-
- * soundness) and never touches combinators. That keeps the expression usable
- * both for *counting* matches (`contains`) and for *rejecting* non-matches
- * (`propertyNames`, `dependentSchemas`) in strict mode, where a wrong verdict
- * would silently accept or reject a document. Anything richer returns `null`,
- * and `assertNoUnsupportedKeywords` turns that into a generation-time error.
- *
- * Constraint keywords apply per JSON Schema semantics: a `pattern`/`maxLength`
- * with no `type` still constrains string instances (and is a no-op for other
- * types), so a type-less schema guards each family by its runtime type rather
- * than ignoring it — the subtlety `propertyNames: { maxLength: 3 }` depends on.
- *
- * `ctx.depth` seeds the loop variable names so nested walks never shadow one
- * another, and caps how far the expression may grow.
- */
-export declare const subschemaMatchExpr: (accessor: string, schema: JSONSchema, ctx?: MatchContext) => string | null;
-/**
- * True when a `$ref` node carries a keyword that constrains the value on its own.
- * 2020-12 applies a `$ref`'s siblings alongside the target, so delegating the
- * whole node to the referenced parser (which knows nothing about them) drops
- * every one of them — and a fast path built from the target's shape validator
- * skips them too.
- */
-export declare const hasConstrainingRefSibling: (schema: JSONSchema) => boolean;
-/**
- * Whether {@link subschemaMatchExpr} can build an exact matcher for `schema`.
- * The generation-time guard uses this to decide whether a `contains`,
- * `propertyNames`, or `dependentSchemas` subschema is enforceable.
- */
-export declare const canMatchSubschema: (schema: JSONSchema, rootSchema?: Record<string, unknown>) => boolean;