openapi-typesafe 0.0.0 → 1.0.0-rc.1

package/src/application/transform/document/type-resolution.ts

@@ -0,0 +1,163 @@
+import type {
+  IrIndexSignature,
+  IrMember,
+  IrObjectType,
+  IrPropertySignature,
+  IrType,
+} from "../../../domain/ir/nodes.js";
+import type { DeclaredTypeLookup } from "./declared-types.js";
+
+/**
+ * The types the `--path-params-as-types` overlap check compares, as TypeScript sees them:
+ * references followed to the declarations of the document, `T["key"]` and `T[number]` read from
+ * `T`, and an intersection of object types merged into one object.
+ */
+
+const UNDEFINED: IrType = { kind: "keyword", keyword: "undefined" };
+
+export function nameOf(member: IrPropertySignature): string {
+  return member.name.kind === "string" ? member.name.value : member.name.text;
+}
+
+export function propertiesOf(type: IrObjectType): Map<string, IrPropertySignature> {
+  const properties = type.members.filter(
+    (member: IrMember): member is IrPropertySignature => member.kind === "property",
+  );
+  return new Map(properties.map((property) => [nameOf(property), property]));
+}
+
+export function indexSignaturesOf(type: IrObjectType): IrIndexSignature[] {
+  return type.members.filter(
+    (member: IrMember): member is IrIndexSignature => member.kind === "indexSignature",
+  );
+}
+
+/** The type read from a property: an optional one may be `undefined`. */
+export function readType(property: IrPropertySignature): IrType {
+  return property.isOptional ? { kind: "union", types: [property.type, UNDEFINED] } : property.type;
+}
+
+/**
+ * `T[number]` for an array `T`, as the generator writes for an item of an array response: the
+ * element type, readonly or not. A tuple's is the union of its elements, which is not modelled.
+ */
+function arrayElement(type: IrType): IrType | null {
+  const list = type.kind === "readonly" ? type.type : type;
+  return list.kind === "array" ? list.element : null;
+}
+
+/** One property for two of the same name in an intersection. */
+function mergedProperty(
+  first: IrPropertySignature,
+  second: IrPropertySignature,
+): IrPropertySignature {
+  return {
+    ...first,
+    type: { kind: "intersection", types: [first.type, second.type] },
+    isOptional: first.isOptional && second.isOptional,
+    isReadonly: first.isReadonly || second.isReadonly,
+  };
+}
+
+/** Resolves types once each, for one comparison. */
+export class TypeResolution {
+  private readonly lookup: DeclaredTypeLookup;
+  private readonly resolvedTypes = new Map<IrType, IrType>();
+
+  constructor(lookup: DeclaredTypeLookup) {
+    this.lookup = lookup;
+  }
+
+  /** The type a reference names, followed through references to references; computed once. */
+  resolved(type: IrType): IrType {
+    const known = this.resolvedTypes.get(type);
+    if (known !== undefined) {
+      return known;
+    }
+    // A type that reaches itself while it is resolved stays as it is written there.
+    this.resolvedTypes.set(type, type);
+    const seen = new Set<IrType>();
+    let current = type;
+    while (!seen.has(current)) {
+      seen.add(current);
+      const named = this.lookup(current) ?? this.indexedProperty(current);
+      if (named === null) {
+        break;
+      }
+      current = named;
+    }
+    const result = current.kind === "intersection" ? (this.merged(current) ?? current) : current;
+    this.resolvedTypes.set(type, result);
+    return result;
+  }
+
+  /**
+   * `T["key"]` read from the object type `T` resolves to, which the lookup does not do for an
+   * object it reached through another lookup (`paths["/a/{id}"]["get"]`). An optional property
+   * reads as `T | undefined`; `T[number]` is the element of the array `T`.
+   */
+  private indexedProperty(type: IrType): IrType | null {
+    if (type.kind !== "indexedAccess") {
+      return null;
+    }
+    const { index } = type;
+    if (index.kind === "keyword" && index.keyword === "number") {
+      return arrayElement(this.resolved(type.object));
+    }
+    const object = this.resolved(type.object);
+    if (index.kind !== "stringLiteral" || object.kind !== "object") {
+      return null;
+    }
+    const property = propertiesOf(object).get(index.value);
+    return property === undefined ? null : readType(property);
+  }
+
+  /**
+   * An intersection of object types as the one object TypeScript makes of it: a property in
+   * several parts has the intersection of their types, and is optional only when it is in each.
+   * Null when a part is no object type.
+   */
+  private merged(type: IrType): IrObjectType | null {
+    const parts = this.objectParts(type);
+    if (parts === null) {
+      return null;
+    }
+    const properties = new Map<string, IrPropertySignature>();
+    const indexes: IrIndexSignature[] = [];
+    for (const member of parts.flatMap((part) => part.members)) {
+      if (member.kind === "indexSignature") {
+        indexes.push(member);
+        continue;
+      }
+      const name = nameOf(member);
+      const other = properties.get(name);
+      properties.set(name, other === undefined ? member : mergedProperty(other, member));
+    }
+    return { kind: "object", members: [...properties.values(), ...indexes] };
+  }
+
+  /**
+   * The object types an intersection is made of, nested ones flattened; null for any other, and
+   * for an intersection that contains itself, which TypeScript does not merge either.
+   */
+  private objectParts(
+    type: IrType,
+    visiting: ReadonlySet<IrType> = new Set(),
+  ): IrObjectType[] | null {
+    if (type.kind === "object") {
+      return [type];
+    }
+    if (type.kind !== "intersection" || visiting.has(type)) {
+      return null;
+    }
+    const parts: IrObjectType[] = [];
+    for (const part of type.types) {
+      const objects = this.objectParts(this.resolved(part), new Set([...visiting, type]));
+      if (objects === null) {
+        return null;
+      }
+      parts.push(...objects);
+    }
+    return parts;
+  }
+}

package/src/application/transform/document/webhooks.ts

@@ -0,0 +1,22 @@
+import { irObject, irProperty } from "../../../domain/ir/constructors.js";
+import type { IrType } from "../../../domain/ir/nodes.js";
+import { toPropertyName } from "../../../domain/ir/property-name.js";
+import { createRef } from "../../../domain/openapi/json-pointer.js";
+import type { PathItemObject, PathsObject } from "../../../domain/openapi/path-item-object.js";
+import { documentEntries } from "../document-entries.js";
+import type { TransformContext } from "../transform-context.js";
+import { pathItemType } from "./path-item.js";
+
+/**
+ * The `webhooks` interface body (OpenAPI 3.1 §4.8.1): one path item per webhook name. Unlike
+ * `paths`, a `$ref` entry is read as a path item (so every method is `never`), as in the original,
+ * and members carry no JSDoc.
+ */
+export function webhooksType(webhooks: PathsObject, context: TransformContext): IrType {
+  const members = documentEntries(webhooks, context.options).map(([name, pathItem]) => {
+    const location = { path: createRef(["webhooks", name]) };
+    const type = pathItemType(pathItem as PathItemObject, location, context);
+    return irProperty(toPropertyName(name), type, { isReadonly: context.options.immutable });
+  });
+  return irObject(members);
+}

package/src/application/transform/document-entries.ts

@@ -0,0 +1,28 @@
+import { sortEntriesByKey } from "../../domain/ir/normalize.js";
+import type { SchemaOptions } from "./schema/schema-context.js";
+
+/** Whether a document object has `deprecated: true` (`--exclude-deprecated` drops it). */
+export function isDeprecated(value: unknown): boolean {
+  return Boolean(value && typeof value === "object" && "deprecated" in value && value.deprecated);
+}
+
+/** Whether a deprecated entry is still needed, so `--exclude-deprecated` keeps it. */
+export type DeprecatedEntryFilter = (value: unknown) => boolean;
+
+const KEEPS_NONE: DeprecatedEntryFilter = () => false;
+
+/**
+ * `Object.entries` of a document map (the original `getEntries`): sorted for `--alphabetize`,
+ * without deprecated entries for `--exclude-deprecated`, except those `isKept` names.
+ */
+export function documentEntries<T>(
+  record: Readonly<Record<string, T>>,
+  options: Pick<SchemaOptions, "alphabetize" | "excludeDeprecated">,
+  isKept: DeprecatedEntryFilter = KEEPS_NONE,
+): [string, T][] {
+  const entries = Object.entries(record);
+  const sorted = options.alphabetize ? sortEntriesByKey(entries) : entries;
+  return options.excludeDeprecated
+    ? sorted.filter(([, value]) => !isDeprecated(value) || isKept(value))
+    : sorted;
+}

package/src/application/transform/footer/document-footer.ts

@@ -0,0 +1,212 @@
+import { irReference } from "../../../domain/ir/constructors.js";
+import type {
+  IrDeclaration,
+  IrEnumDeclaration,
+  IrPropertySignature,
+  IrType,
+} from "../../../domain/ir/nodes.js";
+import { HELPER_TYPES, type HelperType } from "../helper-types.js";
+import type {
+  EnumDeclarationRequest,
+  EnumMemberMetadata,
+  EnumValuesRequest,
+} from "../schema/schema-context.js";
+import type { DocumentFooter } from "../transform-context.js";
+import {
+  type DeclaredMembers,
+  EnumNaming,
+  enumDeclaration,
+  withoutDeclaredMembers,
+} from "./enum-naming.js";
+import { FIRST_SCHEMA_NAMES, type SharedEnumNames } from "./shared-enum-names.js";
+
+/** Where footer declarations go, in order: the run's `ctx.injectFooter`, open to user code. */
+export interface FooterSink {
+  /** Whether a type alias with this name is declared already (by the generator or a user). */
+  hasTypeAlias(name: string): boolean;
+  add(declaration: IrDeclaration): void;
+  /** Add a member to the `operations` interface, declared first if needed; see `DocumentFooter`. */
+  addOperation(build: () => IrPropertySignature): void;
+}
+
+/**
+ * The `--dedupe-enums` key of the original: the values in default sort order, each paired with
+ * the metadata at its sorted position (not the value's own metadata), as the original does.
+ */
+function dedupeKey(request: EnumDeclarationRequest): string {
+  return [...request.values]
+    .sort(compareAsStrings)
+    .map((value, index) => metadataKey(String(value), request.metadata[index]))
+    .join(",");
+}
+
+/** `Array.prototype.sort` without a comparator: compares the values as strings. */
+function compareAsStrings(left: string | number, right: string | number): number {
+  const leftText = String(left);
+  const rightText = String(right);
+  if (leftText === rightText) {
+    return 0;
+  }
+  return leftText < rightText ? -1 : 1;
+}
+
+function metadataKey(value: string, metadata: EnumMemberMetadata | undefined): string {
+  return `${metadata?.name ?? value}:${metadata?.description || ""}`;
+}
+
+/** Separates a repeated `--enum-values` array name from its number, as root type aliases do. */
+const ENUM_VALUES_NUMBER_SEPARATOR = "_";
+
+/** The whole declaration: an equal key means the same enum, member for member. */
+function declarationKey(name: string, request: EnumDeclarationRequest): string {
+  return JSON.stringify([name, request.values, request.metadata]);
+}
+
+/**
+ * The footer of one run: enums (deduplicated with `--dedupe-enums`), `--enum-values` arrays, the
+ * helper types they need, and the `operations` interface. Replaces the original's module-level
+ * `enumCache`, so runs no longer share enums (research/legacy-bugs.md, item 3).
+ */
+export class RunFooter implements DocumentFooter {
+  private readonly naming = new EnumNaming();
+  private readonly enumNamesByKey = new Map<string, string>();
+  /** Declarations added already: the same one twice fails with "Duplicate identifier". */
+  private readonly declaredEnums = new Set<string>();
+  /** The member names of each declared enum, by value. */
+  private readonly membersByEnum = new Map<string, Map<string | number, string>>();
+  /** The members of each declared enum name, by member name. */
+  private readonly declaredMembers = new Map<string, Map<string, string | number>>();
+  /** `--enum-values` arrays added already: their declared name by name, type and values. */
+  private readonly declaredEnumValues = new Map<string, string>();
+  /** The declared `--enum-values` array names. */
+  private readonly enumValuesNames = new Set<string>();
+  private readonly sink: FooterSink;
+  private readonly isDedupingEnums: boolean;
+  private readonly sharedNames: SharedEnumNames;
+
+  constructor(
+    sink: FooterSink,
+    isDedupingEnums: boolean,
+    sharedNames: SharedEnumNames = FIRST_SCHEMA_NAMES,
+  ) {
+    this.sink = sink;
+    this.isDedupingEnums = isDedupingEnums;
+    this.sharedNames = sharedNames;
+  }
+
+  addEnum(request: EnumDeclarationRequest): string {
+    // The name is built before the cache lookup: it advances the naming state either way.
+    const ownName = this.naming.enumName(request.name);
+    const key = this.isDedupingEnums ? dedupeKey(request) : null;
+    // Every schema of a shared enum goes to `sharedNames`, the later ones too.
+    const name = key === null ? ownName : this.sharedNames.nameOf(key, ownName, request);
+    const known = key === null ? undefined : this.enumNamesByKey.get(key);
+    if (known !== undefined) {
+      return known;
+    }
+    // Only a repeated member fails to compile; two empty declarations merge, so they stay.
+    const declared = request.values.length > 0 ? declarationKey(name, request) : null;
+    if (declared !== null && this.declaredEnums.has(declared)) {
+      return name;
+    }
+    if (declared !== null) {
+      this.declaredEnums.add(declared);
+    }
+    const declaration = this.withoutRepeats(enumDeclaration(name, request, this.naming));
+    if (declaration !== null) {
+      this.record(declaration);
+      this.sink.add(declaration);
+    }
+    if (key !== null) {
+      this.enumNamesByKey.set(key, name);
+    }
+    return name;
+  }
+
+  /** The declaration without members an earlier one of the name has; null when none is left. */
+  private withoutRepeats(declaration: IrEnumDeclaration): IrEnumDeclaration | null {
+    const earlier: DeclaredMembers | undefined = this.declaredMembers.get(declaration.name);
+    if (earlier === undefined) {
+      return declaration;
+    }
+    const merged = withoutDeclaredMembers(declaration, earlier);
+    // Two empty declarations merge into one empty enum, which compiles, so the second stays.
+    return merged.members.length === 0 && declaration.members.length > 0 ? null : merged;
+  }
+
+  /** The members of a declaration; the first member of a value names it. */
+  private record(declaration: IrEnumDeclaration): void {
+    const byName = this.declaredMembers.get(declaration.name) ?? new Map();
+    const byValue = this.membersByEnum.get(declaration.name) ?? new Map();
+    for (const member of declaration.members) {
+      byName.set(member.name, member.value);
+      if (!byValue.has(member.value)) {
+        byValue.set(member.value, member.name);
+      }
+    }
+    this.declaredMembers.set(declaration.name, byName);
+    this.membersByEnum.set(declaration.name, byValue);
+  }
+
+  enumMembers(name: string): ReadonlyMap<string | number, string> {
+    return this.membersByEnum.get(name) ?? new Map();
+  }
+
+  addEnumValues(request: EnumValuesRequest): void {
+    const baseName = this.naming.arrayName(request.name);
+    // The same array twice fails with "Cannot redeclare"; a schema typed twice adds it twice.
+    const declared = JSON.stringify([baseName, request.type, request.values]);
+    if (this.declaredEnumValues.has(declared)) {
+      return;
+    }
+    const name = this.freeEnumValuesName(baseName);
+    this.declaredEnumValues.set(declared, name);
+    this.enumValuesNames.add(name);
+    this.require(HELPER_TYPES.flattenedDeepRequired);
+    this.require(HELPER_TYPES.readonlyArray);
+    this.sink.add({
+      kind: "constArray",
+      name,
+      isExported: true,
+      type: readonlyArrayOf(request.type),
+      values: request.values,
+      comments: [],
+    });
+  }
+
+  /**
+   * Another array may have the name: `Discount/type` and `discount/type`, or a property and an
+   * inline `allOf` item of one schema, typed at one location. A redeclared `const` does not
+   * compile, so a later one gets the next number (`discountTypeValues_2`). Every unnumbered name
+   * ends with `Values`, so a number never takes a name that a later array needs.
+   */
+  private freeEnumValuesName(name: string): string {
+    let candidate = name;
+    for (let count = 2; this.enumValuesNames.has(candidate); count++) {
+      candidate = `${name}${ENUM_VALUES_NUMBER_SEPARATOR}${count}`;
+    }
+    return candidate;
+  }
+
+  requireWithRequired(): void {
+    this.require(HELPER_TYPES.withRequired);
+  }
+
+  requirePropertyValues(): void {
+    this.require(HELPER_TYPES.propertyValues);
+  }
+
+  addOperation(build: () => IrPropertySignature): void {
+    this.sink.addOperation(build);
+  }
+
+  private require(helper: HelperType): void {
+    if (!this.sink.hasTypeAlias(helper.name)) {
+      this.sink.add({ kind: "rawDeclaration", name: helper.name, text: helper.text });
+    }
+  }
+}
+
+function readonlyArrayOf(type: IrType): IrType {
+  return irReference(HELPER_TYPES.readonlyArray.name, [type]);
+}

package/src/application/transform/footer/enum-naming.ts

@@ -0,0 +1,210 @@
+import { ERROR_CODES, OpenAPITypesafeError } from "../../../domain/errors.js";
+import type { IrComment, IrEnumDeclaration } from "../../../domain/ir/nodes.js";
+import { withNumberedRepeats } from "../numbered-names.js";
+
+const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z_$0-9]*$/;
+/** A run of invalid characters and the character after it, which starts the next word. */
+const INVALID_RUN_THEN_CHARACTER_RE = /[^A-Za-z_$0-9]+(.)?/g;
+const INVALID_RUN_RE = /[^A-Za-z_$0-9]+/;
+const INVALID_RUNS_RE = /[^A-Za-z_$0-9]+/g;
+const INVALID_CHARACTER_RE = /[^A-Za-z_$0-9]/;
+const STARTS_WITH_DIGIT_RE = /^[0-9]/;
+/** Invalid character runs with a readable replacement; any other run becomes `_`. */
+const SPECIAL_CHARACTERS: ReadonlyMap<string, string> = new Map([["+", "Plus"]]);
+const NUMBER_PREFIX = "Value";
+const NEGATIVE_PREFIX = "ValueMinus";
+
+export class EmptyEnumNameError extends OpenAPITypesafeError {
+  constructor(name: string) {
+    super({
+      code: ERROR_CODES.ENUM_NAME_EMPTY,
+      message: `Cannot build an enum or enum values name from "${name}": no valid characters`,
+      details: { name },
+    });
+    this.name = "EmptyEnumNameError";
+  }
+}
+
+/** Metadata of one enum member (`x-enum-varnames`, `x-enum-descriptions`). */
+export interface EnumMemberNaming {
+  readonly name?: string | undefined;
+  readonly description?: string | null | undefined;
+}
+
+/**
+ * Names of `--enum` declarations, their members and `--enum-values` arrays, as the original
+ * builds them. One instance per run.
+ *
+ * The original checks the character after an invalid run with a global regex and `.test()`,
+ * which keeps `lastIndex`: after a check that finds an invalid character, the next check fails,
+ * and a later member name with invalid characters resets it. `isNextCheckSkipped` keeps that
+ * behavior within a run (research/legacy-bugs.md, item 2; fixed in Phase 7).
+ */
+export class EnumNaming {
+  private isNextCheckSkipped = false;
+
+  /** `my-status` → `MyStatus`. */
+  enumName(name: string): string {
+    const sanitized = this.sanitize(name);
+    return `${firstCharacter(sanitized, name).toUpperCase()}${sanitized.substring(1)}`;
+  }
+
+  /** `MyStatusValues` → `myStatusValues`. */
+  arrayName(name: string): string {
+    const sanitized = this.sanitize(name);
+    return `${firstCharacter(sanitized, name).toLowerCase()}${sanitized.substring(1)}`;
+  }
+
+  /** A member name: a valid identifier, a rewritten one, or a quoted name. */
+  memberName(value: string | number, metadata: EnumMemberNaming = {}): string {
+    const name = metadata.name ?? String(value);
+    if (IDENTIFIER_RE.test(name)) {
+      return name;
+    }
+    // The original runs a global `match` here, which resets the regex state.
+    this.isNextCheckSkipped = false;
+    const prefixed = prefixedMemberName(name);
+    const invalidRun = INVALID_RUN_RE.exec(prefixed);
+    if (!invalidRun) {
+      // Only the empty name has no invalid run and is no identifier (upstream #2807).
+      return prefixed === "" ? quotedMemberName(prefixed) : prefixed;
+    }
+    return invalidRun[0] === prefixed
+      ? quotedMemberName(prefixed)
+      : prefixed.replace(INVALID_RUNS_RE, (run) => SPECIAL_CHARACTERS.get(run) ?? "_");
+  }
+
+  private sanitize(name: string): string {
+    const sanitized = name.replace(INVALID_RUN_THEN_CHARACTER_RE, (run) => {
+      const next = run.charAt(run.length - 1);
+      return this.isInvalid(next) ? "" : next.toUpperCase();
+    });
+    // The original prefixed the unsanitized name, which kept invalid characters after a leading
+    // digit, and missed a digit that only became first after sanitizing (research/legacy-bugs.md,
+    // item 15). Prefixing the sanitized name gives the same name wherever the original was valid.
+    return STARTS_WITH_DIGIT_RE.test(sanitized) ? `${NUMBER_PREFIX}${sanitized}` : sanitized;
+  }
+
+  private isInvalid(character: string): boolean {
+    if (this.isNextCheckSkipped) {
+      this.isNextCheckSkipped = false;
+      return false;
+    }
+    this.isNextCheckSkipped = INVALID_CHARACTER_RE.test(character);
+    return this.isNextCheckSkipped;
+  }
+}
+
+function firstCharacter(sanitized: string, name: string): string {
+  const first = sanitized[0];
+  if (first === undefined) {
+    throw new EmptyEnumNameError(name);
+  }
+  return first;
+}
+
+/**
+ * A string-literal member name. The original wrapped the name in quotes without escaping, so `\`
+ * and `"` gave invalid output (upstream #2614); a JSON string is a valid TypeScript string.
+ */
+export function quotedMemberName(name: string): string {
+  return JSON.stringify(name);
+}
+
+function prefixedMemberName(name: string): string {
+  if (Number(name[0]) >= 0) {
+    // Only the first dot: `1.5` → `Value1_5`.
+    return `${NUMBER_PREFIX}${name}`.replace(".", "_");
+  }
+  return name[0] === "-" ? `${NEGATIVE_PREFIX}${name.slice(1)}` : name;
+}
+
+/** Every line terminator of JavaScript, which would end a `//` comment. */
+const LINE_TERMINATORS_RE = /\r\n|[\n\r\u2028\u2029]/g;
+
+/** The text of a member's `//` comment: trimmed, on one line; empty when there is none. */
+export function enumMemberDescription(description: string | null | undefined): string {
+  return description?.trim().replace(LINE_TERMINATORS_RE, " ") ?? "";
+}
+
+/**
+ * The member comment: the trimmed description as a line comment, as in the original. Line breaks
+ * become spaces: in a `//` comment they ended the comment early (upstream #2838).
+ */
+function enumMemberComments(metadata: EnumMemberNaming = {}): IrComment[] {
+  const description = enumMemberDescription(metadata.description);
+  return description ? [{ kind: "line", text: ` ${description}` }] : [];
+}
+
+/** The members of an enum, by value, with optional metadata at the same index. */
+export interface EnumMembers {
+  readonly values: readonly (string | number)[];
+  readonly metadata: readonly (EnumMemberNaming | undefined)[];
+}
+
+/** Separates a repeated member name from its number: `reactions_1` → `reactions_1_2`. */
+const MEMBER_NUMBER_SEPARATOR = "_";
+
+/** The `count`-th use of a member name; a quoted name gets the number inside the quotes. */
+function numberedMemberName(name: string, count: number): string {
+  const isQuoted = name.startsWith('"');
+  const raw = isQuoted ? (JSON.parse(name) as string) : name;
+  const numbered = `${raw}${MEMBER_NUMBER_SEPARATOR}${count}`;
+  return isQuoted ? quotedMemberName(numbered) : numbered;
+}
+
+/**
+ * An exported enum with an already built `name`; member names advance the naming state. Values
+ * whose names come out the same (`reactions-+1` and `reactions--1` are both `reactions_1`) would
+ * not compile, so a repeated name gets a number (`reactions_1_2`).
+ */
+export function enumDeclaration(
+  name: string,
+  members: EnumMembers,
+  naming: EnumNaming,
+): IrEnumDeclaration {
+  const names = members.values.map((value, index) =>
+    naming.memberName(value, members.metadata[index]),
+  );
+  const uniqueNames = withNumberedRepeats(names, numberedMemberName);
+  return {
+    kind: "enum",
+    name,
+    isExported: true,
+    members: members.values.map((value, index) => ({
+      name: uniqueNames[index] as string,
+      value,
+      comments: enumMemberComments(members.metadata[index]),
+    })),
+    comments: [],
+  };
+}
+
+/** The member names an enum name has so far, with their values. */
+export type DeclaredMembers = ReadonlyMap<string, string | number>;
+
+/**
+ * A later declaration of an enum name merges with the earlier ones, and a member name declared
+ * twice does not compile (TS2300): a property and an inline `allOf` item of one schema give one
+ * name. A member that repeats one by name and value is left out; one whose name another value has
+ * gets the next free number (`a_b_2`).
+ */
+export function withoutDeclaredMembers(
+  declaration: IrEnumDeclaration,
+  declared: DeclaredMembers,
+): IrEnumDeclaration {
+  const taken = new Set(declared.keys());
+  const members: IrEnumDeclaration["members"][number][] = [];
+  for (const member of declaration.members) {
+    if (declared.get(member.name) === member.value) {
+      continue;
+    }
+    let name = member.name;
+    for (let count = 2; taken.has(name); count++) {
+      name = numberedMemberName(member.name, count);
+    }
+    taken.add(name);
+    members.push(name === member.name ? member : { ...member, name });
+  }
+  return { ...declaration, members };
+}