eslint-plugin-ts-type-forge 0.2.0 → 0.3.1

package/dist/rules/tuple-rule-utils.mjs

@@ -0,0 +1,56 @@
+import { TS_TYPE_FORGE_MODULE } from './constants.mjs';
+import { buildTypeImportFix, getImportedLocalName, getTsTypeForgeImports, hasConflictingDeclaration } from './import-utils.mjs';
+
+const DEFAULT_IMPORT_STYLE = "global";
+const IMPORT_STYLE_SCHEMA_PROPERTY = {
+  type: "string",
+  enum: ["global", "named"],
+  description: [
+    "How the ts-type-forge type is brought into scope.",
+    "'global' (default) assumes the ambient globals of",
+    "`ts-type-forge/global` and never touches imports;",
+    "'named' makes the autofix add the corresponding",
+    `\`import { type \u2026 } from '${TS_TYPE_FORGE_MODULE}';\``,
+    "when the name is not imported yet."
+  ].join(" ")
+};
+const resolveTypeName = (program, canonicalName, importStyle) => {
+  const importedLocalName = getImportedLocalName(
+    getTsTypeForgeImports(program),
+    canonicalName
+  );
+  if (importedLocalName !== void 0) {
+    return { localName: importedLocalName, needsImport: false };
+  }
+  return hasConflictingDeclaration(program, canonicalName) ? void 0 : { localName: canonicalName, needsImport: importStyle === "named" };
+};
+const reportTupleRewrites = (context, rewrites, messageId, importStyle) => {
+  const sourceCode = context.sourceCode;
+  const program = sourceCode.ast;
+  const resolved = rewrites.flatMap((rewrite) => {
+    const target = resolveTypeName(program, rewrite.canonicalName, importStyle);
+    return target === void 0 ? [] : [{ rewrite, target }];
+  });
+  const importNames = Array.from(
+    new Set(
+      resolved.filter(({ target }) => target.needsImport).map(({ rewrite }) => rewrite.canonicalName)
+    )
+  );
+  for (const [index, { rewrite, target }] of resolved.entries()) {
+    const replacement = `${target.localName}<${rewrite.typeArgs}>`;
+    context.report({
+      node: rewrite.node,
+      messageId,
+      data: { original: sourceCode.getText(rewrite.node), replacement },
+      fix: (fixer) => [
+        ...index === 0 ? importNames.flatMap(
+          (name) => buildTypeImportFix(fixer, program, name)
+        ) : [],
+        fixer.replaceText(rewrite.node, replacement)
+      ]
+    });
+  }
+};
+
+export { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY, reportTupleRewrites, resolveTypeName };
+//# sourceMappingURL=tuple-rule-utils.mjs.map

package/dist/rules/tuple-rule-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple-rule-utils.mjs","sources":["../../src/rules/tuple-rule-utils.mts"],"sourcesContent":["import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';\nimport { TS_TYPE_FORGE_MODULE } from './constants.mjs';\nimport {\n  buildTypeImportFix,\n  getImportedLocalName,\n  getTsTypeForgeImports,\n  hasConflictingDeclaration,\n} from './import-utils.mjs';\n\n/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */\n\n/** `JSONSchema4`, reached through the public rule-module types. */\ntype JsonSchema = Exclude<\n  TSESLint.RuleModule<string, readonly unknown[]>['meta']['schema'],\n  readonly unknown[]\n>;\n\nexport type ImportStyle = 'global' | 'named';\n\nexport const DEFAULT_IMPORT_STYLE: ImportStyle = 'global';\n\nexport const IMPORT_STYLE_SCHEMA_PROPERTY: JsonSchema = {\n  type: 'string',\n  enum: ['global', 'named'],\n  description: [\n    'How the ts-type-forge type is brought into scope.',\n    \"'global' (default) assumes the ambient globals of\",\n    '`ts-type-forge/global` and never touches imports;',\n    \"'named' makes the autofix add the corresponding\",\n    `\\`import { type … } from '${TS_TYPE_FORGE_MODULE}';\\``,\n    'when the name is not imported yet.',\n  ].join(' '),\n};\n\n/**\n * Resolves how a ts-type-forge type name should be written in this file, and\n * whether the autofix has to add an import for it.\n *\n * Returns `undefined` when the name is already bound to something else (a local\n * alias, or an import from another module) — rewriting to it would then silently\n * resolve to the wrong declaration, which is exactly what happens inside\n * ts-type-forge's own sources.\n */\nexport const resolveTypeName = (\n  program: TSESTree.Program,\n  canonicalName: string,\n  importStyle: ImportStyle,\n): Readonly<{ localName: string; needsImport: boolean }> | undefined => {\n  const importedLocalName = getImportedLocalName(\n    getTsTypeForgeImports(program),\n    canonicalName,\n  );\n\n  if (importedLocalName !== undefined) {\n    return { localName: importedLocalName, needsImport: false };\n  }\n\n  return hasConflictingDeclaration(program, canonicalName)\n    ? undefined\n    : { localName: canonicalName, needsImport: importStyle === 'named' };\n};\n\nexport type TupleRewrite = Readonly<{\n  node: TSESTree.Node;\n  canonicalName: string;\n  /** Text inside the `<...>` of the replacement, e.g. `'2, string'`. */\n  typeArgs: string;\n}>;\n\n/**\n * Emits one report per rewrite, resolving each target name and attaching every\n * required import to the *first* report.\n *\n * All import fixes must live on a single report: `insertTextBefore(program, …)`\n * produces overlapping ranges, and ESLint merges each report's fixes into one\n * span — so spreading them across reports makes the fixes conflict and only one\n * survives per pass.\n */\nexport const reportTupleRewrites = <MessageIds extends string>(\n  context: TSESLint.RuleContext<MessageIds, readonly unknown[]>,\n  rewrites: readonly TupleRewrite[],\n  messageId: MessageIds,\n  importStyle: ImportStyle,\n): void => {\n  const sourceCode = context.sourceCode;\n\n  const program = sourceCode.ast;\n\n  const resolved = rewrites.flatMap((rewrite) => {\n    const target = resolveTypeName(program, rewrite.canonicalName, importStyle);\n\n    // The name is already bound to something else in this file, so the rewrite\n    // would resolve to the wrong declaration.\n    return target === undefined ? [] : [{ rewrite, target }];\n  });\n\n  const importNames = Array.from(\n    new Set(\n      resolved\n        .filter(({ target }) => target.needsImport)\n        .map(({ rewrite }) => rewrite.canonicalName),\n    ),\n  );\n\n  for (const [index, { rewrite, target }] of resolved.entries()) {\n    const replacement = `${target.localName}<${rewrite.typeArgs}>`;\n\n    context.report({\n      node: rewrite.node,\n      messageId,\n      data: { original: sourceCode.getText(rewrite.node), replacement },\n      fix: (fixer) => [\n        ...(index === 0\n          ? importNames.flatMap((name) =>\n              buildTypeImportFix(fixer, program, name),\n            )\n          : []),\n        fixer.replaceText(rewrite.node, replacement),\n      ],\n    });\n  }\n};\n\n/* eslint-enable @typescript-eslint/prefer-readonly-parameter-types */\n"],"names":[],"mappings":";;;AAmBO,MAAM,oBAAA,GAAoC;AAE1C,MAAM,4BAAA,GAA2C;AAAA,EACtD,IAAA,EAAM,QAAA;AAAA,EACN,IAAA,EAAM,CAAC,QAAA,EAAU,OAAO,CAAA;AAAA,EACxB,WAAA,EAAa;AAAA,IACX,mDAAA;AAAA,IACA,mDAAA;AAAA,IACA,mDAAA;AAAA,IACA,iDAAA;AAAA,IACA,kCAA6B,oBAAoB,CAAA,IAAA,CAAA;AAAA,IACjD;AAAA,GACF,CAAE,KAAK,GAAG;AACZ;AAWO,MAAM,eAAA,GAAkB,CAC7B,OAAA,EACA,aAAA,EACA,WAAA,KACsE;AACtE,EAAA,MAAM,iBAAA,GAAoB,oBAAA;AAAA,IACxB,sBAAsB,OAAO,CAAA;AAAA,IAC7B;AAAA,GACF;AAEA,EAAA,IAAI,sBAAsB,MAAA,EAAW;AACnC,IAAA,OAAO,EAAE,SAAA,EAAW,iBAAA,EAAmB,WAAA,EAAa,KAAA,EAAM;AAAA,EAC5D;AAEA,EAAA,OAAO,yBAAA,CAA0B,OAAA,EAAS,aAAa,CAAA,GACnD,MAAA,GACA,EAAE,SAAA,EAAW,aAAA,EAAe,WAAA,EAAa,WAAA,KAAgB,OAAA,EAAQ;AACvE;AAkBO,MAAM,mBAAA,GAAsB,CACjC,OAAA,EACA,QAAA,EACA,WACA,WAAA,KACS;AACT,EAAA,MAAM,aAAa,OAAA,CAAQ,UAAA;AAE3B,EAAA,MAAM,UAAU,UAAA,CAAW,GAAA;AAE3B,EAAA,MAAM,QAAA,GAAW,QAAA,CAAS,OAAA,CAAQ,CAAC,OAAA,KAAY;AAC7C,IAAA,MAAM,MAAA,GAAS,eAAA,CAAgB,OAAA,EAAS,OAAA,CAAQ,eAAe,WAAW,CAAA;AAI1E,IAAA,OAAO,MAAA,KAAW,SAAY,EAAC,GAAI,CAAC,EAAE,OAAA,EAAS,QAAQ,CAAA;AAAA,EACzD,CAAC,CAAA;AAED,EAAA,MAAM,cAAc,KAAA,CAAM,IAAA;AAAA,IACxB,IAAI,GAAA;AAAA,MACF,QAAA,CACG,MAAA,CAAO,CAAC,EAAE,QAAO,KAAM,MAAA,CAAO,WAAW,CAAA,CACzC,IAAI,CAAC,EAAE,OAAA,EAAQ,KAAM,QAAQ,aAAa;AAAA;AAC/C,GACF;AAEA,EAAA,KAAA,MAAW,CAAC,OAAO,EAAE,OAAA,EAAS,QAAQ,CAAA,IAAK,QAAA,CAAS,OAAA,EAAQ,EAAG;AAC7D,IAAA,MAAM,cAAc,CAAA,EAAG,MAAA,CAAO,SAAS,CAAA,CAAA,EAAI,QAAQ,QAAQ,CAAA,CAAA,CAAA;AAE3D,IAAA,OAAA,CAAQ,MAAA,CAAO;AAAA,MACb,MAAM,OAAA,CAAQ,IAAA;AAAA,MACd,SAAA;AAAA,MACA,IAAA,EAAM,EAAE,QAAA,EAAU,UAAA,CAAW,QAAQ,OAAA,CAAQ,IAAI,GAAG,WAAA,EAAY;AAAA,MAChE,GAAA,EAAK,CAAC,KAAA,KAAU;AAAA,QACd,GAAI,KAAA,KAAU,CAAA,GACV,WAAA,CAAY,OAAA;AAAA,UAAQ,CAAC,IAAA,KACnB,kBAAA,CAAmB,KAAA,EAAO,SAAS,IAAI;AAAA,YAEzC,EAAC;AAAA,QACL,KAAA,CAAM,WAAA,CAAY,OAAA,CAAQ,IAAA,EAAM,WAAW;AAAA;AAC7C,KACD,CAAA;AAAA,EACH;AACF;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-ts-type-forge",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "private": false,
   "description": "ESLint rules that steer type declarations toward ts-type-forge idioms.",
   "keywords": [
@@ -34,28 +34,9 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsx ./scripts/cmd/build.mts",
-    "build:min": "tsx ./scripts/cmd/build.mts --skip-check",
-    "check:ext": "tsx ./scripts/cmd/check-ext.mts",
-    "fmt": "format-uncommitted --cwd .",
-    "fmt:diff": "format-diff-from origin/main --cwd .",
-    "fmt:full": "pnpm run z:prettier .",
-    "gen:rule-types": "tsx ./scripts/cmd/gen-rule-types.mts",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "test": "pnpm run z:vitest run",
-    "test:cov": "pnpm run z:vitest run --coverage",
-    "testw": "pnpm run z:vitest",
-    "tsc": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
-    "tscw": "node ../../node_modules/typescript-native/bin/tsc --noEmit --watch -p ./tsconfig.json",
-    "type-check": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
-    "z:prettier": "prettier --config ../../.prettierrc --ignore-path ../../.prettierignore --ignore-path ../../.gitignore --ignore-unknown --no-error-on-unmatched-pattern --write",
-    "z:vitest": "vitest --config ./configs/vitest.config.mts"
-  },
   "dependencies": {
     "@typescript-eslint/utils": "8.65.0",
-    "ts-type-forge": "workspace:*"
+    "ts-type-forge": "8.0.0"
   },
   "devDependencies": {
     "@typescript-eslint/parser": "8.65.0",
@@ -73,5 +54,24 @@
   "publishConfig": {
     "access": "public",
     "provenance": true
+  },
+  "scripts": {
+    "build": "tsx ./scripts/cmd/build.mts",
+    "build:min": "tsx ./scripts/cmd/build.mts --skip-check",
+    "check:ext": "tsx ./scripts/cmd/check-ext.mts",
+    "fmt": "format-uncommitted --cwd .",
+    "fmt:diff": "format-diff-from origin/main --cwd .",
+    "fmt:full": "pnpm run z:prettier .",
+    "gen:rule-types": "tsx ./scripts/cmd/gen-rule-types.mts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "pnpm run z:vitest run",
+    "test:cov": "pnpm run z:vitest run --coverage",
+    "testw": "pnpm run z:vitest",
+    "tsc": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
+    "tscw": "node ../../node_modules/typescript-native/bin/tsc --noEmit --watch -p ./tsconfig.json",
+    "type-check": "node ../../node_modules/typescript-native/bin/tsc --noEmit",
+    "z:prettier": "prettier --config ../../.prettierrc --ignore-path ../../.prettierignore --ignore-path ../../.gitignore --ignore-unknown --no-error-on-unmatched-pattern --write",
+    "z:vitest": "vitest --config ./configs/vitest.config.mts"
   }
-}
+}

package/src/rule-types.mts

@@ -28,7 +28,7 @@ type RuleOptionsOf<Name extends keyof typeof tsTypeForgeRules> =
     : never;
 
 /**
- * @description Replace the `readonly [V, ...V[]]` tuple spelling with `NonEmptyArray<V>` from ts-type-forge.
+ * @description Replace uniform tuple spellings such as `[V, ...V[]]` / `[V, V, ...V[]]` / `[V, V, V]` with the canonical ts-type-forge tuple type.
  *
  *  ```md
  *  | key        | value      |
@@ -38,7 +38,7 @@ type RuleOptionsOf<Name extends keyof typeof tsTypeForgeRules> =
  *  | fixable    | code       |
  *  ```
  */
-namespace PreferNonEmptyArray {
+namespace PreferCanonicalLengthConstrainedTuple {
   /**
    * ### schema
    *
@@ -53,7 +53,12 @@ namespace PreferNonEmptyArray {
    *           "global",
    *           "named"
    *         ],
-   *         "description": "How `NonEmptyArray` is brought into scope. 'global' (default) assumes the ambient globals of `ts-type-forge/global` and never touches imports; 'named' makes the autofix add `import { type NonEmptyArray } from 'ts-type-forge';` when the name is not imported yet."
+   *         "description": "How the ts-type-forge type is brought into scope. 'global' (default) assumes the ambient globals of `ts-type-forge/global` and never touches imports; 'named' makes the autofix add the corresponding `import { type … } from 'ts-type-forge';` when the name is not imported yet."
+   *       },
+   *       "maxLength": {
+   *         "type": "integer",
+   *         "minimum": 2,
+   *         "description": "Longest tuple the rule rewrites (default 10). Longer tuples are usually spelled out on purpose, and the named form stops being more readable."
    *       }
    *     },
    *     "additionalProperties": false
@@ -61,7 +66,9 @@ namespace PreferNonEmptyArray {
    * ]
    * ```
    */
-  export type Options = NonNullable<RuleOptionsOf<'prefer-non-empty-array'>[0]>;
+  export type Options = NonNullable<
+    RuleOptionsOf<'prefer-canonical-length-constrained-tuple'>[0]
+  >;
 
   export type RuleEntry =
     | 'off'
@@ -70,11 +77,11 @@ namespace PreferNonEmptyArray {
 }
 
 export type EslintTsTypeForgeRules = Readonly<{
-  'ts-type-forge/prefer-non-empty-array': PreferNonEmptyArray.RuleEntry;
+  'ts-type-forge/prefer-canonical-length-constrained-tuple': PreferCanonicalLengthConstrainedTuple.RuleEntry;
 }>;
 
 export type EslintTsTypeForgeRulesOption = Readonly<{
-  'ts-type-forge/prefer-non-empty-array': PreferNonEmptyArray.Options;
+  'ts-type-forge/prefer-canonical-length-constrained-tuple': PreferCanonicalLengthConstrainedTuple.Options;
 }>;
 
 // If this assertion fails to type-check, this generated file has drifted from

package/src/rules/ast-utils.mts

@@ -6,54 +6,96 @@ import {
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
+export type UniformTupleShape = Readonly<{
+  /** The node an autofix must replace: the tuple, or the `readonly` operator. */
+  node: TSESTree.Node;
+  isReadonly: boolean;
+  /** Source text of the (single, shared) element type. */
+  elementText: string;
+  /** Number of leading fixed-position elements. */
+  fixedCount: number;
+  /** Whether a trailing `...V[]` rest element is present. */
+  hasRest: boolean;
+}>;
+
 /**
- * Matches the "non-empty array" tuple spelling — `readonly [V, ...V[]]` (and
- * its equivalent `readonly [V, ...(readonly V[])]`) — and returns the source
- * text of `V`, or `undefined` when `node` is not that shape.
+ * Recognizes a tuple whose every position has the *same* element type — the
+ * hand-rolled spelling of ts-type-forge's length-constrained tuple family:
+ *
+ * | shape                | meaning                    |
+ * | :------------------- | :------------------------- |
+ * | `[V, ..., V]`        | `FixedLengthTuple<N, V>`   |
+ * | `[V, ..., V, ...V[]]`| `MinLengthTuple<N, V>`     |
  *
- * Deliberately narrow:
+ * Returns `undefined` for anything else. Deliberately narrow:
  *
- * - Only the `readonly` operator is matched. A mutable `[V, ...V[]]` is a
- *   different type (`MutableNonEmptyArray<V>`) and is left alone.
- * - Exactly two elements, the second being a rest element whose element type is
- *   textually identical to the first.
- * - Labelled members (`readonly [head: V, ...tail: V[]]`) are skipped, since
- *   rewriting them would silently drop the labels.
+ * - Element types are compared by normalized source text, so heterogeneous
+ *   tuples are never matched.
+ * - Optional (`[V?]`) and labelled (`[head: V]`) members are skipped, since
+ *   rewriting them would drop information.
+ * - A tuple that is only a rest element (`[...V[]]`) is not a length
+ *   constraint at all.
  */
-export const getNonEmptyArrayElementText = (
-  node: TSESTree.TSTypeOperator,
+export const analyzeUniformTuple = (
+  tuple: TSESTree.TSTupleType,
   sourceCode: TSESLint.SourceCode,
-): string | undefined => {
-  if (node.operator !== 'readonly') return undefined;
+): UniformTupleShape | undefined => {
+  const { parent } = tuple;
 
-  const tuple = node.typeAnnotation;
+  const isReadonly =
+    parent.type === AST_NODE_TYPES.TSTypeOperator &&
+    parent.operator === 'readonly';
 
-  if (tuple?.type !== AST_NODE_TYPES.TSTupleType) return undefined;
+  const elements = tuple.elementTypes;
 
-  const [head, tail, ...rest] = tuple.elementTypes;
+  const last = elements.at(-1);
 
-  if (head === undefined || tail === undefined || rest.length > 0) {
-    return undefined;
-  }
+  const hasRest = last?.type === AST_NODE_TYPES.TSRestType;
+
+  const leading = hasRest ? elements.slice(0, -1) : elements;
 
   if (
-    head.type === AST_NODE_TYPES.TSRestType ||
-    head.type === AST_NODE_TYPES.TSOptionalType ||
-    head.type === AST_NODE_TYPES.TSNamedTupleMember ||
-    tail.type !== AST_NODE_TYPES.TSRestType
+    leading.length === 0 ||
+    leading.some(
+      (element) =>
+        element.type === AST_NODE_TYPES.TSRestType ||
+        element.type === AST_NODE_TYPES.TSOptionalType ||
+        element.type === AST_NODE_TYPES.TSNamedTupleMember,
+    )
   ) {
     return undefined;
   }
 
-  const restElementType = getArrayElementType(tail.typeAnnotation);
+  const restElementType =
+    last !== undefined && hasRest
+      ? getArrayElementType(last.typeAnnotation)
+      : undefined;
+
+  if (hasRest && restElementType === undefined) return undefined;
+
+  const [head] = leading;
+
+  if (head === undefined) return undefined;
+
+  const elementText = sourceCode.getText(head);
 
-  if (restElementType === undefined) return undefined;
+  const expected = normalizeWhitespace(elementText);
 
-  const headText = sourceCode.getText(head);
+  const others = [
+    ...leading.slice(1),
+    ...(restElementType === undefined ? [] : [restElementType]),
+  ];
 
-  return normalizeWhitespace(headText) ===
-    normalizeWhitespace(sourceCode.getText(restElementType))
-    ? headText
+  return others.every(
+    (element) => normalizeWhitespace(sourceCode.getText(element)) === expected,
+  )
+    ? {
+        node: isReadonly ? parent : tuple,
+        isReadonly,
+        elementText,
+        fixedCount: leading.length,
+        hasRest,
+      }
     : undefined;
 };
 

package/src/rules/constants.mts

@@ -1,3 +1,20 @@
 export const TS_TYPE_FORGE_MODULE = 'ts-type-forge';
 
-export const NON_EMPTY_ARRAY_TYPE_NAME = 'NonEmptyArray';
+export const NON_EMPTY_TUPLE_TYPE_NAME = 'NonEmptyTuple';
+
+export const MUTABLE_NON_EMPTY_TUPLE_TYPE_NAME = 'MutableNonEmptyTuple';
+
+export const MIN_LENGTH_TUPLE_TYPE_NAME = 'MinLengthTuple';
+
+export const MUTABLE_MIN_LENGTH_TUPLE_TYPE_NAME = 'MutableMinLengthTuple';
+
+export const FIXED_LENGTH_TUPLE_TYPE_NAME = 'FixedLengthTuple';
+
+export const MUTABLE_FIXED_LENGTH_TUPLE_TYPE_NAME = 'MutableFixedLengthTuple';
+
+/**
+ * Upper bound for the `maxLength` option of `prefer-length-constrained-tuple`.
+ * Beyond this, spelling the tuple out is usually intentional (e.g. a matrix
+ * row), and the named form stops being more readable.
+ */
+export const DEFAULT_MAX_TUPLE_LENGTH = 10;

package/src/rules/prefer-canonical-length-constrained-tuple.mts

@@ -0,0 +1,149 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+import { analyzeUniformTuple, type UniformTupleShape } from './ast-utils.mjs';
+import {
+  DEFAULT_MAX_TUPLE_LENGTH,
+  FIXED_LENGTH_TUPLE_TYPE_NAME,
+  MIN_LENGTH_TUPLE_TYPE_NAME,
+  MUTABLE_FIXED_LENGTH_TUPLE_TYPE_NAME,
+  MUTABLE_MIN_LENGTH_TUPLE_TYPE_NAME,
+  MUTABLE_NON_EMPTY_TUPLE_TYPE_NAME,
+  NON_EMPTY_TUPLE_TYPE_NAME,
+} from './constants.mjs';
+import {
+  DEFAULT_IMPORT_STYLE,
+  IMPORT_STYLE_SCHEMA_PROPERTY,
+  reportTupleRewrites,
+  type TupleRewrite,
+} from './tuple-rule-utils.mjs';
+
+type Options = readonly [
+  Readonly<{
+    importStyle?: 'global' | 'named';
+    maxLength?: number;
+  }>?,
+];
+
+type MessageIds = 'useCanonicalTuple';
+
+/**
+ * A single fixed element without a rest (`[V]`) is left alone: it reads better
+ * than `FixedLengthTuple<1, V>`.
+ */
+const MIN_FIXED_LENGTH = 2;
+
+export const preferCanonicalLengthConstrainedTuple: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace uniform tuple spellings such as `[V, ...V[]]` / `[V, V, ...V[]]` / `[V, V, V]` with the canonical ts-type-forge tuple type.',
+    },
+    fixable: 'code',
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          importStyle: IMPORT_STYLE_SCHEMA_PROPERTY,
+          maxLength: {
+            type: 'integer',
+            minimum: MIN_FIXED_LENGTH,
+            description: [
+              'Longest tuple the rule rewrites (default',
+              `${DEFAULT_MAX_TUPLE_LENGTH}).`,
+              'Longer tuples are usually spelled out on purpose, and the named',
+              'form stops being more readable.',
+            ].join(' '),
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      useCanonicalTuple:
+        'Replace `{{original}}` with `{{replacement}}` from ts-type-forge.',
+    },
+  },
+
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    const options = context.options[0];
+
+    const importStyle = options?.importStyle ?? DEFAULT_IMPORT_STYLE;
+
+    const maxLength = options?.maxLength ?? DEFAULT_MAX_TUPLE_LENGTH;
+
+    const mut_rewrites: TupleRewrite[] = [];
+
+    return {
+      TSTupleType: (node) => {
+        const shape = analyzeUniformTuple(node, sourceCode);
+
+        if (shape === undefined || shape.fixedCount > maxLength) return;
+
+        const canonicalName = canonicalNameFor(shape);
+
+        if (canonicalName === undefined) return;
+
+        mut_rewrites.push({
+          node: shape.node,
+          canonicalName,
+          typeArgs:
+            shape.fixedCount === 1
+              ? shape.elementText
+              : `${shape.fixedCount}, ${shape.elementText}`,
+        });
+      },
+      'Program:exit': () => {
+        reportTupleRewrites(
+          context,
+          mut_rewrites,
+          'useCanonicalTuple',
+          importStyle,
+        );
+      },
+    };
+  },
+  defaultOptions: [
+    { importStyle: DEFAULT_IMPORT_STYLE, maxLength: DEFAULT_MAX_TUPLE_LENGTH },
+  ],
+} as const;
+
+/**
+ * The ts-type-forge type a given tuple shape spells out, or `undefined` when the
+ * shape is deliberately left alone.
+ *
+ * | shape                 | readonly            | mutable                    |
+ * | :-------------------- | :------------------ | :------------------------- |
+ * | `[V, ...V[]]`         | `NonEmptyTuple`     | `MutableNonEmptyTuple`     |
+ * | `[V, …×N, ...V[]]`    | `MinLengthTuple`    | `MutableMinLengthTuple`    |
+ * | `[V, …×N]` (N >= 2)   | `FixedLengthTuple`  | `MutableFixedLengthTuple`  |
+ */
+const canonicalNameFor = (
+  // `UniformTupleShape` carries a `TSESTree.Node`, which is not deeply readonly.
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  shape: UniformTupleShape,
+): string | undefined => {
+  const { isReadonly, hasRest, fixedCount } = shape;
+
+  if (hasRest) {
+    if (fixedCount === 1) {
+      return isReadonly
+        ? NON_EMPTY_TUPLE_TYPE_NAME
+        : MUTABLE_NON_EMPTY_TUPLE_TYPE_NAME;
+    }
+
+    return isReadonly
+      ? MIN_LENGTH_TUPLE_TYPE_NAME
+      : MUTABLE_MIN_LENGTH_TUPLE_TYPE_NAME;
+  }
+
+  if (fixedCount < MIN_FIXED_LENGTH) return undefined;
+
+  return isReadonly
+    ? FIXED_LENGTH_TUPLE_TYPE_NAME
+    : MUTABLE_FIXED_LENGTH_TUPLE_TYPE_NAME;
+};

package/src/rules/prefer-canonical-length-constrained-tuple.test.mts

@@ -0,0 +1,178 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferCanonicalLengthConstrainedTuple } from './prefer-canonical-length-constrained-tuple.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+  },
+});
+
+describe('prefer-canonical-length-constrained-tuple', () => {
+  tester.run(
+    'prefer-canonical-length-constrained-tuple',
+    preferCanonicalLengthConstrainedTuple,
+    {
+      valid: [
+        {
+          name: 'ignores heterogeneous tuples',
+          code: 'type T = readonly [string, number];',
+        },
+        {
+          name: 'ignores single-element tuples',
+          code: 'type T = readonly [string];',
+        },
+        {
+          name: 'ignores tuples longer than maxLength',
+          options: [{ maxLength: 2 }],
+          code: 'type T = readonly [string, string, string];',
+        },
+        {
+          name: 'ignores labelled members (the labels would be lost)',
+          code: 'type T = readonly [a: string, b: string];',
+        },
+        {
+          name: 'ignores optional members',
+          code: 'type T = readonly [string, string?];',
+        },
+        {
+          name: 'ignores rest-only tuples',
+          code: 'type T = readonly [...string[]];',
+        },
+        {
+          name: 'ignores plain arrays',
+          code: 'type T = readonly string[];',
+        },
+        {
+          name: 'stays silent when the target name is bound locally',
+          code: dedent`
+            type FixedLengthTuple<N, V> = readonly [N, V];
+            type T = readonly [string, string];
+          `,
+        },
+      ],
+      invalid: [
+        {
+          name: 'readonly non-empty tuple',
+          code: 'type T = readonly [string, ...string[]];',
+          output: 'type T = NonEmptyTuple<string>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'mutable non-empty tuple',
+          code: 'type T = [string, ...string[]];',
+          output: 'type T = MutableNonEmptyTuple<string>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'readonly non-empty tuple with a readonly rest spelling',
+          code: 'type T = readonly [string, ...(readonly string[])];',
+          output: 'type T = NonEmptyTuple<string>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'readonly fixed-length tuple',
+          code: 'type T = readonly [string, string, string];',
+          output: 'type T = FixedLengthTuple<3, string>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'mutable fixed-length tuple',
+          code: 'type T = [string, string, string];',
+          output: 'type T = MutableFixedLengthTuple<3, string>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'readonly min-length tuple',
+          code: 'type T = readonly [number, number, ...number[]];',
+          output: 'type T = MinLengthTuple<2, number>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'mutable min-length tuple',
+          code: 'type T = [number, number, ...number[]];',
+          output: 'type T = MutableMinLengthTuple<2, number>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'readonly rest spelling inside a readonly tuple',
+          code: 'type T = readonly [number, number, ...(readonly number[])];',
+          output: 'type T = MinLengthTuple<2, number>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'handles the default maximum length of 10',
+          code: 'type T = readonly [1, 1, 1, 1, 1, 1, 1, 1, 1, 1];',
+          output: 'type T = FixedLengthTuple<10, 1>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'keeps a composite element type intact',
+          code: 'type T = readonly [string | number, string | number];',
+          output: 'type T = FixedLengthTuple<2, string | number>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'handles generic element types',
+          code: 'type T<V> = [V, V, ...V[]];',
+          output: 'type T<V> = MutableMinLengthTuple<2, V>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'adds named imports once per target type',
+          options: [{ importStyle: 'named' }],
+          code: dedent`
+            type A = readonly [string, string];
+            type B = readonly [number, number, number];
+            type C = [number, number, ...number[]];
+          `,
+          output: dedent`
+            import { type FixedLengthTuple } from 'ts-type-forge';
+            import { type MutableMinLengthTuple } from 'ts-type-forge';
+            type A = FixedLengthTuple<2, string>;
+            type B = FixedLengthTuple<3, number>;
+            type C = MutableMinLengthTuple<2, number>;
+          `,
+          errors: [
+            { messageId: 'useCanonicalTuple' },
+            { messageId: 'useCanonicalTuple' },
+            { messageId: 'useCanonicalTuple' },
+          ],
+        },
+        {
+          name: 'reuses an aliased import',
+          code: dedent`
+            import { type FixedLengthTuple as FLT } from 'ts-type-forge';
+
+            type T = readonly [string, string];
+          `,
+          output: dedent`
+            import { type FixedLengthTuple as FLT } from 'ts-type-forge';
+
+            type T = FLT<2, string>;
+          `,
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+        {
+          name: 'rewrites parameter and return type positions',
+          code: 'declare const f: (xs: readonly [number, number]) => [string, string];',
+          output:
+            'declare const f: (xs: FixedLengthTuple<2, number>) => MutableFixedLengthTuple<2, string>;',
+          errors: [
+            { messageId: 'useCanonicalTuple' },
+            { messageId: 'useCanonicalTuple' },
+          ],
+        },
+        {
+          name: 'respects a raised maxLength',
+          options: [{ maxLength: 12 }],
+          code: 'type T = readonly [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];',
+          output: 'type T = FixedLengthTuple<12, 0>;',
+          errors: [{ messageId: 'useCanonicalTuple' }],
+        },
+      ],
+    },
+  );
+});