@amritk/generate-parsers 0.23.0 → 0.25.0

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

@@ -1,148 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-/**
- * Boolean type-check expression builders shared by the shape validators, the
- * parsers' fast paths, and the strict-mode assertions. They live in their own
- * module (rather than generate-parser-function) so generate-strict-assertion
- * can use them without an import cycle.
- *
- * Every expression built here is *true-sound*: when it evaluates to true the
- * value definitely matches the schema fragment. That is all a fast path needs.
- * The reverse direction — false definitely means invalid — only holds when
- * {@link canEnforceUnion} approves the schema, because a check may call an
- * imported `validate{X}Shape` that was generated as a conservative `=> false`
- * stub. Strict-mode code that *throws* on a false check must gate on it.
- */
-/**
- * Returns the shape-predicate function name for a given type name.
- * The predicate is generated alongside each parser and tells callers
- * whether `input` is already in the shape produced by the parser's fast path.
- */
-export declare const shapeValidatorName: (typeName: string) => string;
-/**
- * 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.
- */
-export declare const isInlineObjectProperty: (propSchema: JSONSchema) => propSchema is JSONSchema.Object;
-/**
- * Matches an array property whose `items` is an inline object schema — the
- * array-items analogue of {@link isInlineObjectProperty}. These get a private
- * item sub-parser (and shape predicate) so element values — including nested
- * enums and `$ref`s — are actually validated instead of only passing an
- * `Array.isArray` check.
- */
-export declare const isInlineObjectArrayProperty: (propSchema: JSONSchema) => boolean;
-/**
- * Matches an array property whose `items` is a *union* of object branches — the
- * shape a coercing parser needs a private item sub-parser for, so an element can
- * be dispatched to (and repaired toward) a branch rather than passed through.
- * {@link isInlineObjectArrayProperty} deliberately does not cover this: a union
- * is not one inline object, and the trust walk reads that predicate to decide
- * what a shape validator proves.
- */
-export declare const isUnionArrayProperty: (propSchema: JSONSchema) => boolean;
-/**
- * Matches a union written directly as a property value — `logo: { anyOf: [...] }`
- * rather than a `$ref`, a definition, or an array's `items`. This is the one
- * union position the coercing dispatcher did not reach, so a value matching no
- * branch was passed through unrepaired.
- *
- * The union's *own* keywords are the reason for the exclusions: 2020-12 applies
- * them alongside the branches, and a dispatcher expresses none of them, so a
- * constrained union keeps the general path rather than getting a parser that
- * quietly drops the constraint.
- */
-export declare const isInlineUnionProperty: (propSchema: JSONSchema) => boolean;
-/**
- * Extracts the branch list of a `oneOf`/`anyOf` union, or `null` when the
- * schema is not a union (or mixes in other composition keywords we cannot
- * turn into a membership check).
- */
-export declare const getUnionBranches: (schema: JSONSchema) => readonly JSONSchema[] | null;
-/**
- * True when {@link getUnionBranches} came from a `oneOf` rather than an `anyOf` —
- * i.e. the value must match *exactly one* branch, not at least one.
- *
- * The distinction was dropped before: both spellings produced a plain
- * disjunction, so `{ oneOf: [{…a}, {…b}] }` accepted `{ a: 'x', b: 1 }`, which
- * matches both branches. Ajv, the runtime interpreter, and `generate-validators`
- * all reject it, so the two mjst engines disagreed on the same contract.
- */
-export declare const isExclusiveUnion: (schema: JSONSchema) => boolean;
-/**
- * True when a schema carries a keyword the strict slow path enforces but which
- * no flat type check can mirror: `contains` (array item counting),
- * `dependentRequired` / `dependentSchemas` (cross-property presence),
- * `propertyNames` (per-key constraints), the conditional and composition
- * keywords (`if`/`then`/`else`, `not`, a constraining `allOf`), or per-key value
- * schemas (`patternProperties`, a constraining `additionalProperties`). A fast
- * path or shape validator that accepted such a value on a bare type check would
- * skip the enforcement, so both must bail when this is true — the slow path then
- * runs the real checks.
- */
-export declare const hasFastPathBlockingKeyword: (schema: JSONSchema) => boolean;
-/**
- * The membership check for an array-form `type` (the multi-type / nullable
- * idiom, e.g. `["string","null"]`): the disjunction of the per-type checks.
- * Returns `undefined` when the schema has no array `type`, and `null` when it
- * has one that cannot be checked soundly — a type name we do not model, or a
- * constraint keyword a bare `typeof` would skip.
- *
- * Without this every nullable property fell through to `hasType`, which is false
- * for an array `type`, and produced no check at all: no fast path (so the shape
- * validator degraded to the `=> false` stub) and, in strict mode, nothing to
- * throw on.
- */
-export declare const multiTypeCheck: (varName: string, schema: JSONSchema, options?: {
-    readonly ignoreConstraints?: boolean;
-}) => string | null | undefined;
-/**
- * Generates a fast-path type check expression for a property.
- * Returns null if the schema is too complex for a simple type check.
- *
- * When `useRefImports` is true, $ref properties (and arrays of $refs) are
- * checked by calling the imported shape predicate, allowing parent parsers
- * to fast-path through nested ref types without recursing into their parsers.
- */
-export declare const generatePropertyTypeCheck: (varName: string, schema: JSONSchema, useRefImports: boolean, suffix: string) => string | null;
-/**
- * Generates a boolean check that `varName` matches an inline object schema —
- * `isObject` plus a per-property check for every declared property (and a
- * presence check for `required` keys without a declared schema). Used for
- * union branches written inline, where no named shape validator exists to
- * call. Returns null when any property is too complex to check.
- */
-export declare const generateInlineObjectCheck: (varName: string, schema: JSONSchema, useRefImports: boolean, suffix: string) => string | null;
-/**
- * Generates a union membership check. Inline object branches get a per-property
- * check; everything else goes through {@link generatePropertyTypeCheck} ($refs
- * call the imported shape validator, consts/enums/scalars check directly).
- * Returns null when any branch cannot be checked.
- *
- * `exclusive` (a `oneOf` — see {@link isExclusiveUnion}) counts the matching
- * branches and demands exactly one, instead of the `anyOf` disjunction. The count
- * form is *tighter* than the disjunction it replaces — anything it accepts, the
- * disjunction accepted too — so a true-sound caller (a fast path, a shape
- * validator) can only get safer: a value it now declines merely takes the slow
- * path, which re-validates. A caller that *throws* on a false result needs each
- * branch check to be exact in both directions, which is precisely what
- * {@link canEnforceUnion} certifies.
- */
-export declare const generateUnionCheck: (varName: string, branches: readonly JSONSchema[], useRefImports: boolean, suffix: string, exclusive?: boolean) => string | null;
-/**
- * True when the union membership check emitted by {@link generateUnionCheck}
- * is also *false-sound* — a false result definitely means the value is invalid
- * — so strict mode may throw on it.
- *
- * The risk is `$ref`s: a branch (or a property inside one) whose check calls
- * an imported `validate{X}Shape` is only trustworthy when that validator was
- * generated as a real predicate. This walks every reachable ref (mirroring
- * generateShapeValidator's stub conditions) and rejects the union when any of
- * them would have produced the conservative `=> false` stub, or is itself
- * built on one. Cycles (e.g. a recursive `expr` union) are assumed sound —
- * the recursion bottoms out on the data, not the schema.
- */
-export declare const canEnforceUnion: (branches: readonly JSONSchema[], rootSchema: Record<string, unknown> | undefined) => boolean;

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

@@ -1,454 +0,0 @@
-import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
-import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
-import { refToName } from "@amritk/helpers/ref-to-name";
-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, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
-import { maxLengthPassExpr, minLengthPassExpr } from "@amritk/helpers/string-length-check";
-import { generateEnumCheck } from "./generate-enum-check.js";
-import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
-import { everyTailItem, getPrefixItems, plainScalarItemCheck, prefixItemsCapsLength, singleTypeCheck } from "./generate-validation-expression.js";
-import { hasConstrainingRefSibling, subschemaMatchExpr } from "./subschema-match.js";
-const shapeValidatorName = (typeName) => `validate${typeName}Shape`;
-const isInlineObjectProperty = (propSchema) => {
-  if (!isSchemaObject(propSchema))
-    return false;
-  if (hasRef(propSchema) || hasEnum(propSchema) || hasConst(propSchema))
-    return false;
-  if (Array.isArray(propSchema.type))
-    return false;
-  if (hasOneOf(propSchema) || hasAnyOf(propSchema) || hasAllOf(propSchema))
-    return false;
-  if ("patternProperties" in propSchema || "not" in propSchema)
-    return false;
-  if ("if" in propSchema || "then" in propSchema || "else" in propSchema)
-    return false;
-  if (hasAdditionalProperties(propSchema) && typeof propSchema.additionalProperties !== "boolean")
-    return false;
-  return isObjectSchema(propSchema) && hasProperties(propSchema);
-};
-const isInlineObjectArrayProperty = (propSchema) => {
-  if (!isSchemaObject(propSchema))
-    return false;
-  if (!("type" in propSchema) || propSchema.type !== "array")
-    return false;
-  if (!hasItems(propSchema) || Array.isArray(propSchema.items))
-    return false;
-  return isInlineObjectProperty(propSchema.items);
-};
-const isUnionArrayProperty = (propSchema) => {
-  if (!isSchemaObject(propSchema))
-    return false;
-  if (!("type" in propSchema) || propSchema.type !== "array")
-    return false;
-  if (!hasItems(propSchema) || Array.isArray(propSchema.items))
-    return false;
-  const items = propSchema.items;
-  if (!isSchemaObject(items))
-    return false;
-  const branches = getUnionBranches(items);
-  if (branches === null || branches.length < 2)
-    return false;
-  return branches.every((branch) => isSchemaObject(branch) && (hasRef(branch) || isInlineObjectProperty(branch)));
-};
-const isInlineUnionProperty = (propSchema) => {
-  if (!isSchemaObject(propSchema))
-    return false;
-  if (hasRef(propSchema) || hasAllOf(propSchema) || "not" in propSchema)
-    return false;
-  if ("if" in propSchema || "then" in propSchema || "else" in propSchema)
-    return false;
-  if ("patternProperties" in propSchema)
-    return false;
-  const branches = getUnionBranches(propSchema);
-  if (branches === null || branches.length < 2)
-    return false;
-  if (hasBranchSiblingConstraint(propSchema))
-    return false;
-  return branches.every((branch) => isSchemaObject(branch) && (hasRef(branch) || isInlineObjectProperty(branch)));
-};
-const getUnionBranches = (schema) => {
-  if (!isSchemaObject(schema))
-    return null;
-  if (hasAllOf(schema) || "not" in schema)
-    return null;
-  if (hasOneOf(schema) && schema.oneOf.length > 0)
-    return schema.oneOf;
-  if (hasAnyOf(schema) && schema.anyOf.length > 0)
-    return schema.anyOf;
-  return null;
-};
-const isExclusiveUnion = (schema) => isSchemaObject(schema) && !hasAllOf(schema) && !("not" in schema) && hasOneOf(schema) && schema.oneOf.length > 0;
-const hasFastPathBlockingKeyword = (schema) => {
-  if (!isSchemaObject(schema))
-    return false;
-  const record = schema;
-  return "contains" in record || "dependentSchemas" in record || "propertyNames" in record || "dependentRequired" in record || // Composition and conditionals: the strict assertions now enforce these, but
-  // a guard built from per-property type checks cannot mirror them — it said
-  // "already in shape" for `{ kind: 'a' }` under `if: {kind: 'a'}, then:
-  // {required: ['n']}` and returned before the conditional was ever tested.
-  "if" in record || "then" in record || "else" in record || "not" in record || "patternProperties" in record || // `unevaluated*` is answered against the whole node's annotation coverage,
-  // which a per-property guard has no way to reproduce.
-  "unevaluatedProperties" in record && record["unevaluatedProperties"] !== true || "unevaluatedItems" in record && record["unevaluatedItems"] !== true || // A `$ref` guard calls the target's shape validator, which knows nothing
-  // about the siblings 2020-12 still applies: `{ $ref: …, minProperties: 2 }`
-  // was waved through on the target's shape alone.
-  hasConstrainingRefSibling(schema) || hasConstrainingAllOf(schema) || hasConstrainingAdditionalProperties(schema);
-};
-const hasConstrainingAllOf = (schema) => hasAllOf(schema) && schema.allOf.some((member) => !(isSchemaObject(member) && hasRef(member)));
-const hasConstrainingAdditionalProperties = (schema) => {
-  if (!hasAdditionalProperties(schema))
-    return false;
-  const additional = schema.additionalProperties;
-  if (typeof additional === "boolean")
-    return false;
-  return subschemaMatchExpr("_x", additional) !== "true";
-};
-const CONSTRAINT_KEYWORDS = [
-  "pattern",
-  "minLength",
-  "maxLength",
-  "minimum",
-  "maximum",
-  "exclusiveMinimum",
-  "exclusiveMaximum",
-  "multipleOf",
-  "minItems",
-  "maxItems",
-  "uniqueItems",
-  "items",
-  "prefixItems",
-  "properties",
-  "required",
-  "additionalProperties",
-  "patternProperties",
-  "minProperties",
-  "maxProperties"
-];
-const hasBranchSiblingConstraint = (schema) => {
-  const record = schema;
-  return "type" in record || CONSTRAINT_KEYWORDS.some((keyword) => keyword in record);
-};
-const multiTypeCheck = (varName, schema, options = {}) => {
-  if (!isSchemaObject(schema) || !Array.isArray(schema.type))
-    return void 0;
-  const record = schema;
-  if (!options.ignoreConstraints && CONSTRAINT_KEYWORDS.some((keyword) => keyword in record))
-    return null;
-  const checks = [];
-  for (const type of schema.type) {
-    const check = singleTypeCheck(varName, type);
-    if (check === null)
-      return null;
-    checks.push(`(${check})`);
-  }
-  if (checks.length === 0)
-    return null;
-  return checks.length === 1 ? checks[0] : `(${checks.join(" || ")})`;
-};
-const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
-  if (!isSchemaObject(schema))
-    return null;
-  if (hasFastPathBlockingKeyword(schema))
-    return null;
-  if (useRefImports && hasRef(schema)) {
-    const refName = refToName(schema.$ref, suffix);
-    return `${shapeValidatorName(refName)}(${varName})`;
-  }
-  if (hasRef(schema))
-    return null;
-  if (hasEnum(schema)) {
-    return schema.enum.length > 0 ? generateEnumCheck(varName, schema.enum) : null;
-  }
-  const branches = getUnionBranches(schema);
-  if (branches) {
-    if (hasBranchSiblingConstraint(schema))
-      return null;
-    return generateUnionCheck(varName, branches, useRefImports, suffix, isExclusiveUnion(schema));
-  }
-  if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || "not" in schema) {
-    return null;
-  }
-  if (hasConst(schema)) {
-    const c = schema.const;
-    return c === null || typeof c !== "object" ? `${varName} === ${JSON.stringify(c)}` : null;
-  }
-  const multiType = multiTypeCheck(varName, schema);
-  if (multiType !== void 0)
-    return multiType;
-  if (!hasType(schema))
-    return null;
-  if (useRefImports && schema.type === "array" && hasItems(schema) && isSchemaObject(schema.items) && hasRef(schema.items)) {
-    const refName = refToName(schema.items.$ref, suffix);
-    return `Array.isArray(${varName}) && ${varName}.every(${shapeValidatorName(refName)})`;
-  }
-  const checks = [];
-  switch (schema.type) {
-    case "string": {
-      checks.push(`typeof ${varName} === "string"`);
-      if (hasPattern(schema))
-        checks.push(`${regexLiteral(schema.pattern)}.test(${varName})`);
-      if (hasMinLength(schema))
-        checks.push(minLengthPassExpr(varName, schema.minLength));
-      if (hasMaxLength(schema))
-        checks.push(maxLengthPassExpr(varName, schema.maxLength));
-      break;
-    }
-    case "number":
-    case "integer": {
-      checks.push(`typeof ${varName} === "number"`);
-      if (schema.type === "integer")
-        checks.push(`Number.isInteger(${varName})`);
-      if (hasMinimum(schema))
-        checks.push(`${varName} >= ${schema.minimum}`);
-      if (hasMaximum(schema))
-        checks.push(`${varName} <= ${schema.maximum}`);
-      if (hasExclusiveMinimum(schema))
-        checks.push(`${varName} > ${schema.exclusiveMinimum}`);
-      if (hasExclusiveMaximum(schema))
-        checks.push(`${varName} < ${schema.exclusiveMaximum}`);
-      if (hasMultipleOf(schema))
-        checks.push(multipleOfPassExpr(varName, schema.multipleOf));
-      break;
-    }
-    case "boolean":
-      checks.push(`typeof ${varName} === "boolean"`);
-      break;
-    case "array": {
-      checks.push(`Array.isArray(${varName})`);
-      if (hasMinItems(schema))
-        checks.push(`${varName}.length >= ${schema.minItems}`);
-      if (hasMaxItems(schema))
-        checks.push(`${varName}.length <= ${schema.maxItems}`);
-      if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-        checks.push(generateUniqueItemsCheck(varName, schema));
-      }
-      if (hasItems(schema) && !Array.isArray(schema.items)) {
-        const items = schema.items;
-        const itemCheck = plainScalarItemCheck(items, "_it") ?? (isSchemaObject(items) && hasEnum(items) && items.enum.length > 0 ? generateEnumCheck("_it", items.enum) : null);
-        if (itemCheck) {
-          checks.push(everyTailItem(varName, itemCheck, schema));
-        } else if (!(isSchemaObject(items) && (hasRef(items) || isInlineObjectProperty(items)))) {
-          const match = subschemaMatchExpr("_it", items);
-          if (match === null)
-            return null;
-          if (match !== "true")
-            checks.push(everyTailItem(varName, match, schema));
-        }
-      }
-      const prefix = getPrefixItems(schema);
-      if (prefix) {
-        for (let i = 0; i < prefix.length; i++) {
-          const posCheck = generatePropertyTypeCheck(`${varName}[${i}]`, prefix[i], false, suffix);
-          if (posCheck === null)
-            return null;
-          checks.push(`(${varName}.length <= ${i} || (${posCheck}))`);
-        }
-        if (prefixItemsCapsLength(schema))
-          checks.push(`${varName}.length <= ${prefix.length}`);
-      }
-      break;
-    }
-    case "object":
-      if (hasProperties(schema) || hasRequired(schema))
-        return null;
-      checks.push(`isObject(${varName})`);
-      if (hasMinProperties(schema))
-        checks.push(`Object.keys(${varName}).length >= ${schema.minProperties}`);
-      if (hasMaxProperties(schema))
-        checks.push(`Object.keys(${varName}).length <= ${schema.maxProperties}`);
-      break;
-    default:
-      return null;
-  }
-  if (checks.length === 0)
-    return null;
-  let result = checks[0];
-  for (let i = 1; i < checks.length; i++) {
-    result += " && " + checks[i];
-  }
-  return result;
-};
-const generateInlineObjectCheck = (varName, schema, useRefImports, suffix) => {
-  if (!isSchemaObject(schema) || !isObjectSchema(schema) || !hasProperties(schema))
-    return null;
-  if (hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema) || "not" in schema)
-    return null;
-  if ("patternProperties" in schema || "if" in schema)
-    return null;
-  if (hasAdditionalProperties(schema) && typeof schema.additionalProperties !== "boolean")
-    return null;
-  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
-  const checks = [`isObject(${varName})`];
-  for (const [key, propSchema] of Object.entries(schema.properties)) {
-    const acc = safeAccessor(varName, key);
-    const check = generatePropertyTypeCheck(acc, propSchema, useRefImports, suffix);
-    if (check === null)
-      return null;
-    checks.push(required.has(key) ? check : `(${acc} === undefined || ${check})`);
-    required.delete(key);
-  }
-  for (const key of required) {
-    checks.push(hasOwnCheck(varName, key));
-  }
-  if (hasAdditionalProperties(schema) && schema.additionalProperties === false) {
-    const allowedKeys = JSON.stringify(Object.keys(schema.properties));
-    checks.push(`Object.keys(${varName}).every((_k) => ${allowedKeys}.includes(_k))`);
-  }
-  if (hasMinProperties(schema))
-    checks.push(`Object.keys(${varName}).length >= ${schema.minProperties}`);
-  if (hasMaxProperties(schema))
-    checks.push(`Object.keys(${varName}).length <= ${schema.maxProperties}`);
-  return checks.join(" && ");
-};
-const generateUnionCheck = (varName, branches, useRefImports, suffix, exclusive = false) => {
-  if (branches.length === 0)
-    return null;
-  const parts = [];
-  for (const branch of branches) {
-    if (!isSchemaObject(branch))
-      return null;
-    const check = isObjectSchema(branch) && hasProperties(branch) && !hasRef(branch) ? generateInlineObjectCheck(varName, branch, useRefImports, suffix) : generatePropertyTypeCheck(varName, branch, useRefImports, suffix);
-    if (check === null)
-      return null;
-    parts.push(`(${check})`);
-  }
-  if (parts.length === 1)
-    return parts[0];
-  if (exclusive)
-    return `((${parts.map((part) => `(${part} ? 1 : 0)`).join(" + ")}) === 1)`;
-  return `(${parts.join(" || ")})`;
-};
-const canEnforceUnion = (branches, rootSchema) => {
-  const visiting = /* @__PURE__ */ new Set();
-  return branches.length > 0 && branches.every((branch) => {
-    if (!isSchemaObject(branch))
-      return false;
-    return isObjectSchema(branch) && hasProperties(branch) && !hasRef(branch) ? canTrustInlineObjectCheck(branch, rootSchema, visiting) : canTrustPropertyCheck(branch, rootSchema, visiting);
-  });
-};
-const canTrustPropertyCheck = (schema, rootSchema, visiting) => {
-  if (!isSchemaObject(schema))
-    return false;
-  if (hasRef(schema)) {
-    return canTrustReferencedValidator(schema.$ref, rootSchema, visiting);
-  }
-  if (hasEnum(schema))
-    return schema.enum.length > 0;
-  const branches = getUnionBranches(schema);
-  if (branches) {
-    return branches.every((branch) => {
-      if (!isSchemaObject(branch))
-        return false;
-      return isObjectSchema(branch) && hasProperties(branch) && !hasRef(branch) ? canTrustInlineObjectCheck(branch, rootSchema, visiting) : canTrustPropertyCheck(branch, rootSchema, visiting);
-    });
-  }
-  if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || "not" in schema)
-    return false;
-  if (hasConst(schema))
-    return schema.const === null || typeof schema.const !== "object";
-  const multiType = multiTypeCheck("_x", schema);
-  if (multiType !== void 0)
-    return multiType !== null;
-  if (!hasType(schema))
-    return false;
-  if (schema.type === "array" && hasItems(schema) && isSchemaObject(schema.items) && hasRef(schema.items)) {
-    return canTrustReferencedValidator(schema.items.$ref, rootSchema, visiting);
-  }
-  switch (schema.type) {
-    case "string":
-    case "number":
-    case "integer":
-    case "boolean":
-    case "array":
-    case "object":
-      return true;
-    default:
-      return false;
-  }
-};
-const canTrustShapeProperty = (propSchema, rootSchema, visiting) => {
-  if (!isSchemaObject(propSchema))
-    return false;
-  if (hasAdditionalProperties(propSchema) && typeof propSchema.additionalProperties !== "boolean")
-    return false;
-  if (isInlineObjectProperty(propSchema)) {
-    return Object.values(propSchema.properties ?? {}).every((sub) => canTrustShapeProperty(sub, rootSchema, visiting));
-  }
-  if (isInlineObjectArrayProperty(propSchema)) {
-    const items = propSchema.items;
-    return Object.values(items.properties ?? {}).every((sub) => canTrustShapeProperty(sub, rootSchema, visiting));
-  }
-  return canTrustPropertyCheck(propSchema, rootSchema, visiting);
-};
-const KEYWORDS_INLINE_CHECK_IGNORES = [
-  "propertyNames",
-  "dependentRequired",
-  "dependentSchemas",
-  "contains",
-  "unevaluatedProperties"
-];
-const canTrustInlineObjectCheck = (schema, rootSchema, visiting) => {
-  if (!isSchemaObject(schema) || !isObjectSchema(schema) || !hasProperties(schema))
-    return false;
-  if (hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema) || "not" in schema)
-    return false;
-  if ("patternProperties" in schema || "if" in schema)
-    return false;
-  if (hasAdditionalProperties(schema) && typeof schema.additionalProperties !== "boolean")
-    return false;
-  const record = schema;
-  if (KEYWORDS_INLINE_CHECK_IGNORES.some((keyword) => keyword in record))
-    return false;
-  return Object.values(schema.properties).every((propSchema) => canTrustPropertyCheck(propSchema, rootSchema, visiting));
-};
-const canTrustReferencedValidator = (ref, rootSchema, visiting) => {
-  if (visiting.has(ref))
-    return true;
-  if (!rootSchema)
-    return false;
-  const resolved = resolveRef(ref, rootSchema);
-  if (!resolved || !isSchemaObject(resolved))
-    return false;
-  visiting.add(ref);
-  try {
-    if (hasRef(resolved) && !hasProperties(resolved)) {
-      return canTrustReferencedValidator(resolved.$ref, rootSchema, visiting);
-    }
-    if (!hasProperties(resolved)) {
-      const branches = getUnionBranches(resolved);
-      if (!branches) {
-        if ("patternProperties" in resolved || "if" in resolved)
-          return false;
-        return canTrustPropertyCheck(resolved, rootSchema, visiting);
-      }
-      if ("patternProperties" in resolved || "if" in resolved)
-        return false;
-      return branches.every((branch) => {
-        if (!isSchemaObject(branch))
-          return false;
-        return isObjectSchema(branch) && hasProperties(branch) && !hasRef(branch) ? canTrustInlineObjectCheck(branch, rootSchema, visiting) : canTrustPropertyCheck(branch, rootSchema, visiting);
-      });
-    }
-    if (hasOneOf(resolved) || hasAnyOf(resolved) || hasAllOf(resolved) || "not" in resolved || "patternProperties" in resolved || "if" in resolved || "then" in resolved || "else" in resolved) {
-      return false;
-    }
-    return Object.values(resolved.properties).every((propSchema) => canTrustShapeProperty(propSchema, rootSchema, visiting));
-  } finally {
-    visiting.delete(ref);
-  }
-};
-export {
-  canEnforceUnion,
-  generateInlineObjectCheck,
-  generatePropertyTypeCheck,
-  generateUnionCheck,
-  getUnionBranches,
-  hasFastPathBlockingKeyword,
-  isExclusiveUnion,
-  isInlineObjectArrayProperty,
-  isInlineObjectProperty,
-  isInlineUnionProperty,
-  isUnionArrayProperty,
-  multiTypeCheck,
-  shapeValidatorName
-};

package/dist/generators/generate-unique-items-check.d.ts

@@ -1,16 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-/**
- * Builds the boolean expression that is TRUE when every element of `accessor` is
- * distinct — the `uniqueItems: true` contract.
- *
- * Scalar-only arrays take the cheap native `Set` (exact for primitives, and
- * allocation is a single pass). Anything that might hold an object or an array
- * falls back to the canonical-JSON projection above, because JSON Schema compares
- * items by *structural* equality and neither a plain `Set` (reference equality)
- * nor a raw `JSON.stringify` key (order sensitive) answers that question.
- *
- * @param accessor - Expression yielding the array; the caller must already have
- *   proven `Array.isArray`.
- * @param schema - The array schema, read for its item types.
- */
-export declare const generateUniqueItemsCheck: (accessor: string, schema: JSONSchema) => string;

package/dist/generators/generate-unique-items-check.js

@@ -1,32 +0,0 @@
-import { hasType, isSchemaObject } from "@amritk/helpers/schema-guards";
-const SCALAR_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null"]);
-const schemaIsScalarOnly = (schema) => {
-  if (schema === void 0 || !isSchemaObject(schema) || !hasType(schema))
-    return false;
-  const type = schema["type"];
-  const types = Array.isArray(type) ? type : [type];
-  return types.length > 0 && types.every((t) => typeof t === "string" && SCALAR_TYPES.has(t));
-};
-const arrayItemsAreScalarOnly = (schema) => {
-  if (!isSchemaObject(schema))
-    return false;
-  const record = schema;
-  const prefix = record["prefixItems"];
-  if (Array.isArray(prefix)) {
-    if (!prefix.every((position) => schemaIsScalarOnly(position)))
-      return false;
-    const tail = "items" in record ? record["items"] : record["additionalItems"];
-    return tail === false ? true : schemaIsScalarOnly(tail);
-  }
-  if (Array.isArray(record["items"])) {
-    if (!record["items"].every((position) => schemaIsScalarOnly(position)))
-      return false;
-    return record["additionalItems"] === false ? true : schemaIsScalarOnly(record["additionalItems"]);
-  }
-  return schemaIsScalarOnly(record["items"]);
-};
-const CANONICAL_JSON = 'JSON.stringify(_u, (_k, _v) => (_v !== null && typeof _v === "object" && !Array.isArray(_v)) ? Object.fromEntries(Object.keys(_v).sort().map((_sk) => [_sk, (_v as Record<string, unknown>)[_sk]])) : _v)';
-const generateUniqueItemsCheck = (accessor, schema) => arrayItemsAreScalarOnly(schema) ? `new Set(${accessor}).size === ${accessor}.length` : `new Set((${accessor} as unknown[]).map((_u) => ${CANONICAL_JSON})).size === ${accessor}.length`;
-export {
-  generateUniqueItemsCheck
-};