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

package/src/domain/openapi/discriminator-conflicts.ts

@@ -0,0 +1,251 @@
+import { admittedPropertyValues, resolveLocalRef } from "./admitted-values.js";
+import { isUnionMember, unionAt } from "./discriminated-union.js";
+import { createRef, escapePointerSegment, parseRefPointer } from "./json-pointer.js";
+
+/**
+ * Discriminator members whose discriminator value their own property does not allow. By the
+ * Discriminator Object rule, a member that no `mapping` entry names has its schema name as the
+ * value, so with a property `enum` (or `const`) that does not list it no value of the member
+ * matches, and where the generator adds the value to the member the property type is `never`.
+ * Each one gets a warning (CODING_PRINCIPLES §8.7).
+ */
+
+export interface DiscriminatorValueConflict {
+  /** The member schema, such as `#/components/schemas/EpisodeObject`. */
+  readonly member: string;
+  /** The schema that has the Discriminator Object. */
+  readonly owner: string;
+  readonly propertyName: string;
+  /** The values the discriminator gives the member: its mapping keys, or its name. */
+  readonly values: readonly string[];
+  /** The values the member's property allows. */
+  readonly allowed: readonly (string | number | boolean | null)[];
+  /** Whether no mapping entry names the member, so its value is its schema name. */
+  readonly isImplicit: boolean;
+}
+
+type JsonObject = Readonly<Record<string, unknown>>;
+
+const COMPONENT_SCHEMAS = "#/components/schemas/";
+
+function isObject(value: unknown): value is JsonObject {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+interface Owner {
+  readonly pointer: string;
+  readonly propertyName: string;
+  readonly mapping: Readonly<Record<string, string>>;
+  readonly memberRefs: readonly string[];
+}
+
+function refsOf(list: unknown): string[] {
+  return (Array.isArray(list) ? list : []).flatMap((item) =>
+    isObject(item) && typeof item.$ref === "string" ? [item.$ref] : [],
+  );
+}
+
+function mappingTarget(target: string): string {
+  return target.startsWith("#") ? target : `${COMPONENT_SCHEMAS}${escapePointerSegment(target)}`;
+}
+
+function ownerAt(node: JsonObject, pointer: () => string): Owner | null {
+  const discriminator = node.discriminator;
+  if (!isObject(discriminator) || typeof discriminator.propertyName !== "string") {
+    return null;
+  }
+  const mapping = isObject(discriminator.mapping)
+    ? (discriminator.mapping as Readonly<Record<string, string>>)
+    : {};
+  const mapped = Object.values(mapping)
+    .filter((t) => typeof t === "string")
+    .map(mappingTarget);
+  const memberRefs = [...refsOf(node.oneOf), ...refsOf(node.anyOf), ...mapped];
+  return { pointer: pointer(), propertyName: discriminator.propertyName, mapping, memberRefs };
+}
+
+/** A node of the document walk; the pointer is built only for the nodes that need it. */
+interface Visit {
+  readonly node: unknown;
+  readonly key: string | null;
+  readonly parent: Visit | null;
+}
+
+function pointerOf(visit: Visit): string {
+  const segments: string[] = [];
+  for (let current: Visit | null = visit; current?.key != null; current = current.parent) {
+    segments.unshift(current.key);
+  }
+  return createRef(segments);
+}
+
+function childrenOf(visit: Visit): Visit[] {
+  const { node } = visit;
+  const entries: [string, unknown][] = Array.isArray(node)
+    ? node.map((item, index) => [String(index), item])
+    : isObject(node)
+      ? Object.entries(node)
+      : [];
+  return entries.map(([key, child]) => ({ node: child, key, parent: visit }));
+}
+
+/**
+ * Every Discriminator Object of the document, depth first, with its pointer. The walk keeps its
+ * own stack, so a document nested past the call stack fails in the transform, as it did before.
+ */
+function ownersIn(document: unknown): Owner[] {
+  const found: Owner[] = [];
+  const stack: Visit[] = [{ node: document, key: null, parent: null }];
+  for (let visit = stack.pop(); visit !== undefined; visit = stack.pop()) {
+    const owner = isObject(visit.node) ? ownerAt(visit.node, () => pointerOf(visit)) : null;
+    if (owner !== null) {
+      found.push(owner);
+    }
+    stack.push(...childrenOf(visit).reverse());
+  }
+  return found;
+}
+
+/** A member and the `$ref`s whose properties its type leaves out (`Omit` of its parents). */
+interface Member {
+  readonly ref: string;
+  readonly skipped: ReadonlySet<string>;
+}
+
+interface Child {
+  readonly ref: string;
+  readonly schema: JsonObject;
+}
+
+/** How the run types an `allOf` of a discriminated union. */
+export interface ConflictOptions {
+  /**
+   * `allof-discriminated-union`: a schema that `allOf`s a union which does not contain it reuses
+   * the union and gets no value, so neither it nor the schemas below it are members.
+   */
+  readonly isUnionReused: boolean;
+}
+
+/** What the search for conflicts reads: the document and its `allOf` children by parent. */
+interface ConflictSearch extends ConflictOptions {
+  readonly document: unknown;
+  readonly children: ReadonlyMap<string, readonly Child[]>;
+}
+
+/** The `allOf` children of the owner that inherit its discriminator. */
+function inheritingChildren(owner: Owner, search: ConflictSearch): readonly Child[] {
+  const children = search.children.get(owner.pointer) ?? [];
+  const resolve = (ref: string) => resolveLocalRef(search.document, ref);
+  const union = search.isUnionReused ? unionAt(owner.pointer, resolve) : undefined;
+  return union === undefined
+    ? children
+    : children.filter((child) => isUnionMember(union, child.ref, resolve));
+}
+
+/** The component schemas whose `allOf` holds a `$ref`, by that `$ref`, in document order. */
+function allOfChildren(document: unknown): Map<string, Child[]> {
+  const schemas = resolveLocalRef(document, "#/components/schemas");
+  const children = new Map<string, Child[]>();
+  for (const [name, schema] of Object.entries(isObject(schemas) ? schemas : {})) {
+    if (!isObject(schema)) {
+      continue;
+    }
+    const child = { ref: `${COMPONENT_SCHEMAS}${escapePointerSegment(name)}`, schema };
+    for (const parent of new Set(refsOf(schema.allOf))) {
+      const siblings = children.get(parent) ?? [];
+      siblings.push(child);
+      children.set(parent, siblings);
+    }
+  }
+  return children;
+}
+
+/** Whether a schema defines a discriminator of the property itself: it is the owner below. */
+function ownsProperty(schema: JsonObject, propertyName: string): boolean {
+  const discriminator = schema.discriminator;
+  return isObject(discriminator) && discriminator.propertyName === propertyName;
+}
+
+/**
+ * Component schemas that inherit the owner through `allOf`, also through a chain
+ * (`Lion: { allOf: [Cat] }`, `Cat: { allOf: [Pet] }`). Each parent on the way is left out of the
+ * member's values, as its type omits the property. A schema with its own discriminator of the
+ * property is a member, but the schemas below it are its own members.
+ */
+function inheritingMembers(owner: Owner, search: ConflictSearch): Member[] {
+  const found: Member[] = [];
+  const visited = new Set([owner.pointer]);
+  const parents: Member[] = [{ ref: owner.pointer, skipped: new Set([owner.pointer]) }];
+  for (let parent = parents.shift(); parent !== undefined; parent = parents.shift()) {
+    const children =
+      parent.ref === owner.pointer
+        ? inheritingChildren(owner, search)
+        : (search.children.get(parent.ref) ?? []);
+    for (const child of children) {
+      if (visited.has(child.ref)) {
+        continue;
+      }
+      visited.add(child.ref);
+      found.push({ ref: child.ref, skipped: parent.skipped });
+      if (!ownsProperty(child.schema, owner.propertyName)) {
+        parents.push({ ref: child.ref, skipped: new Set([...parent.skipped, child.ref]) });
+      }
+    }
+  }
+  return found;
+}
+
+/** The members of an owner, each once: the listed and mapped ones, then the inheriting ones. */
+function membersOf(owner: Owner, search: ConflictSearch): Member[] {
+  const listed = owner.memberRefs.map((ref) => ({ ref, skipped: new Set([owner.pointer]) }));
+  const members = new Map<string, Member>();
+  for (const member of [...listed, ...inheritingMembers(owner, search)]) {
+    if (!members.has(member.ref)) {
+      members.set(member.ref, member);
+    }
+  }
+  return [...members.values()];
+}
+
+function memberValues(owner: Owner, member: string): { values: string[]; isImplicit: boolean } {
+  const values = Object.entries(owner.mapping)
+    .filter(([, target]) => typeof target === "string" && mappingTarget(target) === member)
+    .map(([key]) => key);
+  const name = parseRefPointer(member).pop() ?? "";
+  return values.length > 0 ? { values, isImplicit: false } : { values: [name], isImplicit: true };
+}
+
+function conflictOf(owner: Owner, { ref: member, skipped }: Member, document: unknown) {
+  // The owner's own property is left out of an inheriting member's type (`Omit`).
+  const allowed = admittedPropertyValues(
+    resolveLocalRef(document, member),
+    owner.propertyName,
+    document,
+    skipped,
+  );
+  const { values, isImplicit } = memberValues(owner, member);
+  if (allowed === null || values.some((value) => allowed.has(value))) {
+    return null;
+  }
+  const { pointer, propertyName } = owner;
+  return { member, owner: pointer, propertyName, values, allowed: [...allowed], isImplicit };
+}
+
+/** The conflicts of the document, one per member and value list, in document order. */
+export function findDiscriminatorValueConflicts(
+  document: unknown,
+  options: ConflictOptions = { isUnionReused: false },
+): readonly DiscriminatorValueConflict[] {
+  const conflicts = new Map<string, DiscriminatorValueConflict>();
+  const search = { ...options, document, children: allOfChildren(document) };
+  for (const owner of ownersIn(document)) {
+    for (const member of membersOf(owner, search)) {
+      const conflict = conflictOf(owner, member, document);
+      const key = JSON.stringify([member.ref, conflict?.propertyName, conflict?.values]);
+      if (conflict !== null && !conflicts.has(key)) {
+        conflicts.set(key, conflict);
+      }
+    }
+  }
+  return [...conflicts.values()];
+}

package/src/domain/openapi/parameter-object.ts

@@ -23,6 +23,10 @@ export interface ParameterObject {
   readonly in: ParameterLocation | typeof QUERYSTRING_LOCATION;
   readonly required?: boolean;
   readonly deprecated?: boolean;
+  /** How the value is serialized; `form` for `in: query` when absent (§4.8.12.4). */
+  readonly style?: string;
+  /** Whether an array or object value is sent as several values; true for `form` when absent. */
+  readonly explode?: boolean;
   readonly schema?: Schema;
   readonly content?: ContentMap;
 }

package/src/domain/openapi/path-templates.ts

@@ -0,0 +1,31 @@
+/**
+ * The Paths Object rule (OpenAPI 3.1 §4.8.8): "Templated paths with the same hierarchy but
+ * different templated names MUST NOT exist as they are identical." Such paths, `/a/{id}` and
+ * `/a/{name}`, match the same URLs, so a client cannot tell which one a request is for.
+ */
+
+const PATH_PARAMETER_RE = /\{[^}]+\}/g;
+const PATH_PREFIX = "/";
+const UNNAMED_PARAMETER = "{}";
+
+function isObject(value: unknown): value is Readonly<Record<string, unknown>> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * The groups of paths that differ only in the names of their template parameters, each group in
+ * document order, the groups in the order of their first path. Keys that are no path, such as an
+ * `x-` extension, are left out.
+ */
+export function findIdenticalPathTemplates(document: unknown): string[][] {
+  const paths = isObject(document) && isObject(document.paths) ? document.paths : {};
+  const byHierarchy = new Map<string, string[]>();
+  for (const url of Object.keys(paths)) {
+    if (!url.startsWith(PATH_PREFIX) || !url.includes("{")) {
+      continue;
+    }
+    const hierarchy = url.replace(PATH_PARAMETER_RE, UNNAMED_PARAMETER);
+    byHierarchy.set(hierarchy, [...(byHierarchy.get(hierarchy) ?? []), url]);
+  }
+  return [...byHierarchy.values()].filter((urls) => urls.length > 1);
+}

package/src/domain/openapi/schema-object.ts

@@ -42,6 +42,8 @@ export interface SchemaObject {
   readonly $defs?: Readonly<Record<string, SchemaObject>>;
   readonly items?: Schema | readonly Schema[];
   readonly prefixItems?: readonly Schema[];
+  readonly unevaluatedItems?: Schema;
+  readonly contains?: Schema;
   readonly minItems?: number;
   readonly maxItems?: number;
   readonly allOf?: readonly Schema[];

package/src/domain/output-fixes.ts

@@ -6,14 +6,43 @@ import { ERROR_CODES, OpenAPITypesafeError } from "./errors.js";
  * default.
  */
 export const OutputFix = {
+  /** An `allOf` `$ref` to a discriminated union is the union, without `Omit` or a schema name. */
+  ALLOF_DISCRIMINATED_UNION: "allof-discriminated-union",
   /** An `allOf` member with only `required` makes those properties of the others required. */
   ALLOF_REQUIRED: "allof-required",
+  /** The JSDoc of a schema lists the descriptions of its `anyOf` and `oneOf` members. */
+  ANYOF_ONEOF_DESCRIPTIONS: "anyof-oneof-descriptions",
+  /** `anyOf` / `oneOf` variants with only `required` make those keys of the parent required. */
+  ANYOF_ONEOF_REQUIRED: "anyof-oneof-required",
   /** `anyOf` next to object keywords or `allOf` is intersected with them, not added to a union. */
   ANYOF_PROPERTIES: "anyof-properties",
   /** `--array-length` tuples have `min` to `max` items, nest right and follow `--immutable`. */
   ARRAY_LENGTH_TUPLES: "array-length-tuples",
-  /** A schema two discriminators name gets one enum of their values, a mapping before its name. */
+  /** `--dedupe-enums` names a shared enum by all of its schemas, not by the first one. */
+  DEDUPE_ENUM_NAMES: "dedupe-enum-names",
+  /** `required` next to an `allOf` `$ref` to a discriminator member still gives `WithRequired`. */
+  DISCRIMINATOR_MEMBER_REQUIRED: "discriminator-member-required",
+  /**
+   * The value a discriminator member gets: one enum of every discriminator's values, a mapping
+   * before the schema name, a schema's own mapping before an inherited one, none where the member
+   * declares it, and with `--enum` a member of the owner's enum.
+   */
   DISCRIMINATOR_VALUES: "discriminator-values",
+  /** An exploded object query parameter's properties are keys of `query`, as they are sent. */
+  EXPLODED_QUERY_OBJECTS: "exploded-query-objects",
+  /** `--enum` declares an enum that lists `null` without it, and the type adds `| null`. */
+  NULLABLE_ENUMS: "nullable-enums",
+  /** `--path-params-as-types` gives each `{name}` its placeholder, `{number}` included. */
+  PATH_PARAM_TYPE_NAMES: "path-param-type-names",
+  /** A `prefixItems` tuple is open unless `items` or `unevaluatedItems` closes it (2020-12). */
+  PREFIX_ITEMS: "prefix-items",
+  /** `readOnly` and `writeOnly` of the schema a `$ref` names, or of `allOf` members, count. */
+  READ_WRITE_REFS: "read-write-refs",
+  /**
+   * A `$ref` into schema keywords (`content/<type>/schema`, `items`, `allOf/0`) gets the type it
+   * points at, also where the original type compiles through an index signature.
+   */
+  REF_POINTERS: "ref-pointers",
   /** Schemas of one root type name without the prefix each get an alias, the earlier numbered. */
   ROOT_TYPE_NUMBERING: "root-type-numbering",
   /** `unevaluatedProperties` types the keys no other keyword declares (an index signature). */
@@ -58,11 +87,18 @@ export function resolveOutputFixes(names: readonly OutputFixName[]): ReadonlySet
 
 /** A generator option that a fix works with; without it, the fix changes nothing (ADR-021). */
 export interface OutputFixRequirement {
-  readonly option: "arrayLength" | "rootTypes" | "rootTypesNoSchemaPrefix";
+  readonly option:
+    | "arrayLength"
+    | "dedupeEnums"
+    | "enum"
+    | "pathParamsAsTypes"
+    | "rootTypes"
+    | "rootTypesNoSchemaPrefix";
   readonly flag: string;
 }
 
 const ROOT_TYPES = { option: "rootTypes", flag: "--root-types" } as const;
+const ENUM = { option: "enum", flag: "--enum" } as const;
 const NO_SCHEMA_PREFIX = {
   option: "rootTypesNoSchemaPrefix",
   flag: "--root-types-no-schema-prefix",
@@ -71,6 +107,11 @@ const NO_SCHEMA_PREFIX = {
 /** The options each fix needs, by fix name; `all` has none. */
 const REQUIREMENTS: Readonly<Partial<Record<OutputFixName, readonly OutputFixRequirement[]>>> = {
   [OutputFix.ARRAY_LENGTH_TUPLES]: [{ option: "arrayLength", flag: "--array-length" }],
+  [OutputFix.DEDUPE_ENUM_NAMES]: [ENUM, { option: "dedupeEnums", flag: "--dedupe-enums" }],
+  [OutputFix.NULLABLE_ENUMS]: [ENUM],
+  [OutputFix.PATH_PARAM_TYPE_NAMES]: [
+    { option: "pathParamsAsTypes", flag: "--path-params-as-types" },
+  ],
   [OutputFix.ROOT_TYPE_NUMBERING]: [ROOT_TYPES, NO_SCHEMA_PREFIX],
 };
 

package/src/domain/warnings.ts

@@ -0,0 +1,20 @@
+/**
+ * Typed warnings. A warning does not stop the run: the output is written and the CLI exits with 0.
+ * Each one ends with a stable machine-readable code in parentheses, as the CLI prints errors
+ * (`message (CODE)`), so a script or a person can search for it.
+ */
+
+/** Every warning code. */
+export const WARNING_CODES = {
+  DISCRIMINATOR_VALUE_NOT_ALLOWED: "DISCRIMINATOR_VALUE_NOT_ALLOWED",
+  ENUM_VALUES_EXCLUDED: "ENUM_VALUES_EXCLUDED",
+  PATH_TEMPLATES_IDENTICAL: "PATH_TEMPLATES_IDENTICAL",
+  QUERYSTRING_NEXT_TO_QUERY: "QUERYSTRING_NEXT_TO_QUERY",
+} as const;
+
+export type WarningCode = (typeof WARNING_CODES)[keyof typeof WARNING_CODES];
+
+/** The warning line for people, with its code at the end. */
+export function warningText(message: string, code: WarningCode): string {
+  return `${message} (${code})`;
+}

package/src/transform/components-object.ts

@@ -1,5 +1,6 @@
 import { createTransformContext } from "../api/transform-context.js";
 import { componentsType } from "../application/transform/document/components.js";
+import { renameTakenAliases } from "../application/transform/document/root-type-aliases.js";
 import type { IrType, IrTypeAliasDeclaration } from "../domain/ir/nodes.js";
 import { isEnumSchema, singularizeComponentKind } from "../domain/openapi/components-object.js";
 import type { ComponentsObject, GlobalContext } from "../types.js";
@@ -21,5 +22,6 @@ export default function transformComponentsObject(
   ctx: GlobalContext,
 ): (IrType | IrTypeAliasDeclaration)[] {
   const { type, rootTypes } = componentsType(componentsObject, createTransformContext(ctx));
-  return [type, ...rootTypes];
+  // No footer here: only the aliases the `root-type-numbering` fix keeps get numbers.
+  return [type, ...renameTakenAliases(rootTypes, [])];
 }

package/src/types/generator-options.ts

@@ -208,6 +208,17 @@ export interface GlobalContext {
   discriminators: {
     objects: Record<string, DiscriminatorObject>;
     refsHandled: string[];
+    /**
+     * @internal With the `discriminator-values` fix: for each enum the scan added to a
+     * member and each inherited discriminator object, the enum of the owner's property and the
+     * location it is typed at.
+     */
+    enumParents?: ReadonlyMap<object, { readonly schema: SchemaObject; readonly path: string }>;
+    /**
+     * @internal With the `discriminator-values` fix: for each schema, the properties of the
+     * discriminators it inherits besides `objects[ref]`, which it redefines too.
+     */
+    otherProperties?: Readonly<Record<string, readonly string[]>>;
   };
   emptyObjectsUnknown: boolean;
   enum: boolean;

package/dist/application/transform/document/path-item-conflicts.cjs

@@ -1,51 +0,0 @@
-'use strict';
-
-function nameOf(member) {
-  return member.name.kind === "string" ? member.name.value : member.name.text;
-}
-function presenceOf(member) {
-  if (member === void 0) {
-    return "absent";
-  }
-  if (member.type.kind === "keyword" && member.type.keyword === "never") {
-    return member.isOptional ? "never" : "unknown";
-  }
-  return member.isOptional ? "optional" : "required";
-}
-function propertiesOf(type) {
-  if (type.kind !== "object") {
-    return null;
-  }
-  const properties = type.members.filter((member) => {
-    return member.kind === "property";
-  });
-  return new Map(properties.map((property) => [nameOf(property), property]));
-}
-function isPresenceRejected(covering, covered) {
-  if (covered === "unknown") {
-    return false;
-  }
-  if (covering === "required") {
-    return covered !== "required";
-  }
-  return covering === "never" && (covered === "optional" || covered === "required");
-}
-function isPropertyRejected(covering, covered) {
-  if (isPresenceRejected(presenceOf(covering), presenceOf(covered))) {
-    return true;
-  }
-  return covered !== void 0 && isCoveredPathItemRejected(covered.type, covering.type);
-}
-function isCoveredPathItemRejected(covered, covering) {
-  const coveredProperties = propertiesOf(covered);
-  const coveringProperties = propertiesOf(covering);
-  if (coveredProperties === null || coveringProperties === null) {
-    return false;
-  }
-  return [...coveringProperties].some(
-    ([name, property]) => isPropertyRejected(property, coveredProperties.get(name))
-  );
-}
-
-exports.isCoveredPathItemRejected = isCoveredPathItemRejected;
-//# sourceMappingURL=path-item-conflicts.cjs.map

package/dist/application/transform/document/path-item-conflicts.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"path-item-conflicts.cjs","sources":["../../../../src/application/transform/document/path-item-conflicts.ts"],"sourcesContent":["import type { IrMember, IrPropertySignature, IrType } from \"../../../domain/ir/nodes.js\";\n\n/**\n * Whether TypeScript surely rejects a covered path item for the index signature that covers it\n * (roadmap R10.2). The original output compiles when every covered type is assignable to the\n * signature's type, and that output must stay the same, so a signature is only moved when this\n * check proves the error. It compares object types property by property, as the checker does: a\n * property the signature needs and the covered type may lack, or a value where the signature has\n * the `?: never` of an empty slot (a missing method, an empty parameter location), proves it. Two\n * object properties are compared the same way, inside. Any other pair of types (references,\n * unions, keywords) decides nothing, and that output is left as it was.\n */\n\n/**\n * How a property is written. `never` is the `?: never` of an empty slot; a required `never`\n * (assignable to every type) is `unknown` and decides nothing.\n */\ntype Presence = \"absent\" | \"never\" | \"optional\" | \"required\" | \"unknown\";\n\nfunction nameOf(member: IrPropertySignature): string {\n  return member.name.kind === \"string\" ? member.name.value : member.name.text;\n}\n\nfunction presenceOf(member: IrPropertySignature | undefined): Presence {\n  if (member === undefined) {\n    return \"absent\";\n  }\n  if (member.type.kind === \"keyword\" && member.type.keyword === \"never\") {\n    return member.isOptional ? \"never\" : \"unknown\";\n  }\n  return member.isOptional ? \"optional\" : \"required\";\n}\n\nfunction propertiesOf(type: IrType): ReadonlyMap<string, IrPropertySignature> | null {\n  if (type.kind !== \"object\") {\n    return null;\n  }\n  const properties = type.members.filter((member: IrMember): member is IrPropertySignature => {\n    return member.kind === \"property\";\n  });\n  return new Map(properties.map((property) => [nameOf(property), property]));\n}\n\n/**\n * Whether the covered property's presence fails the signature's: a required value it may lack, or\n * a value where the signature has `never` (an object is not `undefined`).\n */\nfunction isPresenceRejected(covering: Presence, covered: Presence): boolean {\n  if (covered === \"unknown\") {\n    return false;\n  }\n  if (covering === \"required\") {\n    return covered !== \"required\";\n  }\n  return covering === \"never\" && (covered === \"optional\" || covered === \"required\");\n}\n\nfunction isPropertyRejected(\n  covering: IrPropertySignature,\n  covered: IrPropertySignature | undefined,\n): boolean {\n  if (isPresenceRejected(presenceOf(covering), presenceOf(covered))) {\n    return true;\n  }\n  // A `never` is not an object type, so a slot that is empty on either side decides nothing here.\n  return covered !== undefined && isCoveredPathItemRejected(covered.type, covering.type);\n}\n\n/** Whether the covered type is surely not assignable to the covering signature's type. */\nexport function isCoveredPathItemRejected(covered: IrType, covering: IrType): boolean {\n  const coveredProperties = propertiesOf(covered);\n  const coveringProperties = propertiesOf(covering);\n  if (coveredProperties === null || coveringProperties === null) {\n    return false;\n  }\n  return [...coveringProperties].some(([name, property]) =>\n    isPropertyRejected(property, coveredProperties.get(name)),\n  );\n}\n"],"names":[],"mappings":";;AAmBA,SAAS,OAAO,MAAA,EAAqC;AACnD,EAAA,OAAO,MAAA,CAAO,KAAK,IAAA,KAAS,QAAA,GAAW,OAAO,IAAA,CAAK,KAAA,GAAQ,OAAO,IAAA,CAAK,IAAA;AACzE;AAEA,SAAS,WAAW,MAAA,EAAmD;AACrE,EAAA,IAAI,WAAW,MAAA,EAAW;AACxB,IAAA,OAAO,QAAA;AAAA,EACT;AACA,EAAA,IAAI,OAAO,IAAA,CAAK,IAAA,KAAS,aAAa,MAAA,CAAO,IAAA,CAAK,YAAY,OAAA,EAAS;AACrE,IAAA,OAAO,MAAA,CAAO,aAAa,OAAA,GAAU,SAAA;AAAA,EACvC;AACA,EAAA,OAAO,MAAA,CAAO,aAAa,UAAA,GAAa,UAAA;AAC1C;AAEA,SAAS,aAAa,IAAA,EAA+D;AACnF,EAAA,IAAI,IAAA,CAAK,SAAS,QAAA,EAAU;AAC1B,IAAA,OAAO,IAAA;AAAA,EACT;AACA,EAAA,MAAM,UAAA,GAAa,IAAA,CAAK,OAAA,CAAQ,MAAA,CAAO,CAAC,MAAA,KAAoD;AAC1F,IAAA,OAAO,OAAO,IAAA,KAAS,UAAA;AAAA,EACzB,CAAC,CAAA;AACD,EAAA,OAAO,IAAI,GAAA,CAAI,UAAA,CAAW,GAAA,CAAI,CAAC,QAAA,KAAa,CAAC,MAAA,CAAO,QAAQ,CAAA,EAAG,QAAQ,CAAC,CAAC,CAAA;AAC3E;AAMA,SAAS,kBAAA,CAAmB,UAAoB,OAAA,EAA4B;AAC1E,EAAA,IAAI,YAAY,SAAA,EAAW;AACzB,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,IAAI,aAAa,UAAA,EAAY;AAC3B,IAAA,OAAO,OAAA,KAAY,UAAA;AAAA,EACrB;AACA,EAAA,OAAO,QAAA,KAAa,OAAA,KAAY,OAAA,KAAY,UAAA,IAAc,OAAA,KAAY,UAAA,CAAA;AACxE;AAEA,SAAS,kBAAA,CACP,UACA,OAAA,EACS;AACT,EAAA,IAAI,mBAAmB,UAAA,CAAW,QAAQ,GAAG,UAAA,CAAW,OAAO,CAAC,CAAA,EAAG;AACjE,IAAA,OAAO,IAAA;AAAA,EACT;AAEA,EAAA,OAAO,YAAY,MAAA,IAAa,yBAAA,CAA0B,OAAA,CAAQ,IAAA,EAAM,SAAS,IAAI,CAAA;AACvF;AAGO,SAAS,yBAAA,CAA0B,SAAiB,QAAA,EAA2B;AACpF,EAAA,MAAM,iBAAA,GAAoB,aAAa,OAAO,CAAA;AAC9C,EAAA,MAAM,kBAAA,GAAqB,aAAa,QAAQ,CAAA;AAChD,EAAA,IAAI,iBAAA,KAAsB,IAAA,IAAQ,kBAAA,KAAuB,IAAA,EAAM;AAC7D,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,OAAO,CAAC,GAAG,kBAAkB,CAAA,CAAE,IAAA;AAAA,IAAK,CAAC,CAAC,IAAA,EAAM,QAAQ,CAAA,KAClD,mBAAmB,QAAA,EAAU,iBAAA,CAAkB,GAAA,CAAI,IAAI,CAAC;AAAA,GAC1D;AACF;;"}

package/dist/application/transform/document/path-item-conflicts.mjs

@@ -1,49 +0,0 @@
-function nameOf(member) {
-  return member.name.kind === "string" ? member.name.value : member.name.text;
-}
-function presenceOf(member) {
-  if (member === void 0) {
-    return "absent";
-  }
-  if (member.type.kind === "keyword" && member.type.keyword === "never") {
-    return member.isOptional ? "never" : "unknown";
-  }
-  return member.isOptional ? "optional" : "required";
-}
-function propertiesOf(type) {
-  if (type.kind !== "object") {
-    return null;
-  }
-  const properties = type.members.filter((member) => {
-    return member.kind === "property";
-  });
-  return new Map(properties.map((property) => [nameOf(property), property]));
-}
-function isPresenceRejected(covering, covered) {
-  if (covered === "unknown") {
-    return false;
-  }
-  if (covering === "required") {
-    return covered !== "required";
-  }
-  return covering === "never" && (covered === "optional" || covered === "required");
-}
-function isPropertyRejected(covering, covered) {
-  if (isPresenceRejected(presenceOf(covering), presenceOf(covered))) {
-    return true;
-  }
-  return covered !== void 0 && isCoveredPathItemRejected(covered.type, covering.type);
-}
-function isCoveredPathItemRejected(covered, covering) {
-  const coveredProperties = propertiesOf(covered);
-  const coveringProperties = propertiesOf(covering);
-  if (coveredProperties === null || coveringProperties === null) {
-    return false;
-  }
-  return [...coveringProperties].some(
-    ([name, property]) => isPropertyRejected(property, coveredProperties.get(name))
-  );
-}
-
-export { isCoveredPathItemRejected };
-//# sourceMappingURL=path-item-conflicts.mjs.map

package/dist/application/transform/document/path-item-conflicts.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"path-item-conflicts.mjs","sources":["../../../../src/application/transform/document/path-item-conflicts.ts"],"sourcesContent":["import type { IrMember, IrPropertySignature, IrType } from \"../../../domain/ir/nodes.js\";\n\n/**\n * Whether TypeScript surely rejects a covered path item for the index signature that covers it\n * (roadmap R10.2). The original output compiles when every covered type is assignable to the\n * signature's type, and that output must stay the same, so a signature is only moved when this\n * check proves the error. It compares object types property by property, as the checker does: a\n * property the signature needs and the covered type may lack, or a value where the signature has\n * the `?: never` of an empty slot (a missing method, an empty parameter location), proves it. Two\n * object properties are compared the same way, inside. Any other pair of types (references,\n * unions, keywords) decides nothing, and that output is left as it was.\n */\n\n/**\n * How a property is written. `never` is the `?: never` of an empty slot; a required `never`\n * (assignable to every type) is `unknown` and decides nothing.\n */\ntype Presence = \"absent\" | \"never\" | \"optional\" | \"required\" | \"unknown\";\n\nfunction nameOf(member: IrPropertySignature): string {\n  return member.name.kind === \"string\" ? member.name.value : member.name.text;\n}\n\nfunction presenceOf(member: IrPropertySignature | undefined): Presence {\n  if (member === undefined) {\n    return \"absent\";\n  }\n  if (member.type.kind === \"keyword\" && member.type.keyword === \"never\") {\n    return member.isOptional ? \"never\" : \"unknown\";\n  }\n  return member.isOptional ? \"optional\" : \"required\";\n}\n\nfunction propertiesOf(type: IrType): ReadonlyMap<string, IrPropertySignature> | null {\n  if (type.kind !== \"object\") {\n    return null;\n  }\n  const properties = type.members.filter((member: IrMember): member is IrPropertySignature => {\n    return member.kind === \"property\";\n  });\n  return new Map(properties.map((property) => [nameOf(property), property]));\n}\n\n/**\n * Whether the covered property's presence fails the signature's: a required value it may lack, or\n * a value where the signature has `never` (an object is not `undefined`).\n */\nfunction isPresenceRejected(covering: Presence, covered: Presence): boolean {\n  if (covered === \"unknown\") {\n    return false;\n  }\n  if (covering === \"required\") {\n    return covered !== \"required\";\n  }\n  return covering === \"never\" && (covered === \"optional\" || covered === \"required\");\n}\n\nfunction isPropertyRejected(\n  covering: IrPropertySignature,\n  covered: IrPropertySignature | undefined,\n): boolean {\n  if (isPresenceRejected(presenceOf(covering), presenceOf(covered))) {\n    return true;\n  }\n  // A `never` is not an object type, so a slot that is empty on either side decides nothing here.\n  return covered !== undefined && isCoveredPathItemRejected(covered.type, covering.type);\n}\n\n/** Whether the covered type is surely not assignable to the covering signature's type. */\nexport function isCoveredPathItemRejected(covered: IrType, covering: IrType): boolean {\n  const coveredProperties = propertiesOf(covered);\n  const coveringProperties = propertiesOf(covering);\n  if (coveredProperties === null || coveringProperties === null) {\n    return false;\n  }\n  return [...coveringProperties].some(([name, property]) =>\n    isPropertyRejected(property, coveredProperties.get(name)),\n  );\n}\n"],"names":[],"mappings":"AAmBA,SAAS,OAAO,MAAA,EAAqC;AACnD,EAAA,OAAO,MAAA,CAAO,KAAK,IAAA,KAAS,QAAA,GAAW,OAAO,IAAA,CAAK,KAAA,GAAQ,OAAO,IAAA,CAAK,IAAA;AACzE;AAEA,SAAS,WAAW,MAAA,EAAmD;AACrE,EAAA,IAAI,WAAW,MAAA,EAAW;AACxB,IAAA,OAAO,QAAA;AAAA,EACT;AACA,EAAA,IAAI,OAAO,IAAA,CAAK,IAAA,KAAS,aAAa,MAAA,CAAO,IAAA,CAAK,YAAY,OAAA,EAAS;AACrE,IAAA,OAAO,MAAA,CAAO,aAAa,OAAA,GAAU,SAAA;AAAA,EACvC;AACA,EAAA,OAAO,MAAA,CAAO,aAAa,UAAA,GAAa,UAAA;AAC1C;AAEA,SAAS,aAAa,IAAA,EAA+D;AACnF,EAAA,IAAI,IAAA,CAAK,SAAS,QAAA,EAAU;AAC1B,IAAA,OAAO,IAAA;AAAA,EACT;AACA,EAAA,MAAM,UAAA,GAAa,IAAA,CAAK,OAAA,CAAQ,MAAA,CAAO,CAAC,MAAA,KAAoD;AAC1F,IAAA,OAAO,OAAO,IAAA,KAAS,UAAA;AAAA,EACzB,CAAC,CAAA;AACD,EAAA,OAAO,IAAI,GAAA,CAAI,UAAA,CAAW,GAAA,CAAI,CAAC,QAAA,KAAa,CAAC,MAAA,CAAO,QAAQ,CAAA,EAAG,QAAQ,CAAC,CAAC,CAAA;AAC3E;AAMA,SAAS,kBAAA,CAAmB,UAAoB,OAAA,EAA4B;AAC1E,EAAA,IAAI,YAAY,SAAA,EAAW;AACzB,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,IAAI,aAAa,UAAA,EAAY;AAC3B,IAAA,OAAO,OAAA,KAAY,UAAA;AAAA,EACrB;AACA,EAAA,OAAO,QAAA,KAAa,OAAA,KAAY,OAAA,KAAY,UAAA,IAAc,OAAA,KAAY,UAAA,CAAA;AACxE;AAEA,SAAS,kBAAA,CACP,UACA,OAAA,EACS;AACT,EAAA,IAAI,mBAAmB,UAAA,CAAW,QAAQ,GAAG,UAAA,CAAW,OAAO,CAAC,CAAA,EAAG;AACjE,IAAA,OAAO,IAAA;AAAA,EACT;AAEA,EAAA,OAAO,YAAY,MAAA,IAAa,yBAAA,CAA0B,OAAA,CAAQ,IAAA,EAAM,SAAS,IAAI,CAAA;AACvF;AAGO,SAAS,yBAAA,CAA0B,SAAiB,QAAA,EAA2B;AACpF,EAAA,MAAM,iBAAA,GAAoB,aAAa,OAAO,CAAA;AAC9C,EAAA,MAAM,kBAAA,GAAqB,aAAa,QAAQ,CAAA;AAChD,EAAA,IAAI,iBAAA,KAAsB,IAAA,IAAQ,kBAAA,KAAuB,IAAA,EAAM;AAC7D,IAAA,OAAO,KAAA;AAAA,EACT;AACA,EAAA,OAAO,CAAC,GAAG,kBAAkB,CAAA,CAAE,IAAA;AAAA,IAAK,CAAC,CAAC,IAAA,EAAM,QAAQ,CAAA,KAClD,mBAAmB,QAAA,EAAU,iBAAA,CAAkB,GAAA,CAAI,IAAI,CAAC;AAAA,GAC1D;AACF;;"}

package/src/application/transform/document/path-item-conflicts.ts

@@ -1,79 +0,0 @@
-import type { IrMember, IrPropertySignature, IrType } from "../../../domain/ir/nodes.js";
-
-/**
- * Whether TypeScript surely rejects a covered path item for the index signature that covers it
- * (roadmap R10.2). The original output compiles when every covered type is assignable to the
- * signature's type, and that output must stay the same, so a signature is only moved when this
- * check proves the error. It compares object types property by property, as the checker does: a
- * property the signature needs and the covered type may lack, or a value where the signature has
- * the `?: never` of an empty slot (a missing method, an empty parameter location), proves it. Two
- * object properties are compared the same way, inside. Any other pair of types (references,
- * unions, keywords) decides nothing, and that output is left as it was.
- */
-
-/**
- * How a property is written. `never` is the `?: never` of an empty slot; a required `never`
- * (assignable to every type) is `unknown` and decides nothing.
- */
-type Presence = "absent" | "never" | "optional" | "required" | "unknown";
-
-function nameOf(member: IrPropertySignature): string {
-  return member.name.kind === "string" ? member.name.value : member.name.text;
-}
-
-function presenceOf(member: IrPropertySignature | undefined): Presence {
-  if (member === undefined) {
-    return "absent";
-  }
-  if (member.type.kind === "keyword" && member.type.keyword === "never") {
-    return member.isOptional ? "never" : "unknown";
-  }
-  return member.isOptional ? "optional" : "required";
-}
-
-function propertiesOf(type: IrType): ReadonlyMap<string, IrPropertySignature> | null {
-  if (type.kind !== "object") {
-    return null;
-  }
-  const properties = type.members.filter((member: IrMember): member is IrPropertySignature => {
-    return member.kind === "property";
-  });
-  return new Map(properties.map((property) => [nameOf(property), property]));
-}
-
-/**
- * Whether the covered property's presence fails the signature's: a required value it may lack, or
- * a value where the signature has `never` (an object is not `undefined`).
- */
-function isPresenceRejected(covering: Presence, covered: Presence): boolean {
-  if (covered === "unknown") {
-    return false;
-  }
-  if (covering === "required") {
-    return covered !== "required";
-  }
-  return covering === "never" && (covered === "optional" || covered === "required");
-}
-
-function isPropertyRejected(
-  covering: IrPropertySignature,
-  covered: IrPropertySignature | undefined,
-): boolean {
-  if (isPresenceRejected(presenceOf(covering), presenceOf(covered))) {
-    return true;
-  }
-  // A `never` is not an object type, so a slot that is empty on either side decides nothing here.
-  return covered !== undefined && isCoveredPathItemRejected(covered.type, covering.type);
-}
-
-/** Whether the covered type is surely not assignable to the covering signature's type. */
-export function isCoveredPathItemRejected(covered: IrType, covering: IrType): boolean {
-  const coveredProperties = propertiesOf(covered);
-  const coveringProperties = propertiesOf(covering);
-  if (coveredProperties === null || coveringProperties === null) {
-    return false;
-  }
-  return [...coveringProperties].some(([name, property]) =>
-    isPropertyRejected(property, coveredProperties.get(name)),
-  );
-}