openapi-typesafe 0.0.0 → 1.0.0-rc.0

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

@@ -0,0 +1,181 @@
+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: [],
+  };
+}

package/src/application/transform/helper-types.ts

@@ -0,0 +1,92 @@
+/**
+ * The helper type aliases the generator adds to the footer, declared once each. The text is the
+ * original's source text as the TypeScript printer printed it, so printing it as written gives
+ * the original output (ENGINEERING_PLAN 6.2 and 6.6), except for the fixes noted below.
+ */
+export interface HelperType {
+  readonly name: string;
+  readonly text: string;
+}
+
+function lines(...parts: readonly string[]): string {
+  return parts.join("\n");
+}
+
+export const HELPER_TYPES = {
+  withRequired: {
+    name: "WithRequired",
+    text: lines("type WithRequired<T, K extends keyof T> = T & {", "    [P in K]-?: T[P];", "};"),
+  },
+  // `unevaluated-properties` (roadmap R11): the value types of every member of a union, so a
+  // `$ref` to a `oneOf` schema gives the values of each variant, not only of the shared keys.
+  propertyValues: {
+    name: "PropertyValues",
+    text: "type PropertyValues<T> = T extends unknown ? T[keyof T] : never;",
+  },
+  // Task 7.4 changes the original text on purpose: `readonly unknown[]` also flattens the arrays
+  // of `--immutable` (upstream #2714, #2749), and `NonNullable` looks through nullable parents
+  // (upstream #2737). The old text did not compile for those schemas.
+  flattenedDeepRequired: {
+    name: "FlattenedDeepRequired",
+    text: lines(
+      "type FlattenedDeepRequired<T> = {",
+      "    [K in keyof T]-?: FlattenedDeepRequired<T[K] extends readonly unknown[] | undefined | " +
+        "null ? Extract<T[K], readonly unknown[]>[number] : NonNullable<T[K]>>;",
+      "};",
+    ),
+  },
+  // `readonly unknown[]`: a readonly array value type stays as is (upstream #2749).
+  readonlyArray: {
+    name: "ReadonlyArray",
+    text: lines(
+      "type ReadonlyArray<T> = [",
+      "    Exclude<T, undefined>",
+      "] extends [",
+      "    readonly unknown[]",
+      "] ? Readonly<Exclude<T, undefined>> : Readonly<Exclude<T, undefined>[]>;",
+    ),
+  },
+} as const satisfies Readonly<Record<string, HelperType>>;
+
+/**
+ * The `--read-write-markers` helper types, written before the root types. Task 7.6 replaces the
+ * original text on purpose (ADR-014): primitives (also branded), readonly arrays, tuples,
+ * intersected arrays and null-only properties keep their types (upstream #2615, #2620, #2632,
+ * #2717, #2765). The declarations equal `Readable` / `Writable` of openapi-typesafe-helpers
+ * (`test/api/read-write-marker-types.test.ts`); the text is what the TypeScript printer prints.
+ */
+export const READ_WRITE_MARKER_TYPES = lines(
+  "export type $Read<T> = {",
+  "    readonly $read: T;",
+  "};",
+  "export type $Write<T> = {",
+  "    readonly $write: T;",
+  "};",
+  "type ReadWritePrimitive = string | number | boolean | bigint | symbol | null | undefined;",
+  "type ReadWriteLeaf = ReadWritePrimitive | ((...args: never) => unknown);",
+  "type ReadWriteMarkedKeys<T, Marker> = {",
+  "    [K in keyof T]-?: NonNullable<T[K]> extends never ? never : NonNullable<T[K]> " +
+    "extends Marker ? K : never;",
+  "}[keyof T];",
+  'type ReadWriteResolveArray<T extends readonly unknown[], Resolved extends "read" | ' +
+    '"write"> = T[number][] extends T ? T extends unknown[] ? ReadWriteResolve<T[number], ' +
+    "Resolved>[] : readonly ReadWriteResolve<T[number], Resolved>[] : {",
+  "    [K in keyof T]: ReadWriteResolve<T[K], Resolved>;",
+  "};",
+  'type ReadWriteResolve<T, Resolved extends "read" | "write"> = Resolved extends "read" ? ' +
+    "Readable<T> : Writable<T>;",
+  "export type Readable<T> = T extends $Write<any> ? never : T extends $Read<infer U> ? " +
+    "Readable<U> : T extends ReadWriteLeaf ? T : T extends readonly unknown[] ? " +
+    'ReadWriteResolveArray<T, "read"> : T extends object ? {',
+  "    [K in keyof T as K extends ReadWriteMarkedKeys<T, $Write<any>> ? never : K]: " +
+    "Readable<T[K]>;",
+  "} : T;",
+  "export type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? " +
+    "Writable<U> : T extends ReadWriteLeaf ? T : T extends readonly unknown[] ? " +
+    'ReadWriteResolveArray<T, "write"> : T extends object ? {',
+  "    [K in keyof T as K extends ReadWriteMarkedKeys<T, $Read<any>> ? never : K]: " +
+    "Writable<T[K]>;",
+  "} & {",
+  "    [K in ReadWriteMarkedKeys<T, $Read<any>>]?: never;",
+  "} : T;",
+);

package/src/application/transform/literal-type.ts

@@ -0,0 +1,54 @@
+import {
+  irArray,
+  irBoolean,
+  irKeyword,
+  irNumber,
+  irObject,
+  irProperty,
+  irRaw,
+  irRecord,
+  irString,
+  irTuple,
+  irTupleElement,
+} from "../../domain/ir/constructors.js";
+import type { IrType } from "../../domain/ir/nodes.js";
+import { toPropertyName } from "../../domain/ir/property-name.js";
+import { UNKNOWN_TYPE } from "./shared-types.js";
+
+function objectLiteralType(value: object): IrType {
+  const members = Object.entries(value).map(([key, entry]) =>
+    irProperty(toPropertyName(key), literalType(entry)),
+  );
+  return members.length > 0 ? irObject(members) : irRecord(irKeyword("string"), irKeyword("never"));
+}
+
+function arrayLiteralType(value: readonly unknown[]): IrType {
+  return value.length === 0
+    ? irArray(irKeyword("never"))
+    : irTuple(value.map((item) => irTupleElement(literalType(item))));
+}
+
+/**
+ * The literal type of a JSON value (the original `tsLiteral`): strings as JSON text, arrays as
+ * tuples (an empty one as `never[]`), objects as object types (an empty one as
+ * `Record<string, never>`), and anything else (`undefined`, functions) as `unknown`.
+ */
+export function literalType(value: unknown): IrType {
+  if (typeof value === "string") {
+    return irString(value, "json");
+  }
+  if (typeof value === "number") {
+    // YAML `.nan` and `.inf` have no literal type; the original prints them as `NaN`, `-Infinity`.
+    return Number.isFinite(value) ? irNumber(value) : irRaw(String(value));
+  }
+  if (typeof value === "boolean") {
+    return irBoolean(value);
+  }
+  if (value === null) {
+    return irKeyword("null");
+  }
+  if (Array.isArray(value)) {
+    return arrayLiteralType(value);
+  }
+  return typeof value === "object" ? objectLiteralType(value) : UNKNOWN_TYPE;
+}

package/src/application/transform/numbered-names.ts

@@ -0,0 +1,20 @@
+/** Builds the name for the `count`-th use of `name` (2, 3…). */
+export type NumberedName = (name: string, count: number) => string;
+
+/**
+ * Names made unique, in order: the first use of a name keeps it, each repeat gets the lowest
+ * number from 2 whose name is not written anywhere in the list.
+ */
+export function withNumberedRepeats(names: readonly string[], numbered: NumberedName): string[] {
+  const written = new Set(names);
+  const taken = new Set<string>();
+  return names.map((name) => {
+    let unique = name;
+    for (let count = 2; taken.has(unique); count += 1) {
+      const candidate = numbered(name, count);
+      unique = written.has(candidate) ? unique : candidate;
+    }
+    taken.add(unique);
+    return unique;
+  });
+}

package/src/application/transform/ref-type.ts

@@ -0,0 +1,97 @@
+import { ERROR_CODES, OpenAPITypesafeError } from "../../domain/errors.js";
+import {
+  irIndexedAccess,
+  irKeyword,
+  irObject,
+  irProperty,
+  irReference,
+  irString,
+} from "../../domain/ir/constructors.js";
+import type { IrType } from "../../domain/ir/nodes.js";
+import { parseRefPointer } from "../../domain/openapi/json-pointer.js";
+
+/** Where a referenced parameter lives in the generated `parameters` type. */
+export interface RefParameterTarget {
+  readonly in: string;
+  readonly name: string;
+}
+
+export interface RefTypeOptions {
+  /** Wrap the root in `FlattenedDeepRequired<…>`. */
+  readonly isDeep?: boolean;
+  /** Segments to narrow with `Extract<T, { segment: unknown }>` before indexing. */
+  readonly extractProperties?: readonly string[];
+  /** Set when the `$ref` resolves to a parameter object: its last segment indexes `in`, `name`. */
+  readonly parameter?: RefParameterTarget | null;
+}
+
+export class InvalidRefError extends OpenAPITypesafeError {
+  constructor(ref: string) {
+    super({
+      code: ERROR_CODES.SCHEMA_REF_INVALID,
+      message: `Error parsing $ref: ${ref}. Is this a valid $ref?`,
+      details: { ref },
+    });
+    this.name = "InvalidRefError";
+  }
+}
+
+/** Segments that index into the root type, always as escaped string literal types. */
+function indexBy(type: IrType, ...segments: readonly string[]): IrType {
+  return segments.reduce<IrType>(
+    (object, segment) => irIndexedAccess(object, irString(segment, "escaped")),
+    type,
+  );
+}
+
+/** `Extract<T, { name: unknown }>`; the name is written as an identifier, as in the original. */
+function extractVariantsWith(type: IrType, propertyName: string): IrType {
+  const probe = irProperty({ kind: "identifier", text: propertyName }, irKeyword("unknown"));
+  return irReference("Extract", [type, irObject([probe])]);
+}
+
+const DEFS_KEYWORD = "$defs";
+
+/**
+ * Index by `segment`. A `$defs` member is optional (it is a keyword, not data), so when more
+ * segments follow it is wrapped in `NonNullable<…>` first; otherwise the next index fails on
+ * `undefined` (upstream #2664).
+ */
+function indexKeyword(type: IrType, segment: string, isLast: boolean): IrType {
+  const indexed = indexBy(type, segment);
+  return segment === DEFS_KEYWORD && !isLast ? irReference("NonNullable", [indexed]) : indexed;
+}
+
+function rootType(rootSegment: string, isDeep: boolean): IrType {
+  return irReference(isDeep ? `FlattenedDeepRequired<${rootSegment}>` : rootSegment);
+}
+
+/**
+ * The indexed-access type of a `$ref` into the generated types (the original `oapiRef`), for
+ * example `components["schemas"]["Foo"]`. The first three segments index directly. After them,
+ * `properties` segments are skipped (objects are flattened, upstream issue 1742), a parameter's
+ * last segment becomes `[in][name]`, and listed segments are narrowed with `Extract` first.
+ *
+ * Throws InvalidRefError when the `$ref` has no pointer.
+ */
+export function refType(ref: string, options: RefTypeOptions = {}): IrType {
+  const [rootSegment, ...pointer] = parseRefPointer(ref);
+  if (rootSegment === undefined) {
+    throw new InvalidRefError(ref);
+  }
+  const extracted = new Set(options.extractProperties ?? []);
+  const lastIndex = pointer.length - 1;
+  const leading = indexBy(rootType(rootSegment, options.isDeep ?? false), ...pointer.slice(0, 2));
+  return pointer.slice(2).reduce<IrType>((type, segment, offset) => {
+    if (segment === "properties") {
+      return type;
+    }
+    if (options.parameter && offset + 2 === lastIndex) {
+      return indexBy(type, options.parameter.in, options.parameter.name);
+    }
+    const isLast = offset + 2 === lastIndex;
+    return extracted.has(segment)
+      ? indexBy(extractVariantsWith(type, segment), segment)
+      : indexKeyword(type, segment, isLast);
+  }, leading);
+}

package/src/application/transform/schema/array-type.ts

@@ -0,0 +1,152 @@
+import { irArray, irReadonly, irTuple, irTupleElement } from "../../../domain/ir/constructors.js";
+import type { IrType } from "../../../domain/ir/nodes.js";
+import type { SchemaObject } from "../../../domain/openapi/schema-object.js";
+import { OutputFix } from "../../../domain/output-fixes.js";
+import { UNKNOWN_TYPE } from "../shared-types.js";
+import { unionOf } from "../type-combinators.js";
+import type { SchemaRequest } from "./schema-rule.js";
+
+/**
+ * `--array-length` writes tuples only while the estimated number of tuple elements stays below
+ * this; the original chose it as roughly where TypeScript starts to struggle with tuple inference.
+ */
+const MAX_LENGTH_TUPLE_ELEMENTS = 30;
+
+/** The tuple of `prefixItems` (or of an `items` list); null without either. */
+function prefixTupleType(schema: SchemaObject, request: SchemaRequest): IrType | null {
+  const { items } = schema;
+  if (!schema.prefixItems && !Array.isArray(items)) {
+    return null;
+  }
+  const prefixItems = schema.prefixItems ?? (items as SchemaObject[]);
+  return irTuple(
+    prefixItems.map((item) => irTupleElement(request.transformNested(item, request.location))),
+  );
+}
+
+/** The type of one item; `unknown` without `items`. */
+function singleItemType(schema: SchemaObject, request: SchemaRequest): IrType {
+  const { items } = schema;
+  return items ? request.transformNested(items as SchemaObject, request.location) : UNKNOWN_TYPE;
+}
+
+/**
+ * The item type as the original returns it: a tuple stands for the whole array, and a nested
+ * `type: array` item is wrapped in an array here already.
+ */
+function itemType(schema: SchemaObject, request: SchemaRequest): IrType {
+  const tuple = prefixTupleType(schema, request);
+  if (tuple !== null) {
+    return tuple;
+  }
+  const { items } = schema;
+  // Checked first: the `in` test below throws for `items: null`.
+  if (!items) {
+    return UNKNOWN_TYPE;
+  }
+  const nested = singleItemType(schema, request);
+  const isNestedArray = typeof items === "object" && "type" in items && items.type === "array";
+  return isNestedArray ? irArray(nested) : nested;
+}
+
+function repeat(type: IrType, count: number): IrType[] {
+  return Array.from({ length: count }, () => type);
+}
+
+interface LengthBounds {
+  readonly min: number;
+  readonly max: number | undefined;
+}
+
+function lengthBounds(schema: SchemaObject): LengthBounds {
+  const { minItems, maxItems } = schema;
+  const min = typeof minItems === "number" && minItems >= 0 ? minItems : 0;
+  const isMaxValid = typeof maxItems === "number" && maxItems >= 0 && min <= maxItems;
+  return { min, max: isMaxValid ? maxItems : undefined };
+}
+
+/**
+ * Tuples for `--array-length`, as the original builds them. With both bounds it emits tuples of
+ * length 0 to `max - min` (not `min` to `max`); the `array-length-tuples` fix corrects it.
+ */
+function lengthTupleType(schema: SchemaObject, item: IrType, bounds: LengthBounds): IrType {
+  const { min, max } = bounds;
+  if (min === max) {
+    return unionOf([irTuple(repeat(item, min).map((type) => irTupleElement(type)))]);
+  }
+  if ((schema.maxItems as number) > 0) {
+    const lengths = Array.from({ length: Math.max(0, (max ?? 0) - min + 1) }, (_, index) => index);
+    return unionOf(
+      lengths.map((length) => irTuple(repeat(item, length).map((type) => irTupleElement(type)))),
+    );
+  }
+  const elements = repeat(item, min).map((type) => irTupleElement(type));
+  return irTuple([...elements, irTupleElement(irArray(item), true)]);
+}
+
+function isLengthTupleWanted(bounds: LengthBounds, request: SchemaRequest): boolean {
+  const { min, max } = bounds;
+  const estimatedSize = max === undefined ? min : (max * (max + 1) - min * (min - 1)) / 2;
+  const hasBounds = min !== 0 || max !== undefined;
+  return (
+    request.context.options.arrayLength && hasBounds && estimatedSize < MAX_LENGTH_TUPLE_ELEMENTS
+  );
+}
+
+/** Applies `--immutable` to one array or tuple type. */
+type ArrayWrapper = (type: IrType) => IrType;
+
+function tupleOf(item: IrType, length: number, isOpen: boolean): IrType {
+  const elements = repeat(item, length).map((type) => irTupleElement(type));
+  return irTuple(isOpen ? [...elements, irTupleElement(irArray(item), true)] : elements);
+}
+
+/** Tuples of every length from `min` to `max`; without `max`, `min` items and a rest element. */
+function fixedLengthTupleType(item: IrType, bounds: LengthBounds, wrap: ArrayWrapper): IrType {
+  const { min, max } = bounds;
+  if (max === undefined) {
+    return wrap(tupleOf(item, min, true));
+  }
+  const lengths = Array.from({ length: max - min + 1 }, (_, index) => min + index);
+  return unionOf(lengths.map((length) => wrap(tupleOf(item, length, false))));
+}
+
+/**
+ * `type: array` with `--array-length` and the `array-length-tuples` fix (#2048, #2330, #2546):
+ * the tuples have `min` to `max` items, the item type is used as it is (a nested array stays one
+ * level deep), a `prefixItems` tuple gets no length tuples around it, and `--immutable` makes
+ * every tuple `readonly`.
+ */
+function fixedArrayType(schema: SchemaObject, request: SchemaRequest): IrType {
+  const wrap: ArrayWrapper = (type) =>
+    request.context.options.immutable ? irReadonly(type) : type;
+  const tuple = prefixTupleType(schema, request);
+  if (tuple !== null) {
+    return wrap(tuple);
+  }
+  const item = singleItemType(schema, request);
+  const bounds = lengthBounds(schema);
+  return isLengthTupleWanted(bounds, request)
+    ? fixedLengthTupleType(item, bounds, wrap)
+    : wrap(irArray(item));
+}
+
+function isArrayLengthFixed(request: SchemaRequest): boolean {
+  const { arrayLength, fixes } = request.context.options;
+  return arrayLength && fixes.has(OutputFix.ARRAY_LENGTH_TUPLES);
+}
+
+/** `type: array`, including tuples (`prefixItems`, array `items`) and `--array-length`. */
+export function arrayType(schema: SchemaObject, request: SchemaRequest): IrType {
+  if (isArrayLengthFixed(request)) {
+    return fixedArrayType(schema, request);
+  }
+  const item = itemType(schema, request);
+  const bounds = lengthBounds(schema);
+  if (isLengthTupleWanted(bounds, request)) {
+    return lengthTupleType(schema, item, bounds);
+  }
+  // A tuple or an array item is used as the array type itself.
+  const type = item.kind === "tuple" || item.kind === "array" ? item : irArray(item);
+  return request.context.options.immutable ? irReadonly(type) : type;
+}