@amritk/generate-parsers 0.17.2 → 0.19.0

package/dist/generators/unevaluated-match.js

@@ -0,0 +1,206 @@
+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 unknown[])[${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 unknown[])`;
+  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/collect-imports.d.ts

@@ -16,6 +16,14 @@ type CollectImportsOptions = {
      * 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

package/dist/helpers/collect-imports.js

@@ -21,7 +21,7 @@ const collectImportTypeNames = (schema, options) => {
   return names;
 };
 const collectImportTargets = (schema, options) => {
-  const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : void 0;
+  const selfFilename = options?.selfFilename ?? (options?.selfRef ? refToFilename(options.selfRef) : void 0);
   const rootSchema = options?.rootSchema;
   const typeSuffix = options?.typeSuffix;
   const refs = /* @__PURE__ */ new Set();

package/dist/helpers/get-default-value.js

@@ -1,11 +1,54 @@
 import { getMjstPrimitive } from "@amritk/helpers/mjst-extension";
 import { hasAllOf, hasAnyOf, hasConst, hasDefault, hasEnum, hasExamples, hasOneOf, hasPattern, hasProperties, hasRequired, hasType, isSchemaObject } from "@amritk/helpers/schema-guards";
 import { generateDefaultFromPattern } from "../generators/generate-default-from-pattern.js";
+const defaultMatchesType = (value, schema) => {
+  if (!hasType(schema))
+    return true;
+  switch (schema.type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number";
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    default:
+      return true;
+  }
+};
+const MAX_FALLBACK_ITEMS = 32;
+const arrayFallback = (schema) => {
+  const record = schema;
+  const positions = Array.isArray(record["prefixItems"]) ? record["prefixItems"] : Array.isArray(record["items"]) ? record["items"] : [];
+  const tail = Array.isArray(record["items"]) ? record["additionalItems"] : record["items"];
+  const minItems = typeof record["minItems"] === "number" ? record["minItems"] : 0;
+  const wanted = minItems > MAX_FALLBACK_ITEMS ? Math.min(minItems, positions.length) : minItems;
+  if (wanted === 0)
+    return "[]";
+  const elements = [];
+  for (let i = 0; i < wanted; i++) {
+    const elementSchema = i < positions.length ? positions[i] : tail;
+    if (elementSchema === void 0 || typeof elementSchema === "boolean")
+      return "[]";
+    const element = getDefaultValue(elementSchema);
+    if (element === "undefined")
+      return "[]";
+    elements.push(element);
+  }
+  return `[${elements.join(", ")}]`;
+};
 const getDefaultValue = (schema) => {
   if (!isSchemaObject(schema)) {
     return "undefined";
   }
-  if (hasDefault(schema)) {
+  if (hasDefault(schema) && defaultMatchesType(schema.default, schema)) {
     return JSON.stringify(schema.default);
   }
   if (hasConst(schema)) {
@@ -63,7 +106,7 @@ const getDefaultValue = (schema) => {
     case "null":
       return "null";
     case "array":
-      return "[]";
+      return arrayFallback(schema);
     case "object": {
       if (hasProperties(schema) && hasRequired(schema)) {
         const props = schema.properties;

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.17.2",
+  "version": "0.19.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
+  "main": "./dist/index.js",
   "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
   "license": "MIT",
   "author": "amritk",
   "keywords": [
@@ -49,10 +55,10 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.13.5",
-    "@amritk/generate-markdown": "0.4.4"
+    "@amritk/helpers": "^0.15.0"
   },
   "devDependencies": {
+    "@amritk/generate-markdown": "^0.4.6",
     "@sinclair/typebox": "^0.34.49",
     "ajv": "^8.17.1",
     "zod": "^4.4.3"