openapi-typesafe 1.0.0-rc.0 → 1.0.0-rc.2

package/dist/application/transform/document/path-key-overlaps.mjs

@@ -1,48 +1,98 @@
+import { isAssignableToTemplate } from './template-key-match.mjs';
+
 const BOOLEAN_TEXTS = ["true", "false"];
-const SAMPLE_TEXTS = {
-  string: "",
-  number: "0",
-  boolean: "true"
-};
-function isNumberText(text) {
-  return text !== "" && Number.isFinite(Number(text));
-}
-function isPlaceholderText(type, text) {
-  if (type === "number") {
-    return isNumberText(text);
-  }
-  return type === "boolean" ? BOOLEAN_TEXTS.includes(text) : true;
+function withPart(shapes, part) {
+  return shapes.flatMap((shape) => {
+    const lead = shape.texts.slice(0, -1);
+    const last = shape.texts[shape.texts.length - 1];
+    if (part.kind === "text") {
+      return [{ texts: [...lead, last + part.text], types: shape.types }];
+    }
+    if (part.type === "boolean") {
+      return BOOLEAN_TEXTS.map((text) => ({ texts: [...lead, last + text], types: shape.types }));
+    }
+    return [{ texts: [...shape.texts, ""], types: [...shape.types, part.type] }];
+  });
 }
-function matchesFrom(text, start, parts, index) {
-  const part = parts[index];
-  if (part === void 0) {
-    return start === text.length;
-  }
-  if (part.kind === "text") {
-    return text.startsWith(part.text, start) && matchesFrom(text, start + part.text.length, parts, index + 1);
+function shapesOf(key) {
+  if (key.kind === "literal") {
+    return [{ texts: [key.url], types: [] }];
   }
-  for (let end = start; end <= text.length; end += 1) {
-    if (isPlaceholderText(part.type, text.slice(start, end)) && matchesFrom(text, end, parts, index + 1)) {
-      return true;
+  return key.parts.reduce(withPart, [{ texts: [""], types: [] }]);
+}
+function isCoveredBy(sources, targets) {
+  return sources.length > 0 && sources.every((source) => targets.some((target) => isAssignableToTemplate(source, target)));
+}
+const EVERY_COVER_REJECTED = () => true;
+function checkedShapes(key) {
+  const shapes = shapesOf(key);
+  return key.kind === "literal" ? shapes : shapes.filter((shape) => shape.types.length > 0);
+}
+function checkedKeyOf(key) {
+  const template = key.kind === "template" ? JSON.stringify(shapesOf(key)) : null;
+  return { key, shapes: checkedShapes(key), template };
+}
+function repeatedTemplates(checked) {
+  const seen = /* @__PURE__ */ new Set();
+  const repeated = /* @__PURE__ */ new Set();
+  for (const { template } of checked) {
+    if (template !== null) {
+      (seen.has(template) ? repeated : seen).add(template);
     }
   }
-  return false;
+  return repeated;
 }
-function sampleOf(key) {
-  if (key.kind === "literal") {
-    return key.url;
+function compareCodeUnits(left, right) {
+  if (left === right) {
+    return 0;
   }
-  return key.parts.map((part) => part.kind === "text" ? part.text : SAMPLE_TEXTS[part.type]).join("");
+  return left < right ? -1 : 1;
+}
+function startTextIndexOf(checked) {
+  const entries = checked.flatMap(
+    ({ shapes }, keyIndex) => shapes.map((shape) => ({ start: shape.texts[0], keyIndex }))
+  );
+  entries.sort((left, right) => compareCodeUnits(left.start, right.start));
+  return {
+    starts: entries.map((entry) => entry.start),
+    keyIndexes: entries.map((entry) => entry.keyIndex)
+  };
+}
+function keysStartingWith(index, prefixes) {
+  const found = /* @__PURE__ */ new Set();
+  for (const prefix of prefixes) {
+    let low = 0;
+    let high = index.starts.length;
+    while (low < high) {
+      const middle = low + high >> 1;
+      if (index.starts[middle] < prefix) {
+        low = middle + 1;
+      } else {
+        high = middle;
+      }
+    }
+    for (let at = low; at < index.starts.length; at += 1) {
+      if (!index.starts[at].startsWith(prefix)) {
+        break;
+      }
+      found.add(index.keyIndexes[at]);
+    }
+  }
+  return found;
 }
-const EVERY_COVER_REJECTED = () => true;
 function coveringTemplateKeys(keys, isRejected = EVERY_COVER_REJECTED) {
+  const checked = keys.map(checkedKeyOf);
+  const repeated = repeatedTemplates(checked);
+  const startTexts = startTextIndexOf(checked);
   const covering = /* @__PURE__ */ new Set();
-  keys.forEach((key, index) => {
-    if (key.kind !== "template") {
+  checked.forEach(({ template, shapes: targets }, index) => {
+    if (template === null) {
       return;
     }
-    const isCovering = keys.some(
-      (other, otherIndex) => otherIndex !== index && matchesFrom(sampleOf(other), 0, key.parts, 0) && isRejected(index, otherIndex)
+    const prefixes = targets.map((target) => target.texts[0]);
+    const candidates = [...keysStartingWith(startTexts, prefixes)].sort((a, b) => a - b);
+    const isCovering = repeated.has(template) || candidates.some(
+      (otherIndex) => otherIndex !== index && isCoveredBy(checked[otherIndex].shapes, targets) && isRejected(index, otherIndex)
     );
     if (isCovering) {
       covering.add(index);

package/dist/application/transform/document/path-key-overlaps.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"path-key-overlaps.mjs","sources":["../../../../src/application/transform/document/path-key-overlaps.ts"],"sourcesContent":["/**\n * `--path-params-as-types` overlaps (roadmap R10.2, backlog 28). A path key with parameters is an\n * index signature over a template literal type, such as `` `/apps/${string}` ``. `${string}` also\n * matches `/`, so that signature covers `/apps/regions` and `` `/apps/${string}/restart` `` as\n * well, and TypeScript requires the covered keys' types to be assignable to its type (TS2411,\n * TS2413). These functions find the signatures that cover another key the checker rejects.\n */\n\n/** A placeholder of a template literal type, by the type it stands for. */\nexport type PathPlaceholder = \"string\" | \"number\" | \"boolean\";\n\n/** One part of a path key: text, or a placeholder. */\nexport type PathKeyPart =\n  | { readonly kind: \"text\"; readonly text: string }\n  | { readonly kind: \"placeholder\"; readonly type: PathPlaceholder };\n\n/** A path key: a URL written as a property, or a template literal type of an index signature. */\nexport type PathKey =\n  | { readonly kind: \"literal\"; readonly url: string }\n  | { readonly kind: \"template\"; readonly parts: readonly PathKeyPart[] };\n\nconst BOOLEAN_TEXTS: readonly string[] = [\"true\", \"false\"];\n\n/** The text one placeholder stands for in a sample of a template key. */\nconst SAMPLE_TEXTS: Readonly<Record<PathPlaceholder, string>> = {\n  string: \"\",\n  number: \"0\",\n  boolean: \"true\",\n};\n\n/** TypeScript's rule for `${number}`: a text that converts to a finite number. */\nfunction isNumberText(text: string): boolean {\n  return text !== \"\" && Number.isFinite(Number(text));\n}\n\nfunction isPlaceholderText(type: PathPlaceholder, text: string): boolean {\n  if (type === \"number\") {\n    return isNumberText(text);\n  }\n  return type === \"boolean\" ? BOOLEAN_TEXTS.includes(text) : true;\n}\n\n/** Whether `text` from `start` on is one of the strings the parts from `index` on describe. */\nfunction matchesFrom(\n  text: string,\n  start: number,\n  parts: readonly PathKeyPart[],\n  index: number,\n): boolean {\n  const part = parts[index];\n  if (part === undefined) {\n    return start === text.length;\n  }\n  if (part.kind === \"text\") {\n    return (\n      text.startsWith(part.text, start) &&\n      matchesFrom(text, start + part.text.length, parts, index + 1)\n    );\n  }\n  for (let end = start; end <= text.length; end += 1) {\n    if (\n      isPlaceholderText(part.type, text.slice(start, end)) &&\n      matchesFrom(text, end, parts, index + 1)\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * One string of the key. If a template key is covered, every string of it is, so a sample that is\n * not covered proves the key is not; a sample that is covered may over-report, which only moves a\n * signature that did not need it (the types stay the same, see `pathsObjectType`).\n */\nfunction sampleOf(key: PathKey): string {\n  if (key.kind === \"literal\") {\n    return key.url;\n  }\n  return key.parts\n    .map((part) => (part.kind === \"text\" ? part.text : SAMPLE_TEXTS[part.type]))\n    .join(\"\");\n}\n\n/** Whether TypeScript rejects the key at `covered` for the signature at `covering`. */\nexport type CoverRejection = (covering: number, covered: number) => boolean;\n\n/** Without type information every covered key counts. */\nconst EVERY_COVER_REJECTED: CoverRejection = () => true;\n\n/** The indexes of the template keys that cover another key of the list, where it is rejected. */\nexport function coveringTemplateKeys(\n  keys: readonly PathKey[],\n  isRejected: CoverRejection = EVERY_COVER_REJECTED,\n): ReadonlySet<number> {\n  const covering = new Set<number>();\n  keys.forEach((key, index) => {\n    if (key.kind !== \"template\") {\n      return;\n    }\n    const isCovering = keys.some(\n      (other, otherIndex) =>\n        otherIndex !== index &&\n        matchesFrom(sampleOf(other), 0, key.parts, 0) &&\n        isRejected(index, otherIndex),\n    );\n    if (isCovering) {\n      covering.add(index);\n    }\n  });\n  return covering;\n}\n"],"names":[],"mappings":"AAqBA,MAAM,aAAA,GAAmC,CAAC,MAAA,EAAQ,OAAO,CAAA;AAGzD,MAAM,YAAA,GAA0D;AAAA,EAC9D,MAAA,EAAQ,EAAA;AAAA,EACR,MAAA,EAAQ,GAAA;AAAA,EACR,OAAA,EAAS;AACX,CAAA;AAGA,SAAS,aAAa,IAAA,EAAuB;AAC3C,EAAA,OAAO,SAAS,EAAA,IAAM,MAAA,CAAO,QAAA,CAAS,MAAA,CAAO,IAAI,CAAC,CAAA;AACpD;AAEA,SAAS,iBAAA,CAAkB,MAAuB,IAAA,EAAuB;AACvE,EAAA,IAAI,SAAS,QAAA,EAAU;AACrB,IAAA,OAAO,aAAa,IAAI,CAAA;AAAA,EAC1B;AACA,EAAA,OAAO,IAAA,KAAS,SAAA,GAAY,aAAA,CAAc,QAAA,CAAS,IAAI,CAAA,GAAI,IAAA;AAC7D;AAGA,SAAS,WAAA,CACP,IAAA,EACA,KAAA,EACA,KAAA,EACA,KAAA,EACS;AACT,EAAA,MAAM,IAAA,GAAO,MAAM,KAAK,CAAA;AACxB,EAAA,IAAI,SAAS,MAAA,EAAW;AACtB,IAAA,OAAO,UAAU,IAAA,CAAK,MAAA;AAAA,EACxB;AACA,EAAA,IAAI,IAAA,CAAK,SAAS,MAAA,EAAQ;AACxB,IAAA,OACE,IAAA,CAAK,UAAA,CAAW,IAAA,CAAK,IAAA,EAAM,KAAK,CAAA,IAChC,WAAA,CAAY,IAAA,EAAM,KAAA,GAAQ,IAAA,CAAK,IAAA,CAAK,MAAA,EAAQ,KAAA,EAAO,QAAQ,CAAC,CAAA;AAAA,EAEhE;AACA,EAAA,KAAA,IAAS,MAAM,KAAA,EAAO,GAAA,IAAO,IAAA,CAAK,MAAA,EAAQ,OAAO,CAAA,EAAG;AAClD,IAAA,IACE,iBAAA,CAAkB,IAAA,CAAK,IAAA,EAAM,IAAA,CAAK,MAAM,KAAA,EAAO,GAAG,CAAC,CAAA,IACnD,YAAY,IAAA,EAAM,GAAA,EAAK,KAAA,EAAO,KAAA,GAAQ,CAAC,CAAA,EACvC;AACA,MAAA,OAAO,IAAA;AAAA,IACT;AAAA,EACF;AACA,EAAA,OAAO,KAAA;AACT;AAOA,SAAS,SAAS,GAAA,EAAsB;AACtC,EAAA,IAAI,GAAA,CAAI,SAAS,SAAA,EAAW;AAC1B,IAAA,OAAO,GAAA,CAAI,GAAA;AAAA,EACb;AACA,EAAA,OAAO,IAAI,KAAA,CACR,GAAA,CAAI,CAAC,IAAA,KAAU,KAAK,IAAA,KAAS,MAAA,GAAS,IAAA,CAAK,IAAA,GAAO,aAAa,IAAA,CAAK,IAAI,CAAE,CAAA,CAC1E,KAAK,EAAE,CAAA;AACZ;AAMA,MAAM,uBAAuC,MAAM,IAAA;AAG5C,SAAS,oBAAA,CACd,IAAA,EACA,UAAA,GAA6B,oBAAA,EACR;AACrB,EAAA,MAAM,QAAA,uBAAe,GAAA,EAAY;AACjC,EAAA,IAAA,CAAK,OAAA,CAAQ,CAAC,GAAA,EAAK,KAAA,KAAU;AAC3B,IAAA,IAAI,GAAA,CAAI,SAAS,UAAA,EAAY;AAC3B,MAAA;AAAA,IACF;AACA,IAAA,MAAM,aAAa,IAAA,CAAK,IAAA;AAAA,MACtB,CAAC,KAAA,EAAO,UAAA,KACN,UAAA,KAAe,KAAA,IACf,YAAY,QAAA,CAAS,KAAK,CAAA,EAAG,CAAA,EAAG,IAAI,KAAA,EAAO,CAAC,CAAA,IAC5C,UAAA,CAAW,OAAO,UAAU;AAAA,KAChC;AACA,IAAA,IAAI,UAAA,EAAY;AACd,MAAA,QAAA,CAAS,IAAI,KAAK,CAAA;AAAA,IACpB;AAAA,EACF,CAAC,CAAA;AACD,EAAA,OAAO,QAAA;AACT;;"}
+{"version":3,"file":"path-key-overlaps.mjs","sources":["../../../../src/application/transform/document/path-key-overlaps.ts"],"sourcesContent":["/**\n * `--path-params-as-types` overlaps (roadmap R10.2, backlog 28). A path key with parameters is an\n * index signature over a template literal type, such as `` `/apps/${string}` ``. `${string}` also\n * matches `/`, so that signature covers `/apps/regions` and `` `/apps/${string}/restart` `` as\n * well, and TypeScript requires the covered keys' types to be assignable to its type (TS2411,\n * TS2413). These functions find the signatures that cover another key the checker rejects.\n */\n\nimport { isAssignableToTemplate, type TemplateShape } from \"./template-key-match.js\";\n\n/** A placeholder of a template literal type, by the type it stands for. */\nexport type PathPlaceholder = \"string\" | \"number\" | \"boolean\";\n\n/** One part of a path key: text, or a placeholder. */\nexport type PathKeyPart =\n  | { readonly kind: \"text\"; readonly text: string }\n  | { readonly kind: \"placeholder\"; readonly type: PathPlaceholder };\n\n/** A path key: a URL written as a property, or a template literal type of an index signature. */\nexport type PathKey =\n  | { readonly kind: \"literal\"; readonly url: string }\n  | { readonly kind: \"template\"; readonly parts: readonly PathKeyPart[] };\n\nconst BOOLEAN_TEXTS: readonly string[] = [\"true\", \"false\"];\n\n/** The shapes after one more part; a boolean placeholder doubles them, as TypeScript does. */\nfunction withPart(shapes: readonly TemplateShape[], part: PathKeyPart): TemplateShape[] {\n  return shapes.flatMap((shape): TemplateShape[] => {\n    const lead = shape.texts.slice(0, -1);\n    // A shape has one text more than it has placeholders, so it always has a last text.\n    const last = shape.texts[shape.texts.length - 1] as string;\n    if (part.kind === \"text\") {\n      return [{ texts: [...lead, last + part.text], types: shape.types }];\n    }\n    if (part.type === \"boolean\") {\n      return BOOLEAN_TEXTS.map((text) => ({ texts: [...lead, last + text], types: shape.types }));\n    }\n    return [{ texts: [...shape.texts, \"\"], types: [...shape.types, part.type] }];\n  });\n}\n\n/**\n * The key types TypeScript makes of a key: a literal is one text; a template is one shape, or a\n * union of shapes when `${boolean}` is in it (`` `/a/${boolean}` `` is `\"/a/true\" | \"/a/false\"`).\n */\nfunction shapesOf(key: PathKey): readonly TemplateShape[] {\n  if (key.kind === \"literal\") {\n    return [{ texts: [key.url], types: [] }];\n  }\n  return key.parts.reduce<TemplateShape[]>(withPart, [{ texts: [\"\"], types: [] }]);\n}\n\n/**\n * Whether a signature checks the covered key: every type of the covered key is assignable to one\n * of the signature's types. A shape without placeholders (a boolean-only template) is a string\n * literal, which is no signature, so the targets leave it out.\n */\nfunction isCoveredBy(\n  sources: readonly TemplateShape[],\n  targets: readonly TemplateShape[],\n): boolean {\n  return (\n    sources.length > 0 &&\n    sources.every((source) => targets.some((target) => isAssignableToTemplate(source, target)))\n  );\n}\n\n/** Whether TypeScript rejects the key at `covered` for the signature at `covering`. */\nexport type CoverRejection = (covering: number, covered: number) => boolean;\n\n/** Without type information every covered key counts. */\nconst EVERY_COVER_REJECTED: CoverRejection = () => true;\n\n/**\n * The key types TypeScript checks against a signature: a literal's, or a template's signature\n * types. A boolean-only template is no signature (TS1337), so the checker neither checks it nor\n * checks anything against it; a repeated one is still reported (TS2374, see `repeatedTemplates`).\n */\nfunction checkedShapes(key: PathKey): readonly TemplateShape[] {\n  const shapes = shapesOf(key);\n  return key.kind === \"literal\" ? shapes : shapes.filter((shape) => shape.types.length > 0);\n}\n\n/** A checked key: the key, the shapes TypeScript checks, and its template identity. */\ninterface CheckedKey {\n  readonly key: PathKey;\n  readonly shapes: readonly TemplateShape[];\n  /** The key types written as one string, for templates; null for a literal. */\n  readonly template: string | null;\n}\n\nfunction checkedKeyOf(key: PathKey): CheckedKey {\n  const template = key.kind === \"template\" ? JSON.stringify(shapesOf(key)) : null;\n  return { key, shapes: checkedShapes(key), template };\n}\n\n/**\n * The templates written more than once, as paths that differ only in parameter names give\n * (`/a/{id}`, `/a/{name}`). OpenAPI forbids such paths, and one object with both signatures fails\n * to compile whatever their types (TS2374), so each always counts as covering the other.\n */\nfunction repeatedTemplates(checked: readonly CheckedKey[]): ReadonlySet<string> {\n  const seen = new Set<string>();\n  const repeated = new Set<string>();\n  for (const { template } of checked) {\n    if (template !== null) {\n      (seen.has(template) ? repeated : seen).add(template);\n    }\n  }\n  return repeated;\n}\n\n/**\n * The checked keys by the first text of each of their shapes, sorted. A key type is assignable to\n * a template only when its first text starts with the template's first text (both branches of\n * `isAssignableToTemplate`), so the keys a template can cover are one run of this list. Without\n * it the check compares every pair of keys, which takes minutes for 10 000 paths.\n */\ninterface StartTextIndex {\n  readonly starts: readonly string[];\n  readonly keyIndexes: readonly number[];\n}\n\n/** Code unit order: in it the strings that start with one prefix are adjacent. */\nfunction compareCodeUnits(left: string, right: string): number {\n  if (left === right) {\n    return 0;\n  }\n  return left < right ? -1 : 1;\n}\n\nfunction startTextIndexOf(checked: readonly CheckedKey[]): StartTextIndex {\n  const entries = checked.flatMap(({ shapes }, keyIndex) =>\n    shapes.map((shape) => ({ start: shape.texts[0] as string, keyIndex })),\n  );\n  entries.sort((left, right) => compareCodeUnits(left.start, right.start));\n  return {\n    starts: entries.map((entry) => entry.start),\n    keyIndexes: entries.map((entry) => entry.keyIndex),\n  };\n}\n\n/** The indexes of the keys with a shape whose first text starts with one of the prefixes. */\nfunction keysStartingWith(index: StartTextIndex, prefixes: readonly string[]): Set<number> {\n  const found = new Set<number>();\n  for (const prefix of prefixes) {\n    let low = 0;\n    let high = index.starts.length;\n    while (low < high) {\n      const middle = (low + high) >> 1;\n      if ((index.starts[middle] as string) < prefix) {\n        low = middle + 1;\n      } else {\n        high = middle;\n      }\n    }\n    for (let at = low; at < index.starts.length; at += 1) {\n      if (!(index.starts[at] as string).startsWith(prefix)) {\n        break;\n      }\n      found.add(index.keyIndexes[at] as number);\n    }\n  }\n  return found;\n}\n\n/**\n * The indexes of the template keys that cover another key of the list, where it is rejected, or\n * that repeat another template key. A template covers the keys TypeScript checks against it, the\n * ones its own matching accepts (see `template-key-match.ts`), not every string it stands for:\n * `` `/a/b/${number}` `` is no `` `/${string}/${number}` `` to the checker, which does not\n * backtrack, so that pair is never checked.\n */\nexport function coveringTemplateKeys(\n  keys: readonly PathKey[],\n  isRejected: CoverRejection = EVERY_COVER_REJECTED,\n): ReadonlySet<number> {\n  const checked = keys.map(checkedKeyOf);\n  const repeated = repeatedTemplates(checked);\n  const startTexts = startTextIndexOf(checked);\n  const covering = new Set<number>();\n  checked.forEach(({ template, shapes: targets }, index) => {\n    if (template === null) {\n      return;\n    }\n    const prefixes = targets.map((target) => target.texts[0] as string);\n    const candidates = [...keysStartingWith(startTexts, prefixes)].sort((a, b) => a - b);\n    const isCovering =\n      repeated.has(template) ||\n      candidates.some(\n        (otherIndex) =>\n          otherIndex !== index &&\n          isCoveredBy((checked[otherIndex] as CheckedKey).shapes, targets) &&\n          isRejected(index, otherIndex),\n      );\n    if (isCovering) {\n      covering.add(index);\n    }\n  });\n  return covering;\n}\n"],"names":[],"mappings":"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"}

package/dist/application/transform/document/path-template-replace.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+const URL_TEXT = null;
+function placeholderText(type) {
+  return `\${${type}}`;
+}
+function replacedUnits(url, matches) {
+  const units = url.split("").map((unit) => ({ unit, owner: URL_TEXT }));
+  matches.forEach(({ match, type }, owner) => {
+    const at = units.map(({ unit }) => unit).join("").indexOf(match);
+    if (at >= 0) {
+      const inserted = placeholderText(type).split("").map((unit) => ({ unit, owner }));
+      units.splice(at, match.length, ...inserted);
+    }
+  });
+  return units;
+}
+function intactPlaceholders(units, matches) {
+  const intact = /* @__PURE__ */ new Map();
+  matches.forEach(({ type }, owner) => {
+    const left = units.filter((unit) => unit.owner === owner).length;
+    if (left === placeholderText(type).length) {
+      intact.set(owner, type);
+    }
+  });
+  return intact;
+}
+function replacedTemplateParts(url, matches) {
+  const units = replacedUnits(url, matches);
+  const intact = intactPlaceholders(units, matches);
+  const parts = [];
+  let text = "";
+  units.forEach(({ unit, owner }, index) => {
+    const type = owner === URL_TEXT ? void 0 : intact.get(owner);
+    if (type === void 0) {
+      text += unit;
+    } else if (units[index - 1]?.owner !== owner) {
+      parts.push({ kind: "text", text }, { kind: "placeholder", type });
+      text = "";
+    }
+  });
+  parts.push({ kind: "text", text });
+  return parts;
+}
+
+exports.placeholderText = placeholderText;
+exports.replacedTemplateParts = replacedTemplateParts;
+//# sourceMappingURL=path-template-replace.cjs.map

package/dist/application/transform/document/path-template-replace.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-template-replace.cjs","sources":["../../../../src/application/transform/document/path-template-replace.ts"],"sourcesContent":["import type { PathKeyPart, PathPlaceholder } from \"./path-key-overlaps.js\";\n\n/**\n * The `--path-params-as-types` key as the original builds it: each `{name}` match, in URL order,\n * replaces the first occurrence of its text in the key so far. A parameter named `number`,\n * `string` or `boolean` can so hit the `${number}` an earlier parameter got: of\n * `/a/{id}/b/{number}` the original makes `/a/$${number}/b/{number}`. That output compiles, so it\n * stays the default (ADR-021); the `path-param-type-names` fix gives every match its own\n * placeholder.\n */\n\n/** One `{name}` of the URL and the placeholder of its parameter's type. */\nexport interface PathParameterMatch {\n  readonly match: string;\n  readonly type: PathPlaceholder;\n}\n\n/**\n * One UTF-16 code unit of the key so far (`indexOf` counts those): URL text, or a unit of the\n * placeholder that the match at `owner` inserted.\n */\ninterface KeyUnit {\n  readonly unit: string;\n  readonly owner: number | null;\n}\n\nconst URL_TEXT = null;\n\n/** `${type}`: the text of a template literal type placeholder. */\nexport function placeholderText(type: PathPlaceholder): string {\n  return `\\${${type}}`;\n}\n\n/** The key's units after each match replaced the first occurrence of its text. */\nfunction replacedUnits(url: string, matches: readonly PathParameterMatch[]): readonly KeyUnit[] {\n  const units: KeyUnit[] = url.split(\"\").map((unit) => ({ unit, owner: URL_TEXT }));\n  matches.forEach(({ match, type }, owner) => {\n    const at = units\n      .map(({ unit }) => unit)\n      .join(\"\")\n      .indexOf(match);\n    if (at >= 0) {\n      const inserted = placeholderText(type)\n        .split(\"\")\n        .map((unit) => ({ unit, owner }));\n      units.splice(at, match.length, ...inserted);\n    }\n  });\n  return units;\n}\n\n/** The placeholders, by match, that no later match cut into. */\nfunction intactPlaceholders(\n  units: readonly KeyUnit[],\n  matches: readonly PathParameterMatch[],\n): ReadonlyMap<number, PathPlaceholder> {\n  const intact = new Map<number, PathPlaceholder>();\n  matches.forEach(({ type }, owner) => {\n    const left = units.filter((unit) => unit.owner === owner).length;\n    if (left === placeholderText(type).length) {\n      intact.set(owner, type);\n    }\n  });\n  return intact;\n}\n\n/**\n * The key as parts. What is left of a placeholder that a later match cut into (the `$` of\n * `$${number}`) is text, as TypeScript reads it.\n */\nexport function replacedTemplateParts(\n  url: string,\n  matches: readonly PathParameterMatch[],\n): PathKeyPart[] {\n  const units = replacedUnits(url, matches);\n  const intact = intactPlaceholders(units, matches);\n  const parts: PathKeyPart[] = [];\n  let text = \"\";\n  units.forEach(({ unit, owner }, index) => {\n    const type = owner === URL_TEXT ? undefined : intact.get(owner);\n    if (type === undefined) {\n      text += unit;\n    } else if (units[index - 1]?.owner !== owner) {\n      parts.push({ kind: \"text\", text }, { kind: \"placeholder\", type });\n      text = \"\";\n    }\n  });\n  parts.push({ kind: \"text\", text });\n  return parts;\n}\n"],"names":[],"mappings":";;AA0BA,MAAM,QAAA,GAAW,IAAA;AAGV,SAAS,gBAAgB,IAAA,EAA+B;AAC7D,EAAA,OAAO,MAAM,IAAI,CAAA,CAAA,CAAA;AACnB;AAGA,SAAS,aAAA,CAAc,KAAa,OAAA,EAA4D;AAC9F,EAAA,MAAM,KAAA,GAAmB,GAAA,CAAI,KAAA,CAAM,EAAE,CAAA,CAAE,GAAA,CAAI,CAAC,IAAA,MAAU,EAAE,IAAA,EAAM,KAAA,EAAO,QAAA,EAAS,CAAE,CAAA;AAChF,EAAA,OAAA,CAAQ,QAAQ,CAAC,EAAE,KAAA,EAAO,IAAA,IAAQ,KAAA,KAAU;AAC1C,IAAA,MAAM,EAAA,GAAK,KAAA,CACR,GAAA,CAAI,CAAC,EAAE,IAAA,EAAK,KAAM,IAAI,CAAA,CACtB,IAAA,CAAK,EAAE,CAAA,CACP,QAAQ,KAAK,CAAA;AAChB,IAAA,IAAI,MAAM,CAAA,EAAG;AACX,MAAA,MAAM,QAAA,GAAW,eAAA,CAAgB,IAAI,CAAA,CAClC,KAAA,CAAM,EAAE,CAAA,CACR,GAAA,CAAI,CAAC,IAAA,MAAU,EAAE,IAAA,EAAM,OAAM,CAAE,CAAA;AAClC,MAAA,KAAA,CAAM,MAAA,CAAO,EAAA,EAAI,KAAA,CAAM,MAAA,EAAQ,GAAG,QAAQ,CAAA;AAAA,IAC5C;AAAA,EACF,CAAC,CAAA;AACD,EAAA,OAAO,KAAA;AACT;AAGA,SAAS,kBAAA,CACP,OACA,OAAA,EACsC;AACtC,EAAA,MAAM,MAAA,uBAAa,GAAA,EAA6B;AAChD,EAAA,OAAA,CAAQ,OAAA,CAAQ,CAAC,EAAE,IAAA,IAAQ,KAAA,KAAU;AACnC,IAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,CAAC,SAAS,IAAA,CAAK,KAAA,KAAU,KAAK,CAAA,CAAE,MAAA;AAC1D,IAAA,IAAI,IAAA,KAAS,eAAA,CAAgB,IAAI,CAAA,CAAE,MAAA,EAAQ;AACzC,MAAA,MAAA,CAAO,GAAA,CAAI,OAAO,IAAI,CAAA;AAAA,IACxB;AAAA,EACF,CAAC,CAAA;AACD,EAAA,OAAO,MAAA;AACT;AAMO,SAAS,qBAAA,CACd,KACA,OAAA,EACe;AACf,EAAA,MAAM,KAAA,GAAQ,aAAA,CAAc,GAAA,EAAK,OAAO,CAAA;AACxC,EAAA,MAAM,MAAA,GAAS,kBAAA,CAAmB,KAAA,EAAO,OAAO,CAAA;AAChD,EAAA,MAAM,QAAuB,EAAC;AAC9B,EAAA,IAAI,IAAA,GAAO,EAAA;AACX,EAAA,KAAA,CAAM,QAAQ,CAAC,EAAE,IAAA,EAAM,KAAA,IAAS,KAAA,KAAU;AACxC,IAAA,MAAM,OAAO,KAAA,KAAU,QAAA,GAAW,MAAA,GAAY,MAAA,CAAO,IAAI,KAAK,CAAA;AAC9D,IAAA,IAAI,SAAS,MAAA,EAAW;AACtB,MAAA,IAAA,IAAQ,IAAA;AAAA,IACV,WAAW,KAAA,CAAM,KAAA,GAAQ,CAAC,CAAA,EAAG,UAAU,KAAA,EAAO;AAC5C,MAAA,KAAA,CAAM,IAAA,CAAK,EAAE,IAAA,EAAM,MAAA,EAAQ,IAAA,IAAQ,EAAE,IAAA,EAAM,aAAA,EAAe,IAAA,EAAM,CAAA;AAChE,MAAA,IAAA,GAAO,EAAA;AAAA,IACT;AAAA,EACF,CAAC,CAAA;AACD,EAAA,KAAA,CAAM,IAAA,CAAK,EAAE,IAAA,EAAM,MAAA,EAAQ,MAAM,CAAA;AACjC,EAAA,OAAO,KAAA;AACT;;;"}

package/dist/application/transform/document/path-template-replace.mjs

@@ -0,0 +1,45 @@
+const URL_TEXT = null;
+function placeholderText(type) {
+  return `\${${type}}`;
+}
+function replacedUnits(url, matches) {
+  const units = url.split("").map((unit) => ({ unit, owner: URL_TEXT }));
+  matches.forEach(({ match, type }, owner) => {
+    const at = units.map(({ unit }) => unit).join("").indexOf(match);
+    if (at >= 0) {
+      const inserted = placeholderText(type).split("").map((unit) => ({ unit, owner }));
+      units.splice(at, match.length, ...inserted);
+    }
+  });
+  return units;
+}
+function intactPlaceholders(units, matches) {
+  const intact = /* @__PURE__ */ new Map();
+  matches.forEach(({ type }, owner) => {
+    const left = units.filter((unit) => unit.owner === owner).length;
+    if (left === placeholderText(type).length) {
+      intact.set(owner, type);
+    }
+  });
+  return intact;
+}
+function replacedTemplateParts(url, matches) {
+  const units = replacedUnits(url, matches);
+  const intact = intactPlaceholders(units, matches);
+  const parts = [];
+  let text = "";
+  units.forEach(({ unit, owner }, index) => {
+    const type = owner === URL_TEXT ? void 0 : intact.get(owner);
+    if (type === void 0) {
+      text += unit;
+    } else if (units[index - 1]?.owner !== owner) {
+      parts.push({ kind: "text", text }, { kind: "placeholder", type });
+      text = "";
+    }
+  });
+  parts.push({ kind: "text", text });
+  return parts;
+}
+
+export { placeholderText, replacedTemplateParts };
+//# sourceMappingURL=path-template-replace.mjs.map

package/dist/application/transform/document/path-template-replace.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-template-replace.mjs","sources":["../../../../src/application/transform/document/path-template-replace.ts"],"sourcesContent":["import type { PathKeyPart, PathPlaceholder } from \"./path-key-overlaps.js\";\n\n/**\n * The `--path-params-as-types` key as the original builds it: each `{name}` match, in URL order,\n * replaces the first occurrence of its text in the key so far. A parameter named `number`,\n * `string` or `boolean` can so hit the `${number}` an earlier parameter got: of\n * `/a/{id}/b/{number}` the original makes `/a/$${number}/b/{number}`. That output compiles, so it\n * stays the default (ADR-021); the `path-param-type-names` fix gives every match its own\n * placeholder.\n */\n\n/** One `{name}` of the URL and the placeholder of its parameter's type. */\nexport interface PathParameterMatch {\n  readonly match: string;\n  readonly type: PathPlaceholder;\n}\n\n/**\n * One UTF-16 code unit of the key so far (`indexOf` counts those): URL text, or a unit of the\n * placeholder that the match at `owner` inserted.\n */\ninterface KeyUnit {\n  readonly unit: string;\n  readonly owner: number | null;\n}\n\nconst URL_TEXT = null;\n\n/** `${type}`: the text of a template literal type placeholder. */\nexport function placeholderText(type: PathPlaceholder): string {\n  return `\\${${type}}`;\n}\n\n/** The key's units after each match replaced the first occurrence of its text. */\nfunction replacedUnits(url: string, matches: readonly PathParameterMatch[]): readonly KeyUnit[] {\n  const units: KeyUnit[] = url.split(\"\").map((unit) => ({ unit, owner: URL_TEXT }));\n  matches.forEach(({ match, type }, owner) => {\n    const at = units\n      .map(({ unit }) => unit)\n      .join(\"\")\n      .indexOf(match);\n    if (at >= 0) {\n      const inserted = placeholderText(type)\n        .split(\"\")\n        .map((unit) => ({ unit, owner }));\n      units.splice(at, match.length, ...inserted);\n    }\n  });\n  return units;\n}\n\n/** The placeholders, by match, that no later match cut into. */\nfunction intactPlaceholders(\n  units: readonly KeyUnit[],\n  matches: readonly PathParameterMatch[],\n): ReadonlyMap<number, PathPlaceholder> {\n  const intact = new Map<number, PathPlaceholder>();\n  matches.forEach(({ type }, owner) => {\n    const left = units.filter((unit) => unit.owner === owner).length;\n    if (left === placeholderText(type).length) {\n      intact.set(owner, type);\n    }\n  });\n  return intact;\n}\n\n/**\n * The key as parts. What is left of a placeholder that a later match cut into (the `$` of\n * `$${number}`) is text, as TypeScript reads it.\n */\nexport function replacedTemplateParts(\n  url: string,\n  matches: readonly PathParameterMatch[],\n): PathKeyPart[] {\n  const units = replacedUnits(url, matches);\n  const intact = intactPlaceholders(units, matches);\n  const parts: PathKeyPart[] = [];\n  let text = \"\";\n  units.forEach(({ unit, owner }, index) => {\n    const type = owner === URL_TEXT ? undefined : intact.get(owner);\n    if (type === undefined) {\n      text += unit;\n    } else if (units[index - 1]?.owner !== owner) {\n      parts.push({ kind: \"text\", text }, { kind: \"placeholder\", type });\n      text = \"\";\n    }\n  });\n  parts.push({ kind: \"text\", text });\n  return parts;\n}\n"],"names":[],"mappings":"AA0BA,MAAM,QAAA,GAAW,IAAA;AAGV,SAAS,gBAAgB,IAAA,EAA+B;AAC7D,EAAA,OAAO,MAAM,IAAI,CAAA,CAAA,CAAA;AACnB;AAGA,SAAS,aAAA,CAAc,KAAa,OAAA,EAA4D;AAC9F,EAAA,MAAM,KAAA,GAAmB,GAAA,CAAI,KAAA,CAAM,EAAE,CAAA,CAAE,GAAA,CAAI,CAAC,IAAA,MAAU,EAAE,IAAA,EAAM,KAAA,EAAO,QAAA,EAAS,CAAE,CAAA;AAChF,EAAA,OAAA,CAAQ,QAAQ,CAAC,EAAE,KAAA,EAAO,IAAA,IAAQ,KAAA,KAAU;AAC1C,IAAA,MAAM,EAAA,GAAK,KAAA,CACR,GAAA,CAAI,CAAC,EAAE,IAAA,EAAK,KAAM,IAAI,CAAA,CACtB,IAAA,CAAK,EAAE,CAAA,CACP,QAAQ,KAAK,CAAA;AAChB,IAAA,IAAI,MAAM,CAAA,EAAG;AACX,MAAA,MAAM,QAAA,GAAW,eAAA,CAAgB,IAAI,CAAA,CAClC,KAAA,CAAM,EAAE,CAAA,CACR,GAAA,CAAI,CAAC,IAAA,MAAU,EAAE,IAAA,EAAM,OAAM,CAAE,CAAA;AAClC,MAAA,KAAA,CAAM,MAAA,CAAO,EAAA,EAAI,KAAA,CAAM,MAAA,EAAQ,GAAG,QAAQ,CAAA;AAAA,IAC5C;AAAA,EACF,CAAC,CAAA;AACD,EAAA,OAAO,KAAA;AACT;AAGA,SAAS,kBAAA,CACP,OACA,OAAA,EACsC;AACtC,EAAA,MAAM,MAAA,uBAAa,GAAA,EAA6B;AAChD,EAAA,OAAA,CAAQ,OAAA,CAAQ,CAAC,EAAE,IAAA,IAAQ,KAAA,KAAU;AACnC,IAAA,MAAM,IAAA,GAAO,MAAM,MAAA,CAAO,CAAC,SAAS,IAAA,CAAK,KAAA,KAAU,KAAK,CAAA,CAAE,MAAA;AAC1D,IAAA,IAAI,IAAA,KAAS,eAAA,CAAgB,IAAI,CAAA,CAAE,MAAA,EAAQ;AACzC,MAAA,MAAA,CAAO,GAAA,CAAI,OAAO,IAAI,CAAA;AAAA,IACxB;AAAA,EACF,CAAC,CAAA;AACD,EAAA,OAAO,MAAA;AACT;AAMO,SAAS,qBAAA,CACd,KACA,OAAA,EACe;AACf,EAAA,MAAM,KAAA,GAAQ,aAAA,CAAc,GAAA,EAAK,OAAO,CAAA;AACxC,EAAA,MAAM,MAAA,GAAS,kBAAA,CAAmB,KAAA,EAAO,OAAO,CAAA;AAChD,EAAA,MAAM,QAAuB,EAAC;AAC9B,EAAA,IAAI,IAAA,GAAO,EAAA;AACX,EAAA,KAAA,CAAM,QAAQ,CAAC,EAAE,IAAA,EAAM,KAAA,IAAS,KAAA,KAAU;AACxC,IAAA,MAAM,OAAO,KAAA,KAAU,QAAA,GAAW,MAAA,GAAY,MAAA,CAAO,IAAI,KAAK,CAAA;AAC9D,IAAA,IAAI,SAAS,MAAA,EAAW;AACtB,MAAA,IAAA,IAAQ,IAAA;AAAA,IACV,WAAW,KAAA,CAAM,KAAA,GAAQ,CAAC,CAAA,EAAG,UAAU,KAAA,EAAO;AAC5C,MAAA,KAAA,CAAM,IAAA,CAAK,EAAE,IAAA,EAAM,MAAA,EAAQ,IAAA,IAAQ,EAAE,IAAA,EAAM,aAAA,EAAe,IAAA,EAAM,CAAA;AAChE,MAAA,IAAA,GAAO,EAAA;AAAA,IACT;AAAA,EACF,CAAC,CAAA;AACD,EAAA,KAAA,CAAM,IAAA,CAAK,EAAE,IAAA,EAAM,MAAA,EAAQ,MAAM,CAAA;AACjC,EAAA,OAAO,KAAA;AACT;;"}

package/dist/application/transform/document/paths.cjs

@@ -5,23 +5,23 @@ const propertyName = require('../../../domain/ir/property-name.cjs');
 const rawTextEscapes = require('../../../domain/ir/raw-text-escapes.cjs');
 const jsonPointer = require('../../../domain/openapi/json-pointer.cjs');
 const pathItemObject = require('../../../domain/openapi/path-item-object.cjs');
+const outputFixes = require('../../../domain/output-fixes.cjs');
 const documentEntries = require('../document-entries.cjs');
 const refType = require('../ref-type.cjs');
+const declaredTypes = require('./declared-types.cjs');
 const documentMember = require('./document-member.cjs');
 const pathItem = require('./path-item.cjs');
-const pathItemConflicts = require('./path-item-conflicts.cjs');
 const pathKeyOverlaps = require('./path-key-overlaps.cjs');
+const pathTemplateReplace = require('./path-template-replace.cjs');
+const typeAssignability = require('./type-assignability.cjs');
 
-const PATH_PARAMETER_RE = /\{[^}]+\}/g;
+const PATH_PARAMETER_RE = /\{[^{}]+\}/g;
 const PLACEHOLDERS = /* @__PURE__ */ new Map([
   ["number", "number"],
   ["integer", "number"],
   ["boolean", "boolean"]
 ]);
 const STRING_PLACEHOLDER = "string";
-function placeholderText(type) {
-  return `\${${type}}`;
-}
 function resolvedParameter(parameter, context) {
   return "$ref" in parameter && parameter.$ref ? context.refs.resolve(parameter.$ref) : parameter;
 }
@@ -42,25 +42,28 @@ function pathParameters(pathItem, context) {
   }
   return byName;
 }
+function splitTemplateParts(url, matches) {
+  return url.split(PATH_PARAMETER_RE).flatMap((text, index) => {
+    const type = matches[index]?.type;
+    const textPart = { kind: "text", text };
+    return type === void 0 ? [textPart] : [textPart, { kind: "placeholder", type }];
+  });
+}
 function pathTemplateParts(url, pathItem, context) {
-  const matches = url.match(PATH_PARAMETER_RE);
-  if (!matches) {
+  const found = url.match(PATH_PARAMETER_RE);
+  if (!found) {
     return null;
   }
   const parameters = pathParameters(pathItem, context);
-  const placeholders = matches.map((match) => {
+  const matches = found.map((match) => {
     const schema = parameters.get(match.slice(1, -1))?.schema;
-    return PLACEHOLDERS.get(schema?.type) ?? STRING_PLACEHOLDER;
-  });
-  return url.split(PATH_PARAMETER_RE).flatMap((text, index) => {
-    const type = placeholders[index];
-    const textPart = { kind: "text", text };
-    return type === void 0 ? [textPart] : [textPart, { kind: "placeholder", type }];
+    return { match, type: PLACEHOLDERS.get(schema?.type) ?? STRING_PLACEHOLDER };
   });
+  return context.options.fixes.has(outputFixes.OutputFix.PATH_PARAM_TYPE_NAMES) ? splitTemplateParts(url, matches) : pathTemplateReplace.replacedTemplateParts(url, matches);
 }
 function templateText(parts) {
   const text = parts.map(
-    (part) => part.kind === "text" ? rawTextEscapes.escapeTemplateText(part.text) : placeholderText(part.type)
+    (part) => part.kind === "text" ? rawTextEscapes.escapeTemplateText(part.text) : pathTemplateReplace.placeholderText(part.type)
   ).join("");
   return `\`${text}\``;
 }
@@ -70,7 +73,7 @@ function pathItemMember(url, pathItem$1, context) {
   const parts = context.options.pathParamsAsTypes && url.includes("{") ? pathTemplateParts(url, pathItem$1, context) : null;
   if (parts === null) {
     const member2 = constructors.irProperty(propertyName.toPropertyName(url), type, { isReadonly });
-    return { member: member2, key: literalKey(url), type };
+    return { url, member: member2, key: literalKey(url), type };
   }
   const member = {
     kind: "indexSignature",
@@ -80,20 +83,38 @@ function pathItemMember(url, pathItem$1, context) {
     isReadonly,
     comments: []
   };
-  return { member, key: { kind: "template", parts }, type };
+  return { url, member, key: { kind: "template", parts }, type };
 }
 function literalKey(url) {
   return { kind: "literal", url };
 }
-function pathsObjectType(paths) {
-  const covering = pathKeyOverlaps.coveringTemplateKeys(
-    paths.map(({ key }) => key),
-    (coveringIndex, coveredIndex) => {
-      const coveringPath = paths[coveringIndex];
-      const coveredPath = paths[coveredIndex];
-      return coveringPath !== void 0 && coveredPath !== void 0 && pathItemConflicts.isCoveredPathItemRejected(coveredPath.type, coveringPath.type);
-    }
-  );
+const PATHS_TYPE_NAME = "paths";
+function pathsIndexOf(type) {
+  if (type.kind !== "indexedAccess" || type.index.kind !== "stringLiteral") {
+    return null;
+  }
+  const { object } = type;
+  const isPaths = object.kind === "reference" && object.name === PATHS_TYPE_NAME && object.typeArguments.length === 0;
+  return isPaths ? type.index.value : null;
+}
+function withPathItems(paths, lookup) {
+  const byUrl = new Map(paths.map((path) => [path.url, path.type]));
+  return (type) => {
+    const url = pathsIndexOf(type);
+    return (url === null ? void 0 : byUrl.get(url)) ?? lookup(type);
+  };
+}
+function rejectionOf(paths, lookup) {
+  const relate = typeAssignability.assignabilityProof(withPathItems(paths, lookup));
+  return (coveringIndex, coveredIndex) => {
+    const coveringPath = paths[coveringIndex];
+    const coveredPath = paths[coveredIndex];
+    return coveringPath !== void 0 && coveredPath !== void 0 && relate(coveredPath.type, coveringPath.type) === "rejected";
+  };
+}
+function pathsObjectType(paths, lookup = declaredTypes.NO_DECLARED_TYPES) {
+  const keys = paths.map(({ key }) => key);
+  const covering = pathKeyOverlaps.coveringTemplateKeys(keys, rejectionOf(paths, lookup));
   if (covering.size === 0) {
     return constructors.irObject(paths.map(({ member }) => member));
   }
@@ -101,7 +122,7 @@ function pathsObjectType(paths) {
   const own = paths.filter((_, index) => covering.has(index)).map(({ member }) => constructors.irObject([member]));
   return constructors.irIntersection([constructors.irObject(rest), ...own]);
 }
-function pathsType(paths, context) {
+function pathMembers(paths, context) {
   const members = [];
   for (const [url, pathItem] of documentEntries.documentEntries(paths, context.options)) {
     if (!pathItem || typeof pathItem !== "object") {
@@ -110,7 +131,7 @@ function pathsType(paths, context) {
     if ("$ref" in pathItem) {
       const options = { isReadonly: context.options.immutable };
       const member = documentMember.documentMember(url, refType.refType(pathItem.$ref), pathItem, options);
-      members.push({ member, key: literalKey(url), type: member.type });
+      members.push({ url, member, key: literalKey(url), type: member.type });
       continue;
     }
     const startedAt = context.diagnostics.now();
@@ -120,8 +141,13 @@ function pathsType(paths, context) {
       context.diagnostics.debug(`Transformed path "${url}"`, context.diagnostics.now() - startedAt);
     }
   }
-  return pathsObjectType(members);
+  return members;
+}
+function pathsType(paths, context) {
+  return pathsObjectType(pathMembers(paths, context));
 }
 
+exports.pathMembers = pathMembers;
+exports.pathsObjectType = pathsObjectType;
 exports.pathsType = pathsType;
 //# sourceMappingURL=paths.cjs.map

package/dist/application/transform/document/paths.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"paths.cjs","sources":["../../../../src/application/transform/document/paths.ts"],"sourcesContent":["import { irIntersection, irObject, irProperty, irRaw } from \"../../../domain/ir/constructors.js\";\nimport type { IrMember, IrType } from \"../../../domain/ir/nodes.js\";\nimport { toPropertyName } from \"../../../domain/ir/property-name.js\";\nimport { escapeTemplateText } from \"../../../domain/ir/raw-text-escapes.js\";\nimport { createRef } from \"../../../domain/openapi/json-pointer.js\";\nimport type { OperationObject } from \"../../../domain/openapi/operation-object.js\";\nimport type {\n  ParameterObject,\n  ParameterOrReference,\n} from \"../../../domain/openapi/parameter-object.js\";\nimport {\n  type PathItemObject,\n  type PathsObject,\n  pathItemOperations,\n} from \"../../../domain/openapi/path-item-object.js\";\nimport type { ReferenceSchema, SchemaObject } from \"../../../domain/openapi/schema-object.js\";\nimport { documentEntries } from \"../document-entries.js\";\nimport { refType } from \"../ref-type.js\";\nimport type { TransformContext } from \"../transform-context.js\";\nimport { documentMember } from \"./document-member.js\";\nimport { pathItemType } from \"./path-item.js\";\nimport { isCoveredPathItemRejected } from \"./path-item-conflicts.js\";\nimport {\n  coveringTemplateKeys,\n  type PathKey,\n  type PathKeyPart,\n  type PathPlaceholder,\n} from \"./path-key-overlaps.js\";\n\nconst PATH_PARAMETER_RE = /\\{[^}]+\\}/g;\n\n/** Placeholders by parameter schema type; anything else is a string placeholder. */\nconst PLACEHOLDERS: ReadonlyMap<unknown, PathPlaceholder> = new Map([\n  [\"number\", \"number\"],\n  [\"integer\", \"number\"],\n  [\"boolean\", \"boolean\"],\n]);\nconst STRING_PLACEHOLDER: PathPlaceholder = \"string\";\n\n/** `${type}`: the text of a template literal type placeholder. */\nfunction placeholderText(type: PathPlaceholder): string {\n  return `\\${${type}}`;\n}\n\nfunction resolvedParameter(\n  parameter: ParameterOrReference,\n  context: TransformContext,\n): ParameterObject | undefined {\n  return \"$ref\" in parameter && parameter.$ref\n    ? (context.refs.resolve(parameter.$ref) as ParameterObject | undefined)\n    : (parameter as ParameterObject);\n}\n\nfunction addPathParameters(\n  parameters: readonly ParameterOrReference[],\n  byName: Map<string, ParameterObject>,\n  context: TransformContext,\n): void {\n  for (const parameter of parameters) {\n    const resolved = resolvedParameter(parameter, context);\n    if (resolved && resolved.in === \"path\") {\n      byName.set(resolved.name, resolved);\n    }\n  }\n}\n\n/** Path parameters of the path item and of its operations; later definitions win. */\nfunction pathParameters(\n  pathItem: PathItemObject,\n  context: TransformContext,\n): Map<string, ParameterObject> {\n  const byName = new Map<string, ParameterObject>();\n  addPathParameters(pathItem.parameters ?? [], byName, context);\n  for (const { operation: entry } of pathItemOperations(pathItem)) {\n    const operation = (entry as ReferenceSchema).$ref\n      ? (context.refs.resolve((entry as ReferenceSchema).$ref) as OperationObject | undefined)\n      : (entry as OperationObject);\n    addPathParameters(operation?.parameters ?? [], byName, context);\n  }\n  return byName;\n}\n\n/**\n * `--path-params-as-types`: the URL as template parts, each `{name}` replaced by a placeholder for\n * its parameter's type. Null when the URL has no complete `{…}` placeholder.\n */\nfunction pathTemplateParts(\n  url: string,\n  pathItem: PathItemObject,\n  context: TransformContext,\n): PathKeyPart[] | null {\n  const matches = url.match(PATH_PARAMETER_RE);\n  if (!matches) {\n    return null;\n  }\n  const parameters = pathParameters(pathItem, context);\n  const placeholders = matches.map((match) => {\n    const schema = parameters.get(match.slice(1, -1))?.schema as SchemaObject | undefined;\n    return PLACEHOLDERS.get(schema?.type) ?? STRING_PLACEHOLDER;\n  });\n  return url.split(PATH_PARAMETER_RE).flatMap((text, index): PathKeyPart[] => {\n    const type = placeholders[index];\n    const textPart: PathKeyPart = { kind: \"text\", text };\n    return type === undefined ? [textPart] : [textPart, { kind: \"placeholder\", type }];\n  });\n}\n\n/**\n * The template literal type of the parts. The original escaped only backticks: a backslash or\n * `${` in the URL could end the literal or open a placeholder, and add code to the generated file\n * (intentional fix). So the text parts are escaped.\n */\nfunction templateText(parts: readonly PathKeyPart[]): string {\n  const text = parts\n    .map((part) =>\n      part.kind === \"text\" ? escapeTemplateText(part.text) : placeholderText(part.type),\n    )\n    .join(\"\");\n  return `\\`${text}\\``;\n}\n\n/** A path's member, its key and its path item type for the overlap check. */\ninterface PathMember {\n  readonly member: IrMember;\n  readonly key: PathKey;\n  readonly type: IrType;\n}\n\nfunction pathItemMember(\n  url: string,\n  pathItem: PathItemObject,\n  context: TransformContext,\n): PathMember {\n  const isReadonly = context.options.immutable;\n  const type = pathItemType(pathItem, { path: createRef([\"paths\", url]) }, context);\n  const parts =\n    context.options.pathParamsAsTypes && url.includes(\"{\")\n      ? pathTemplateParts(url, pathItem, context)\n      : null;\n  if (parts === null) {\n    const member = irProperty(toPropertyName(url), type, { isReadonly });\n    return { member, key: literalKey(url), type };\n  }\n  const member: IrMember = {\n    kind: \"indexSignature\",\n    parameterName: \"path\",\n    parameterType: irRaw(templateText(parts)),\n    type,\n    isReadonly,\n    comments: [],\n  };\n  return { member, key: { kind: \"template\", parts }, type };\n}\n\nfunction literalKey(url: string): PathKey {\n  return { kind: \"literal\", url };\n}\n\n/**\n * The members as one object type. When an index signature covers another key, TypeScript checks\n * the covered key's type against it. Where that check surely fails (TS2411, TS2413), each such\n * signature gets an object of its own in an intersection: an intersection does not check its parts\n * against each other, and every key has the type it had in the one object. Output that compiles\n * keeps the one object.\n */\nfunction pathsObjectType(paths: readonly PathMember[]): IrType {\n  const covering = coveringTemplateKeys(\n    paths.map(({ key }) => key),\n    (coveringIndex, coveredIndex) => {\n      const coveringPath = paths[coveringIndex];\n      const coveredPath = paths[coveredIndex];\n      return (\n        coveringPath !== undefined &&\n        coveredPath !== undefined &&\n        isCoveredPathItemRejected(coveredPath.type, coveringPath.type)\n      );\n    },\n  );\n  if (covering.size === 0) {\n    return irObject(paths.map(({ member }) => member));\n  }\n  const rest = paths.filter((_, index) => !covering.has(index)).map(({ member }) => member);\n  const own = paths\n    .filter((_, index) => covering.has(index))\n    .map(({ member }) => irObject([member]));\n  return irIntersection([irObject(rest), ...own]);\n}\n\n/** The `paths` interface body (OpenAPI 3.1 §4.8.8): one member per path, by URL. */\nexport function pathsType(paths: PathsObject, context: TransformContext): IrType {\n  const members: PathMember[] = [];\n  for (const [url, pathItem] of documentEntries(paths, context.options)) {\n    if (!pathItem || typeof pathItem !== \"object\") {\n      continue;\n    }\n    if (\"$ref\" in pathItem) {\n      const options = { isReadonly: context.options.immutable };\n      const member = documentMember(url, refType(pathItem.$ref), pathItem, options);\n      members.push({ member, key: literalKey(url), type: member.type });\n      continue;\n    }\n    const startedAt = context.diagnostics.now();\n    const path = pathItemMember(url, pathItem, context);\n    members.push(path);\n    // The original reports only paths written as properties.\n    if (path.member.kind === \"property\") {\n      context.diagnostics.debug(`Transformed path \"${url}\"`, context.diagnostics.now() - startedAt);\n    }\n  }\n  return pathsObjectType(members);\n}\n"],"names":["pathItemOperations","escapeTemplateText","pathItem","pathItemType","createRef","member","irProperty","toPropertyName","irRaw","coveringTemplateKeys","isCoveredPathItemRejected","irObject","irIntersection","documentEntries","documentMember","refType"],"mappings":"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"}
+{"version":3,"file":"paths.cjs","sources":["../../../../src/application/transform/document/paths.ts"],"sourcesContent":["import { irIntersection, irObject, irProperty, irRaw } from \"../../../domain/ir/constructors.js\";\nimport type { IrMember, IrType } from \"../../../domain/ir/nodes.js\";\nimport { toPropertyName } from \"../../../domain/ir/property-name.js\";\nimport { escapeTemplateText } from \"../../../domain/ir/raw-text-escapes.js\";\nimport { createRef } from \"../../../domain/openapi/json-pointer.js\";\nimport type { OperationObject } from \"../../../domain/openapi/operation-object.js\";\nimport type {\n  ParameterObject,\n  ParameterOrReference,\n} from \"../../../domain/openapi/parameter-object.js\";\nimport {\n  type PathItemObject,\n  type PathsObject,\n  pathItemOperations,\n} from \"../../../domain/openapi/path-item-object.js\";\nimport type { ReferenceSchema, SchemaObject } from \"../../../domain/openapi/schema-object.js\";\nimport { OutputFix } from \"../../../domain/output-fixes.js\";\nimport { documentEntries } from \"../document-entries.js\";\nimport { refType } from \"../ref-type.js\";\nimport type { TransformContext } from \"../transform-context.js\";\nimport { type DeclaredTypeLookup, NO_DECLARED_TYPES } from \"./declared-types.js\";\nimport { documentMember } from \"./document-member.js\";\nimport { pathItemType } from \"./path-item.js\";\nimport {\n  type CoverRejection,\n  coveringTemplateKeys,\n  type PathKey,\n  type PathKeyPart,\n  type PathPlaceholder,\n} from \"./path-key-overlaps.js\";\nimport {\n  type PathParameterMatch,\n  placeholderText,\n  replacedTemplateParts,\n} from \"./path-template-replace.js\";\nimport { assignabilityProof } from \"./type-assignability.js\";\n\n/** `[^{}]` keeps the scan linear: `[^}]` retried from every `{` of a long run of them. */\nconst PATH_PARAMETER_RE = /\\{[^{}]+\\}/g;\n\n/** Placeholders by parameter schema type; anything else is a string placeholder. */\nconst PLACEHOLDERS: ReadonlyMap<unknown, PathPlaceholder> = new Map([\n  [\"number\", \"number\"],\n  [\"integer\", \"number\"],\n  [\"boolean\", \"boolean\"],\n]);\nconst STRING_PLACEHOLDER: PathPlaceholder = \"string\";\n\nfunction resolvedParameter(\n  parameter: ParameterOrReference,\n  context: TransformContext,\n): ParameterObject | undefined {\n  return \"$ref\" in parameter && parameter.$ref\n    ? (context.refs.resolve(parameter.$ref) as ParameterObject | undefined)\n    : (parameter as ParameterObject);\n}\n\nfunction addPathParameters(\n  parameters: readonly ParameterOrReference[],\n  byName: Map<string, ParameterObject>,\n  context: TransformContext,\n): void {\n  for (const parameter of parameters) {\n    const resolved = resolvedParameter(parameter, context);\n    if (resolved && resolved.in === \"path\") {\n      byName.set(resolved.name, resolved);\n    }\n  }\n}\n\n/** Path parameters of the path item and of its operations; later definitions win. */\nfunction pathParameters(\n  pathItem: PathItemObject,\n  context: TransformContext,\n): Map<string, ParameterObject> {\n  const byName = new Map<string, ParameterObject>();\n  addPathParameters(pathItem.parameters ?? [], byName, context);\n  for (const { operation: entry } of pathItemOperations(pathItem)) {\n    const operation = (entry as ReferenceSchema).$ref\n      ? (context.refs.resolve((entry as ReferenceSchema).$ref) as OperationObject | undefined)\n      : (entry as OperationObject);\n    addPathParameters(operation?.parameters ?? [], byName, context);\n  }\n  return byName;\n}\n\n/** Each `{name}` of the URL and its own placeholder, from the URL split at the matches. */\nfunction splitTemplateParts(url: string, matches: readonly PathParameterMatch[]): PathKeyPart[] {\n  return url.split(PATH_PARAMETER_RE).flatMap((text, index): PathKeyPart[] => {\n    const type = matches[index]?.type;\n    const textPart: PathKeyPart = { kind: \"text\", text };\n    return type === undefined ? [textPart] : [textPart, { kind: \"placeholder\", type }];\n  });\n}\n\n/**\n * `--path-params-as-types`: the URL as template parts, each `{name}` replaced by a placeholder for\n * its parameter's type, the way the original replaces them unless the `path-param-type-names` fix\n * is on (see `replacedTemplateParts`). Null when the URL has no complete `{…}` placeholder.\n */\nfunction pathTemplateParts(\n  url: string,\n  pathItem: PathItemObject,\n  context: TransformContext,\n): PathKeyPart[] | null {\n  const found = url.match(PATH_PARAMETER_RE);\n  if (!found) {\n    return null;\n  }\n  const parameters = pathParameters(pathItem, context);\n  const matches = found.map((match): PathParameterMatch => {\n    const schema = parameters.get(match.slice(1, -1))?.schema as SchemaObject | undefined;\n    return { match, type: PLACEHOLDERS.get(schema?.type) ?? STRING_PLACEHOLDER };\n  });\n  return context.options.fixes.has(OutputFix.PATH_PARAM_TYPE_NAMES)\n    ? splitTemplateParts(url, matches)\n    : replacedTemplateParts(url, matches);\n}\n\n/**\n * The template literal type of the parts. The original escaped only backticks: a backslash or\n * `${` in the URL could end the literal or open a placeholder, and add code to the generated file\n * (intentional fix). So the text parts are escaped.\n */\nfunction templateText(parts: readonly PathKeyPart[]): string {\n  const text = parts\n    .map((part) =>\n      part.kind === \"text\" ? escapeTemplateText(part.text) : placeholderText(part.type),\n    )\n    .join(\"\");\n  return `\\`${text}\\``;\n}\n\n/** A path's member, its key and its path item type for the overlap check. */\nexport interface PathMember {\n  readonly url: string;\n  readonly member: IrMember;\n  readonly key: PathKey;\n  readonly type: IrType;\n}\n\nfunction pathItemMember(\n  url: string,\n  pathItem: PathItemObject,\n  context: TransformContext,\n): PathMember {\n  const isReadonly = context.options.immutable;\n  const type = pathItemType(pathItem, { path: createRef([\"paths\", url]) }, context);\n  const parts =\n    context.options.pathParamsAsTypes && url.includes(\"{\")\n      ? pathTemplateParts(url, pathItem, context)\n      : null;\n  if (parts === null) {\n    const member = irProperty(toPropertyName(url), type, { isReadonly });\n    return { url, member, key: literalKey(url), type };\n  }\n  const member: IrMember = {\n    kind: \"indexSignature\",\n    parameterName: \"path\",\n    parameterType: irRaw(templateText(parts)),\n    type,\n    isReadonly,\n    comments: [],\n  };\n  return { url, member, key: { kind: \"template\", parts }, type };\n}\n\nfunction literalKey(url: string): PathKey {\n  return { kind: \"literal\", url };\n}\n\nconst PATHS_TYPE_NAME = \"paths\";\n\n/** The URL of `paths[\"/apps/{id}\"]`, or null for any other type. */\nfunction pathsIndexOf(type: IrType): string | null {\n  if (type.kind !== \"indexedAccess\" || type.index.kind !== \"stringLiteral\") {\n    return null;\n  }\n  const { object } = type;\n  const isPaths =\n    object.kind === \"reference\" &&\n    object.name === PATHS_TYPE_NAME &&\n    object.typeArguments.length === 0;\n  return isPaths ? type.index.value : null;\n}\n\n/**\n * The lookup, and `paths[\"/apps/{id}\"]` as that path's item. The declarations cannot read it: a\n * templated path is no property of `paths`, and TypeScript finds it through the signature.\n */\nfunction withPathItems(\n  paths: readonly PathMember[],\n  lookup: DeclaredTypeLookup,\n): DeclaredTypeLookup {\n  const byUrl = new Map(paths.map((path) => [path.url, path.type]));\n  return (type) => {\n    const url = pathsIndexOf(type);\n    return (url === null ? undefined : byUrl.get(url)) ?? lookup(type);\n  };\n}\n\n/**\n * The rejection of a covered path item: only one proven not assignable to the signature's type\n * counts (ADR-028). A pair the proof cannot decide keeps the original output, which may well\n * compile (`Record<string, never>` fits `{ [key: string]: unknown }`).\n */\nfunction rejectionOf(paths: readonly PathMember[], lookup: DeclaredTypeLookup): CoverRejection {\n  const relate = assignabilityProof(withPathItems(paths, lookup));\n  return (coveringIndex, coveredIndex) => {\n    const coveringPath = paths[coveringIndex];\n    const coveredPath = paths[coveredIndex];\n    return (\n      coveringPath !== undefined &&\n      coveredPath !== undefined &&\n      relate(coveredPath.type, coveringPath.type) === \"rejected\"\n    );\n  };\n}\n\n/**\n * The members as one object type. When an index signature covers another key, TypeScript checks\n * the covered key's type against it. Where that check surely fails (TS2411, TS2413), each such\n * signature gets an object of its own in an intersection: an intersection does not check its parts\n * against each other, and every key has the type it had in the one object. Output that compiles\n * keeps the one object. The lookup reads the types that path items reference; without it, a\n * reference decides nothing.\n */\nexport function pathsObjectType(\n  paths: readonly PathMember[],\n  lookup: DeclaredTypeLookup = NO_DECLARED_TYPES,\n): IrType {\n  const keys = paths.map(({ key }) => key);\n  const covering = coveringTemplateKeys(keys, rejectionOf(paths, lookup));\n  if (covering.size === 0) {\n    return irObject(paths.map(({ member }) => member));\n  }\n  const rest = paths.filter((_, index) => !covering.has(index)).map(({ member }) => member);\n  const own = paths\n    .filter((_, index) => covering.has(index))\n    .map(({ member }) => irObject([member]));\n  return irIntersection([irObject(rest), ...own]);\n}\n\n/** The members of the `paths` interface (OpenAPI 3.1 §4.8.8): one per path, by URL. */\nexport function pathMembers(paths: PathsObject, context: TransformContext): PathMember[] {\n  const members: PathMember[] = [];\n  for (const [url, pathItem] of documentEntries(paths, context.options)) {\n    if (!pathItem || typeof pathItem !== \"object\") {\n      continue;\n    }\n    if (\"$ref\" in pathItem) {\n      const options = { isReadonly: context.options.immutable };\n      const member = documentMember(url, refType(pathItem.$ref), pathItem, options);\n      members.push({ url, member, key: literalKey(url), type: member.type });\n      continue;\n    }\n    const startedAt = context.diagnostics.now();\n    const path = pathItemMember(url, pathItem, context);\n    members.push(path);\n    // The original reports only paths written as properties.\n    if (path.member.kind === \"property\") {\n      context.diagnostics.debug(`Transformed path \"${url}\"`, context.diagnostics.now() - startedAt);\n    }\n  }\n  return members;\n}\n\n/**\n * The `paths` interface body, with only the path items' own types for the overlap check. The\n * document transform checks the overlaps again once the referenced types are declared.\n */\nexport function pathsType(paths: PathsObject, context: TransformContext): IrType {\n  return pathsObjectType(pathMembers(paths, context));\n}\n"],"names":["pathItemOperations","OutputFix","replacedTemplateParts","escapeTemplateText","placeholderText","pathItem","pathItemType","createRef","member","irProperty","toPropertyName","irRaw","assignabilityProof","NO_DECLARED_TYPES","coveringTemplateKeys","irObject","irIntersection","documentEntries","documentMember","refType"],"mappings":"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"}