@amritk/generate-parsers 0.23.0 → 0.25.0

package/dist/generators/subschema-match.js

@@ -1,485 +0,0 @@
-import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
-import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
-import { resolveRef } from "@amritk/helpers/resolve-ref";
-import { hasOwnCheck, missingCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
-import { hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
-import { maxLengthPassExpr, minLengthPassExpr } from "@amritk/helpers/string-length-check";
-import { generateDeepEqualCheck } from "./generate-deep-equal-check.js";
-import { generateEnumCheck } from "./generate-enum-check.js";
-import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
-import { unevaluatedItemsExpr, unevaluatedPropertiesExpr } from "./unevaluated-match.js";
-const HANDLED_KEYWORDS = /* @__PURE__ */ new Set([
-  "type",
-  "enum",
-  "const",
-  "pattern",
-  "minLength",
-  "maxLength",
-  "minimum",
-  "maximum",
-  "exclusiveMinimum",
-  "exclusiveMaximum",
-  "multipleOf",
-  "minItems",
-  "maxItems",
-  "uniqueItems",
-  "items",
-  "prefixItems",
-  "additionalItems",
-  "contains",
-  "minContains",
-  "maxContains",
-  "required",
-  "properties",
-  "patternProperties",
-  "propertyNames",
-  "dependentRequired",
-  "dependentSchemas",
-  "minProperties",
-  "maxProperties",
-  "additionalProperties",
-  "unevaluatedProperties",
-  "unevaluatedItems",
-  "$ref",
-  "allOf",
-  "anyOf",
-  "oneOf",
-  "not",
-  "if",
-  "then",
-  "else"
-]);
-const ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
-  "title",
-  "description",
-  "$comment",
-  "$id",
-  "$schema",
-  "$anchor",
-  "$dynamicAnchor",
-  "$vocabulary",
-  "$defs",
-  "definitions",
-  "examples",
-  "default",
-  "deprecated",
-  "readOnly",
-  "writeOnly",
-  "format",
-  "contentMediaType",
-  "contentEncoding",
-  "contentSchema"
-]);
-const depthOf = (ctx) => ctx.depth ?? 0;
-const nest = (ctx) => ({ ...ctx, depth: depthOf(ctx) + 1 });
-const isObjectExpr = (acc) => `typeof ${acc} === "object" && ${acc} !== null && !Array.isArray(${acc})`;
-const recordOf = (acc) => `(${acc} as Record<string, any>)`;
-const patternEntriesOf = (schema) => {
-  const source = schema["patternProperties"];
-  if (typeof source !== "object" || source === null || Array.isArray(source))
-    return null;
-  return Object.entries(source);
-};
-const stringConstraints = (acc, schema) => {
-  const c = [];
-  if (hasPattern(schema))
-    c.push(`${regexLiteral(schema.pattern)}.test(${acc})`);
-  if (hasMinLength(schema))
-    c.push(minLengthPassExpr(acc, schema.minLength));
-  if (hasMaxLength(schema))
-    c.push(maxLengthPassExpr(acc, schema.maxLength));
-  return c;
-};
-const numberConstraints = (acc, schema, integer) => {
-  const c = [];
-  if (integer)
-    c.push(`Number.isInteger(${acc})`);
-  if (hasMinimum(schema))
-    c.push(`${acc} >= ${schema.minimum}`);
-  if (hasMaximum(schema))
-    c.push(`${acc} <= ${schema.maximum}`);
-  if (hasExclusiveMinimum(schema))
-    c.push(`${acc} > ${schema.exclusiveMinimum}`);
-  if (hasExclusiveMaximum(schema))
-    c.push(`${acc} < ${schema.exclusiveMaximum}`);
-  if (hasMultipleOf(schema))
-    c.push(multipleOfPassExpr(acc, schema.multipleOf));
-  return c;
-};
-const tupleShape = (schema) => {
-  const s = schema;
-  const declared = s["prefixItems"];
-  if (Array.isArray(declared))
-    return { prefix: declared, tail: s["items"] };
-  if (Array.isArray(s["items"]))
-    return { prefix: s["items"], tail: s["additionalItems"] };
-  return { prefix: null, tail: void 0 };
-};
-const arrayConstraints = (acc, schema, ctx) => {
-  const c = [];
-  const d = depthOf(ctx);
-  const elements = `(${acc} as any[])`;
-  if (hasMinItems(schema))
-    c.push(`${acc}.length >= ${schema.minItems}`);
-  if (hasMaxItems(schema))
-    c.push(`${acc}.length <= ${schema.maxItems}`);
-  if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-    c.push(generateUniqueItemsCheck(acc, schema));
-  }
-  const { prefix, tail } = tupleShape(schema);
-  if (prefix) {
-    for (let i = 0; i < prefix.length; i++) {
-      const positional = subschemaMatchExpr(`${elements}[${i}]`, prefix[i], nest(ctx));
-      if (positional === null)
-        return null;
-      if (positional === "true")
-        continue;
-      c.push(`(${acc}.length <= ${i} || ${positional})`);
-    }
-    if (tail === false) {
-      c.push(`${acc}.length <= ${prefix.length}`);
-    } else if (tail !== void 0 && tail !== true) {
-      const el = `_i${d}`;
-      const tailMatch = subschemaMatchExpr(el, tail, nest(ctx));
-      if (tailMatch === null)
-        return null;
-      if (tailMatch !== "true")
-        c.push(`${elements}.every((${el}, _x${d}) => _x${d} < ${prefix.length} || ${tailMatch})`);
-    }
-  } else if ("items" in schema) {
-    if (schema["items"] === false) {
-      c.push(`${acc}.length === 0`);
-    } else if (hasItems(schema)) {
-      const el = `_i${d}`;
-      const itemMatch = subschemaMatchExpr(el, schema.items, nest(ctx));
-      if (itemMatch === null)
-        return null;
-      if (itemMatch !== "true")
-        c.push(`${elements}.every((${el}) => ${itemMatch})`);
-    }
-  }
-  const contains = containsConstraint(acc, schema, ctx);
-  if (contains === null)
-    return null;
-  c.push(...contains);
-  const unevaluated = unevaluatedItemsExpr(acc, schema, ctx, subschemaMatchExpr);
-  if (unevaluated === null)
-    return null;
-  if (unevaluated !== void 0)
-    c.push(unevaluated);
-  return c;
-};
-const containsConstraint = (acc, schema, ctx) => {
-  const s = schema;
-  if (!("contains" in s))
-    return [];
-  const d = depthOf(ctx);
-  const min = typeof s["minContains"] === "number" ? s["minContains"] : 1;
-  const max = typeof s["maxContains"] === "number" ? s["maxContains"] : void 0;
-  if (min === 0 && max === void 0)
-    return [];
-  const el = `_c${d}`;
-  const match = subschemaMatchExpr(el, s["contains"], nest(ctx));
-  if (match === null)
-    return null;
-  const count = `(${acc} as any[]).filter((${el}) => ${match}).length`;
-  const bounds = [];
-  if (min > 0)
-    bounds.push(`${count} >= ${min}`);
-  if (max !== void 0)
-    bounds.push(`${count} <= ${max}`);
-  return bounds;
-};
-const objectConstraints = (acc, schema, ctx) => {
-  const c = [];
-  const d = depthOf(ctx);
-  const required = new Set(hasRequired(schema) ? schema.required : []);
-  const rec = recordOf(acc);
-  if (hasProperties(schema)) {
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-      const propAcc = safeAccessor(rec, key);
-      const propMatch = subschemaMatchExpr(propAcc, propSchema, nest(ctx));
-      if (propMatch === null)
-        return null;
-      if (required.has(key)) {
-        c.push(propMatch === "true" ? hasOwnCheck(rec, key) : `(${hasOwnCheck(rec, key)} && ${propMatch})`);
-      } else if (propMatch !== "true") {
-        c.push(`(${propAcc} === undefined || ${propMatch})`);
-      }
-      required.delete(key);
-    }
-  }
-  for (const key of required)
-    c.push(hasOwnCheck(rec, key));
-  if (hasMinProperties(schema))
-    c.push(`Object.keys(${rec}).length >= ${schema.minProperties}`);
-  if (hasMaxProperties(schema))
-    c.push(`Object.keys(${rec}).length <= ${schema.maxProperties}`);
-  const keyTerms = keyWalkTerms(`_k${d}`, `_v${d}`, schema, ctx);
-  if (keyTerms === null)
-    return null;
-  if (keyTerms.length > 0) {
-    const needsValue = keyTerms.some((term) => term.usesValue);
-    const body = keyTerms.map((term) => term.expr).join(" && ");
-    c.push(needsValue ? `Object.keys(${rec}).every((_k${d}) => { const _v${d} = ${rec}[_k${d}]; return ${body}; })` : `Object.keys(${rec}).every((_k${d}) => ${body})`);
-  }
-  const dependent = dependentTerms(rec, acc, schema, ctx);
-  if (dependent === null)
-    return null;
-  c.push(...dependent);
-  const unevaluated = unevaluatedPropertiesExpr(acc, schema, ctx, subschemaMatchExpr);
-  if (unevaluated === null)
-    return null;
-  if (unevaluated !== void 0)
-    c.push(unevaluated);
-  return c;
-};
-const keyWalkTerms = (keyVar, valueVar, schema, ctx) => {
-  const terms = [];
-  const patterns = patternEntriesOf(schema);
-  const declared = hasProperties(schema) ? Object.keys(schema.properties) : [];
-  if (patterns) {
-    for (const [pattern, sub] of patterns) {
-      const match = subschemaMatchExpr(valueVar, sub, nest(ctx));
-      if (match === null)
-        return null;
-      if (match === "true")
-        continue;
-      terms.push({ expr: `(!${regexLiteral(pattern)}.test(${keyVar}) || ${match})`, usesValue: true });
-    }
-  }
-  const additional = schema["additionalProperties"];
-  if (additional !== void 0 && additional !== true) {
-    const guards = [];
-    if (declared.length > 0)
-      guards.push(`!${JSON.stringify(declared)}.includes(${keyVar})`);
-    if (patterns)
-      for (const [pattern] of patterns)
-        guards.push(`!${regexLiteral(pattern)}.test(${keyVar})`);
-    const unclaimed = guards.length > 0 ? guards.join(" && ") : null;
-    if (additional === false) {
-      terms.push({ expr: unclaimed === null ? "false" : `!(${unclaimed})`, usesValue: false });
-    } else {
-      const match = subschemaMatchExpr(valueVar, additional, nest(ctx));
-      if (match === null)
-        return null;
-      if (match !== "true") {
-        terms.push({ expr: unclaimed === null ? match : `(!(${unclaimed}) || ${match})`, usesValue: true });
-      }
-    }
-  }
-  const names = schema["propertyNames"];
-  if (names !== void 0) {
-    const match = subschemaMatchExpr(keyVar, names, nest(ctx));
-    if (match === null)
-      return null;
-    if (match !== "true")
-      terms.push({ expr: match, usesValue: false });
-  }
-  return terms;
-};
-const dependentTerms = (rec, acc, schema, ctx) => {
-  const s = schema;
-  const terms = [];
-  const dependentRequired = s["dependentRequired"];
-  if (typeof dependentRequired === "object" && dependentRequired !== null && !Array.isArray(dependentRequired)) {
-    for (const [trigger, deps] of Object.entries(dependentRequired)) {
-      if (!Array.isArray(deps) || deps.length === 0)
-        continue;
-      const present = deps.map((dep) => hasOwnCheck(rec, dep)).join(" && ");
-      terms.push(`(${missingCheck(rec, trigger)} || ${deps.length === 1 ? present : `(${present})`})`);
-    }
-  }
-  const dependentSchemas = s["dependentSchemas"];
-  if (typeof dependentSchemas === "object" && dependentSchemas !== null && !Array.isArray(dependentSchemas)) {
-    for (const [trigger, sub] of Object.entries(dependentSchemas)) {
-      const match = subschemaMatchExpr(acc, sub, nest(ctx));
-      if (match === null)
-        return null;
-      if (match === "true")
-        continue;
-      terms.push(`(${missingCheck(rec, trigger)} || ${match})`);
-    }
-  }
-  return terms;
-};
-const subschemaMatchExpr = (accessor, schema, ctx = {}) => {
-  if (schema === true)
-    return "true";
-  if (schema === false)
-    return "false";
-  if (!isSchemaObject(schema))
-    return null;
-  for (const key of Object.keys(schema)) {
-    if (!HANDLED_KEYWORDS.has(key) && !ANNOTATION_KEYWORDS.has(key))
-      return null;
-  }
-  if (depthOf(ctx) > 8)
-    return null;
-  const checks = [];
-  const refCheck = refMatch(accessor, schema, ctx);
-  if (refCheck === null)
-    return null;
-  if (refCheck !== "true")
-    checks.push(refCheck);
-  const combinators = combinatorChecks(accessor, schema, ctx);
-  if (combinators === null)
-    return null;
-  checks.push(...combinators);
-  if (hasConst(schema))
-    checks.push(`(${generateDeepEqualCheck(accessor, schema.const)})`);
-  if (hasEnum(schema)) {
-    if (schema.enum.length === 0)
-      return "false";
-    checks.push(generateEnumCheck(accessor, schema.enum));
-  }
-  if (hasType(schema)) {
-    const typeChecks = buildTypedChecks(accessor, schema, ctx);
-    if (typeChecks === null)
-      return null;
-    checks.push(...typeChecks);
-  } else if (Array.isArray(schema.type)) {
-    const branches = [];
-    for (const type of schema.type) {
-      const branch = buildTypedChecks(accessor, { ...schema, type }, ctx);
-      if (branch === null)
-        return null;
-      branches.push(branch.length === 1 ? branch[0] : `(${branch.join(" && ")})`);
-    }
-    checks.push(branches.length === 0 ? "false" : branches.length === 1 ? branches[0] : `(${branches.join(" || ")})`);
-  } else {
-    const typeless = buildTypelessChecks(accessor, schema, ctx);
-    if (typeless === null)
-      return null;
-    checks.push(...typeless);
-  }
-  if (checks.length === 0)
-    return "true";
-  return checks.length === 1 ? checks[0] : `(${checks.join(" && ")})`;
-};
-const refMatch = (accessor, schema, ctx) => {
-  const ref = schema["$ref"];
-  if (typeof ref !== "string")
-    return "true";
-  if (ctx.rootSchema === void 0)
-    return null;
-  if (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);
-  return subschemaMatchExpr(accessor, target, { ...nest(ctx), seen });
-};
-const combinatorChecks = (accessor, schema, ctx) => {
-  const record = schema;
-  const checks = [];
-  for (const keyword of ["allOf", "anyOf", "oneOf"]) {
-    const members = record[keyword];
-    if (members === void 0)
-      continue;
-    if (!Array.isArray(members) || members.length === 0)
-      return null;
-    const matches = [];
-    for (const member of members) {
-      const match = subschemaMatchExpr(accessor, member, nest(ctx));
-      if (match === null)
-        return null;
-      matches.push(match);
-    }
-    if (keyword === "allOf") {
-      const constraining = matches.filter((match) => match !== "true");
-      if (constraining.length > 0)
-        checks.push(joinAnd(constraining));
-    } else if (keyword === "anyOf") {
-      if (matches.some((match) => match === "true"))
-        continue;
-      checks.push(matches.length === 1 ? matches[0] : `(${matches.join(" || ")})`);
-    } else {
-      checks.push(matches.length === 1 ? matches[0] : `((${matches.map((match) => `(${match} ? 1 : 0)`).join(" + ")}) === 1)`);
-    }
-  }
-  if ("not" in record) {
-    const match = subschemaMatchExpr(accessor, record["not"], nest(ctx));
-    if (match === null)
-      return null;
-    if (match !== "false")
-      checks.push(`!(${match})`);
-  }
-  if ("if" in record) {
-    const ifMatch = subschemaMatchExpr(accessor, record["if"], nest(ctx));
-    if (ifMatch === null)
-      return null;
-    const branch = (keyword) => keyword in record ? subschemaMatchExpr(accessor, record[keyword], nest(ctx)) : void 0;
-    const thenMatch = branch("then");
-    const elseMatch = branch("else");
-    if (thenMatch === null || elseMatch === null)
-      return null;
-    if (thenMatch !== void 0 && thenMatch !== "true")
-      checks.push(`(!(${ifMatch}) || ${thenMatch})`);
-    if (elseMatch !== void 0 && elseMatch !== "true")
-      checks.push(`((${ifMatch}) || ${elseMatch})`);
-  }
-  return checks;
-};
-const buildTypedChecks = (accessor, schema, ctx) => {
-  switch (schema.type) {
-    case "string":
-      return [`typeof ${accessor} === "string"`, ...stringConstraints(accessor, schema)];
-    case "number":
-      return [`typeof ${accessor} === "number"`, ...numberConstraints(accessor, schema, false)];
-    case "integer":
-      return [`typeof ${accessor} === "number"`, ...numberConstraints(accessor, schema, true)];
-    case "boolean":
-      return [`typeof ${accessor} === "boolean"`];
-    case "null":
-      return [`${accessor} === null`];
-    case "array": {
-      const constraints = arrayConstraints(accessor, schema, ctx);
-      if (constraints === null)
-        return null;
-      return [`Array.isArray(${accessor})`, ...constraints];
-    }
-    case "object": {
-      const constraints = objectConstraints(accessor, schema, ctx);
-      if (constraints === null)
-        return null;
-      return [isObjectExpr(accessor), ...constraints];
-    }
-    default:
-      return null;
-  }
-};
-const buildTypelessChecks = (accessor, schema, ctx) => {
-  const checks = [];
-  const strChecks = stringConstraints(accessor, schema);
-  if (strChecks.length > 0)
-    checks.push(`(typeof ${accessor} !== "string" || ${joinAnd(strChecks)})`);
-  const numChecks = numberConstraints(accessor, schema, false);
-  if (numChecks.length > 0)
-    checks.push(`(typeof ${accessor} !== "number" || ${joinAnd(numChecks)})`);
-  const arrChecks = arrayConstraints(accessor, schema, ctx);
-  if (arrChecks === null)
-    return null;
-  if (arrChecks.length > 0)
-    checks.push(`(!Array.isArray(${accessor}) || ${joinAnd(arrChecks)})`);
-  const objChecks = objectConstraints(accessor, schema, ctx);
-  if (objChecks === null)
-    return null;
-  if (objChecks.length > 0)
-    checks.push(`(!(${isObjectExpr(accessor)}) || ${joinAnd(objChecks)})`);
-  return checks;
-};
-const joinAnd = (checks) => checks.length === 1 ? checks[0] : `(${checks.join(" && ")})`;
-const hasConstrainingRefSibling = (schema) => {
-  if (!isSchemaObject(schema) || !("$ref" in schema))
-    return false;
-  return Object.keys(schema).some((key) => key !== "$ref" && !ANNOTATION_KEYWORDS.has(key));
-};
-const canMatchSubschema = (schema, rootSchema) => subschemaMatchExpr("_x", schema, rootSchema ? { rootSchema } : {}) !== null;
-export {
-  canMatchSubschema,
-  hasConstrainingRefSibling,
-  subschemaMatchExpr
-};

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

@@ -1,19 +0,0 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-import type { MatchContext } from './subschema-match.js';
-type MatchFn = (accessor: string, schema: JSONSchema, ctx: MatchContext) => string | null;
-/**
- * The `unevaluatedProperties` conjunct for an object accessor: every own key the
- * schema's other keywords did not evaluate must satisfy the unevaluated
- * subschema (and `false` means there must be no such key).
- *
- * Returns `undefined` when the keyword is absent or constrains nothing (a `true`
- * schema, or a node whose other keywords already sweep every key), and `null`
- * when it cannot be proven inline.
- */
-export declare const unevaluatedPropertiesExpr: (acc: string, schema: JSONSchema, ctx: MatchContext, match: MatchFn) => string | null | undefined;
-/**
- * The `unevaluatedItems` conjunct for an array accessor — the index counterpart
- * of {@link unevaluatedPropertiesExpr}.
- */
-export declare const unevaluatedItemsExpr: (acc: string, schema: JSONSchema, ctx: MatchContext, match: MatchFn) => string | null | undefined;
-export {};