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

package/README.md

@@ -1,9 +1,9 @@
 # eslint-plugin-ts-type-forge
 
 ESLint rules that steer TypeScript **type declarations** toward
-[`ts-type-forge`](https://www.npmjs.com/package/ts-type-forge) idioms — e.g.
-preferring `NonEmptyArray<V>` over the hand-rolled `readonly [V, ...V[]]`
-tuple spelling. Every rule is auto-fixable.
+[`ts-type-forge`](https://www.npmjs.com/package/ts-type-forge) idioms — replacing
+hand-rolled uniform tuple spellings with the library's named length-constrained
+tuple types. Every rule is auto-fixable, and every rewrite is **type-preserving**.
 
 ## Installation
 
@@ -27,7 +27,7 @@ export default [
     {
         plugins: { 'ts-type-forge': eslintPluginTsTypeForge },
         rules: {
-            'ts-type-forge/prefer-non-empty-array': 'error',
+            'ts-type-forge/prefer-canonical-length-constrained-tuple': 'error',
         } satisfies Partial<EslintTsTypeForgeRules>,
     },
 ];
@@ -35,58 +35,80 @@ export default [
 
 ## Rules
 
-| Rule                     | Description                                             |
-| ------------------------ | ------------------------------------------------------- |
-| `prefer-non-empty-array` | Replace `readonly [V, ...V[]]` with `NonEmptyArray<V>`. |
+| Rule                                        | Description                                                                              |
+| :------------------------------------------ | :--------------------------------------------------------------------------------------- |
+| `prefer-canonical-length-constrained-tuple` | Replace hand-rolled uniform tuple spellings with the canonical ts-type-forge tuple type. |
 
-### `prefer-non-empty-array`
+It covers the whole uniform-tuple family:
 
-`readonly [V, ...V[]]` is the hand-rolled spelling of "an array with at least
-one element". `ts-type-forge` already exposes it as `NonEmptyArray<V>` (an
-alias of `MinLengthArray<1, V>`), which reads better and stays consistent with
-the rest of the length-constrained array family.
+| spelling                   | readonly target          | mutable target                  |
+| :------------------------- | :----------------------- | :------------------------------ |
+| `[V, ...V[]]`              | `NonEmptyTuple<V>`       | `MutableNonEmptyTuple<V>`       |
+| `[V, …×N, ...V[]]` (N ≥ 2) | `MinLengthTuple<N, V>`   | `MutableMinLengthTuple<N, V>`   |
+| `[V, …×N]` (N ≥ 2)         | `FixedLengthTuple<N, V>` | `MutableFixedLengthTuple<N, V>` |
+
+### Why the `*Tuple` types and not `NonEmptyArray` / `MinLengthArray`
+
+The `*Array` family (`NonEmptyArray`, `MinLengthArray`, `FixedLengthArray`, …)
+encodes its length constraint in a **brand**: `NonEmptyArray<V>` is
+`MinLengthTuple<1, V> & Brand<…>`, a strict _subtype_ of `readonly [V, ...V[]]`.
+Rewriting a declaration to it would narrow the type — an array literal is not
+assignable to a branded type — so the autofix could break call sites.
+
+The `*Tuple` family is structural and therefore exactly equal to the spelled-out
+tuple, which makes every fix in this plugin a pure rename.
+
+### Examples
 
 ```ts
 // ❌
 type Names = readonly [string, ...string[]];
-declare const head: (xs: readonly [number, ...(readonly number[])]) => number;
+type Queue = [number, ...number[]];
+type Rgb = readonly [number, number, number];
+type AtLeastTwo = [string, string, ...string[]];
 
 // ✅
-type Names = NonEmptyArray<string>;
-declare const head: (xs: NonEmptyArray<number>) => number;
+type Names = NonEmptyTuple<string>;
+type Queue = MutableNonEmptyTuple<number>;
+type Rgb = FixedLengthTuple<3, number>;
+type AtLeastTwo = MutableMinLengthTuple<2, string>;
 ```
 
-The rule deliberately leaves alone:
+Single-element tuples without a rest (`readonly [V]`) are left alone — they read
+better as-is than `FixedLengthTuple<1, V>`.
+
+### The rule deliberately leaves alone
 
-- mutable tuples (`[V, ...V[]]`), which correspond to
-  `MutableNonEmptyArray<V>` rather than `NonEmptyArray<V>`;
-- longer minimum lengths (`readonly [V, V, ...V[]]` — that is
-  `MinLengthArray<2, V>`);
-- labelled members (`readonly [head: V, ...tail: V[]]`), because rewriting
-  them would silently drop the labels;
-- files that already bind the name `NonEmptyArray` to something else (a local
-  alias, or an import from another module).
+- heterogeneous tuples (`readonly [string, number]`);
+- labelled members (`readonly [head: V, ...tail: V[]]`), because rewriting them
+  would silently drop the labels;
+- optional members (`readonly [V, V?]`) and rest-only tuples (`[...V[]]`);
+- files that already bind the target name to something else (a local alias, or
+  an import from another module).
 
-#### Options
+## Options
 
 | Option        | Type                  | Default    | Description                                               |
-| ------------- | --------------------- | ---------- | --------------------------------------------------------- |
-| `importStyle` | `'global' \| 'named'` | `'global'` | How `NonEmptyArray` is expected to be brought into scope. |
+| :------------ | :-------------------- | :--------- | :-------------------------------------------------------- |
+| `importStyle` | `'global' \| 'named'` | `'global'` | How the ts-type-forge type is brought into scope.         |
+| `maxLength`   | `integer`             | `10`       | Longest tuple `prefer-length-constrained-tuple` rewrites. |
 
 - `'global'` — the ambient globals of `ts-type-forge/global` are in use
   (`/// <reference types="ts-type-forge/global" />`), so the autofix only
   rewrites the type and never touches imports.
 - `'named'` — the autofix additionally inserts
-  `import { type NonEmptyArray } from 'ts-type-forge';` when the name is not
-  imported yet.
+  `import { type … } from 'ts-type-forge';` when the name is not imported yet.
 
-Either way, if the file already imports `NonEmptyArray` from `ts-type-forge`
+Either way, if the file already imports the target type from `ts-type-forge`
 (possibly under an alias), the autofix reuses that binding.
 
 ```ts
 {
     rules: {
-        'ts-type-forge/prefer-non-empty-array': ['error', { importStyle: 'named' }],
+        'ts-type-forge/prefer-canonical-length-constrained-tuple': [
+            'error',
+            { importStyle: 'named', maxLength: 6 },
+        ],
     },
 }
 ```

package/dist/rule-types.d.mts

@@ -10,7 +10,7 @@ type SpreadOptionsIfIsArray<T extends readonly [Linter.StringSeverity, unknown]>
  */
 type RuleOptionsOf<Name extends keyof typeof tsTypeForgeRules> = (typeof tsTypeForgeRules)[Name] extends TSESLint.RuleModule<infer _MessageIds extends string, infer Options extends readonly unknown[]> ? Options : 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      |
@@ -20,7 +20,7 @@ type RuleOptionsOf<Name extends keyof typeof tsTypeForgeRules> = (typeof tsTypeF
  *  | fixable    | code       |
  *  ```
  */
-declare namespace PreferNonEmptyArray {
+declare namespace PreferCanonicalLengthConstrainedTuple {
     /**
      * ### schema
      *
@@ -35,7 +35,12 @@ declare 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
@@ -43,14 +48,14 @@ declare namespace PreferNonEmptyArray {
      * ]
      * ```
      */
-    type Options = NonNullable<RuleOptionsOf<'prefer-non-empty-array'>[0]>;
+    type Options = NonNullable<RuleOptionsOf<'prefer-canonical-length-constrained-tuple'>[0]>;
     type RuleEntry = 'off' | Linter.Severity | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>;
 }
 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;
 }>;
 type AssertTrue<B extends true> = B;
 export type RuleNamesAreInSync = AssertTrue<TypeEq<keyof EslintTsTypeForgeRules, `ts-type-forge/${keyof typeof tsTypeForgeRules}`>>;

package/dist/rule-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-types.d.mts","sourceRoot":"","sources":["../src/rule-types.mts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,KAAK,sBAAsB,CACzB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,IACjD,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC/B,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GACzC,CAAC,CAAC;AAEN;;;;GAIG;AACH,KAAK,aAAa,CAAC,IAAI,SAAS,MAAM,OAAO,gBAAgB,IAC3D,CAAC,OAAO,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,QAAQ,CAAC,UAAU,CACzD,MAAM,WAAW,SAAS,MAAM,EAChC,MAAM,OAAO,SAAS,SAAS,OAAO,EAAE,CACzC,GACG,OAAO,GACP,KAAK,CAAC;AAEZ;;;;;;;;;;GAUG;AACH,kBAAU,mBAAmB,CAAC;IAC5B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAY,OAAO,GAAG,WAAW,CAAC,aAAa,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9E,KAAY,SAAS,GACjB,KAAK,GACL,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;CACvE;AAED,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,sCAAsC,EAAE,mBAAmB,CAAC,SAAS,CAAC;CACvE,CAAC,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,sCAAsC,EAAE,mBAAmB,CAAC,OAAO,CAAC;CACrE,CAAC,CAAC;AAIH,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAEpC,MAAM,MAAM,kBAAkB,GAAG,UAAU,CACzC,MAAM,CACJ,MAAM,sBAAsB,EAC5B,iBAAiB,MAAM,OAAO,gBAAgB,EAAE,CACjD,CACF,CAAC"}
+{"version":3,"file":"rule-types.d.mts","sourceRoot":"","sources":["../src/rule-types.mts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,KAAK,sBAAsB,CACzB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,IACjD,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC/B,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GACzC,CAAC,CAAC;AAEN;;;;GAIG;AACH,KAAK,aAAa,CAAC,IAAI,SAAS,MAAM,OAAO,gBAAgB,IAC3D,CAAC,OAAO,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,QAAQ,CAAC,UAAU,CACzD,MAAM,WAAW,SAAS,MAAM,EAChC,MAAM,OAAO,SAAS,SAAS,OAAO,EAAE,CACzC,GACG,OAAO,GACP,KAAK,CAAC;AAEZ;;;;;;;;;;GAUG;AACH,kBAAU,qCAAqC,CAAC;IAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,KAAY,OAAO,GAAG,WAAW,CAC/B,aAAa,CAAC,2CAA2C,CAAC,CAAC,CAAC,CAAC,CAC9D,CAAC;IAEF,KAAY,SAAS,GACjB,KAAK,GACL,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;CACvE;AAED,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,yDAAyD,EAAE,qCAAqC,CAAC,SAAS,CAAC;CAC5G,CAAC,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,yDAAyD,EAAE,qCAAqC,CAAC,OAAO,CAAC;CAC1G,CAAC,CAAC;AAIH,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAEpC,MAAM,MAAM,kBAAkB,GAAG,UAAU,CACzC,MAAM,CACJ,MAAM,sBAAsB,EAC5B,iBAAiB,MAAM,OAAO,gBAAgB,EAAE,CACjD,CACF,CAAC"}

package/dist/rules/ast-utils.d.mts

@@ -1,17 +1,32 @@
 import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+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:
  *
- * Deliberately narrow:
+ * | shape                | meaning                    |
+ * | :------------------- | :------------------------- |
+ * | `[V, ..., V]`        | `FixedLengthTuple<N, V>`   |
+ * | `[V, ..., V, ...V[]]`| `MinLengthTuple<N, V>`     |
  *
- * - 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.
+ * Returns `undefined` for anything else. Deliberately narrow:
+ *
+ * - 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 declare const getNonEmptyArrayElementText: (node: TSESTree.TSTypeOperator, sourceCode: TSESLint.SourceCode) => string | undefined;
+export declare const analyzeUniformTuple: (tuple: TSESTree.TSTupleType, sourceCode: TSESLint.SourceCode) => UniformTupleShape | undefined;
 //# sourceMappingURL=ast-utils.d.mts.map

package/dist/rules/ast-utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ast-utils.d.mts","sourceRoot":"","sources":["../../src/rules/ast-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAIlC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,2BAA2B,SAChC,QAAQ,CAAC,cAAc,cACjB,QAAQ,CAAC,UAAU,KAC9B,MAAM,GAAG,SAgCX,CAAC"}
+{"version":3,"file":"ast-utils.d.mts","sourceRoot":"","sources":["../../src/rules/ast-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAIlC,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,+EAA+E;IAC/E,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,2DAA2D;IAC3D,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,UACvB,QAAQ,CAAC,WAAW,cACf,QAAQ,CAAC,UAAU,KAC9B,iBAAiB,GAAG,SA0DtB,CAAC"}

package/dist/rules/ast-utils.mjs

@@ -1,20 +1,36 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
-const getNonEmptyArrayElementText = (node, sourceCode) => {
-  if (node.operator !== "readonly") return void 0;
-  const tuple = node.typeAnnotation;
-  if (tuple?.type !== AST_NODE_TYPES.TSTupleType) return void 0;
-  const [head, tail, ...rest] = tuple.elementTypes;
-  if (head === void 0 || tail === void 0 || rest.length > 0) {
+const analyzeUniformTuple = (tuple, sourceCode) => {
+  const { parent } = tuple;
+  const isReadonly = parent.type === AST_NODE_TYPES.TSTypeOperator && parent.operator === "readonly";
+  const elements = tuple.elementTypes;
+  const last = elements.at(-1);
+  const hasRest = last?.type === AST_NODE_TYPES.TSRestType;
+  const leading = hasRest ? elements.slice(0, -1) : elements;
+  if (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 void 0;
   }
-  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) {
-    return void 0;
-  }
-  const restElementType = getArrayElementType(tail.typeAnnotation);
-  if (restElementType === void 0) return void 0;
-  const headText = sourceCode.getText(head);
-  return normalizeWhitespace(headText) === normalizeWhitespace(sourceCode.getText(restElementType)) ? headText : void 0;
+  const restElementType = last !== void 0 && hasRest ? getArrayElementType(last.typeAnnotation) : void 0;
+  if (hasRest && restElementType === void 0) return void 0;
+  const [head] = leading;
+  if (head === void 0) return void 0;
+  const elementText = sourceCode.getText(head);
+  const expected = normalizeWhitespace(elementText);
+  const others = [
+    ...leading.slice(1),
+    ...restElementType === void 0 ? [] : [restElementType]
+  ];
+  return others.every(
+    (element) => normalizeWhitespace(sourceCode.getText(element)) === expected
+  ) ? {
+    node: isReadonly ? parent : tuple,
+    isReadonly,
+    elementText,
+    fixedCount: leading.length,
+    hasRest
+  } : void 0;
 };
 const getArrayElementType = (node) => {
   if (node.type === AST_NODE_TYPES.TSArrayType) return node.elementType;
@@ -22,5 +38,5 @@ const getArrayElementType = (node) => {
 };
 const normalizeWhitespace = (text) => text.replaceAll(/\s+/gu, " ").trim();
 
-export { getNonEmptyArrayElementText };
+export { analyzeUniformTuple };
 //# sourceMappingURL=ast-utils.mjs.map

package/dist/rules/ast-utils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ast-utils.mjs","sources":["../../src/rules/ast-utils.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\n\n/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */\n\n/**\n * Matches the \"non-empty array\" tuple spelling — `readonly [V, ...V[]]` (and\n * its equivalent `readonly [V, ...(readonly V[])]`) — and returns the source\n * text of `V`, or `undefined` when `node` is not that shape.\n *\n * Deliberately narrow:\n *\n * - Only the `readonly` operator is matched. A mutable `[V, ...V[]]` is a\n *   different type (`MutableNonEmptyArray<V>`) and is left alone.\n * - Exactly two elements, the second being a rest element whose element type is\n *   textually identical to the first.\n * - Labelled members (`readonly [head: V, ...tail: V[]]`) are skipped, since\n *   rewriting them would silently drop the labels.\n */\nexport const getNonEmptyArrayElementText = (\n  node: TSESTree.TSTypeOperator,\n  sourceCode: TSESLint.SourceCode,\n): string | undefined => {\n  if (node.operator !== 'readonly') return undefined;\n\n  const tuple = node.typeAnnotation;\n\n  if (tuple?.type !== AST_NODE_TYPES.TSTupleType) return undefined;\n\n  const [head, tail, ...rest] = tuple.elementTypes;\n\n  if (head === undefined || tail === undefined || rest.length > 0) {\n    return undefined;\n  }\n\n  if (\n    head.type === AST_NODE_TYPES.TSRestType ||\n    head.type === AST_NODE_TYPES.TSOptionalType ||\n    head.type === AST_NODE_TYPES.TSNamedTupleMember ||\n    tail.type !== AST_NODE_TYPES.TSRestType\n  ) {\n    return undefined;\n  }\n\n  const restElementType = getArrayElementType(tail.typeAnnotation);\n\n  if (restElementType === undefined) return undefined;\n\n  const headText = sourceCode.getText(head);\n\n  return normalizeWhitespace(headText) ===\n    normalizeWhitespace(sourceCode.getText(restElementType))\n    ? headText\n    : undefined;\n};\n\n/** Unwraps `V[]` and `readonly V[]` to `V`. */\nconst getArrayElementType = (\n  node: TSESTree.TypeNode,\n): TSESTree.TypeNode | undefined => {\n  if (node.type === AST_NODE_TYPES.TSArrayType) return node.elementType;\n\n  return node.type === AST_NODE_TYPES.TSTypeOperator &&\n    node.operator === 'readonly' &&\n    node.typeAnnotation?.type === AST_NODE_TYPES.TSArrayType\n    ? node.typeAnnotation.elementType\n    : undefined;\n};\n\nconst normalizeWhitespace = (text: string): string =>\n  text.replaceAll(/\\s+/gu, ' ').trim();\n\n/* eslint-enable @typescript-eslint/prefer-readonly-parameter-types */\n"],"names":[],"mappings":";;AAsBO,MAAM,2BAAA,GAA8B,CACzC,IAAA,EACA,UAAA,KACuB;AACvB,EAAA,IAAI,IAAA,CAAK,QAAA,KAAa,UAAA,EAAY,OAAO,MAAA;AAEzC,EAAA,MAAM,QAAQ,IAAA,CAAK,cAAA;AAEnB,EAAA,IAAI,KAAA,EAAO,IAAA,KAAS,cAAA,CAAe,WAAA,EAAa,OAAO,MAAA;AAEvD,EAAA,MAAM,CAAC,IAAA,EAAM,IAAA,EAAM,GAAG,IAAI,IAAI,KAAA,CAAM,YAAA;AAEpC,EAAA,IAAI,SAAS,MAAA,IAAa,IAAA,KAAS,MAAA,IAAa,IAAA,CAAK,SAAS,CAAA,EAAG;AAC/D,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,IACE,IAAA,CAAK,IAAA,KAAS,cAAA,CAAe,UAAA,IAC7B,KAAK,IAAA,KAAS,cAAA,CAAe,cAAA,IAC7B,IAAA,CAAK,SAAS,cAAA,CAAe,kBAAA,IAC7B,IAAA,CAAK,IAAA,KAAS,eAAe,UAAA,EAC7B;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,MAAM,eAAA,GAAkB,mBAAA,CAAoB,IAAA,CAAK,cAAc,CAAA;AAE/D,EAAA,IAAI,eAAA,KAAoB,QAAW,OAAO,MAAA;AAE1C,EAAA,MAAM,QAAA,GAAW,UAAA,CAAW,OAAA,CAAQ,IAAI,CAAA;AAExC,EAAA,OAAO,mBAAA,CAAoB,QAAQ,CAAA,KACjC,mBAAA,CAAoB,WAAW,OAAA,CAAQ,eAAe,CAAC,CAAA,GACrD,QAAA,GACA,MAAA;AACN;AAGA,MAAM,mBAAA,GAAsB,CAC1B,IAAA,KACkC;AAClC,EAAA,IAAI,IAAA,CAAK,IAAA,KAAS,cAAA,CAAe,WAAA,SAAoB,IAAA,CAAK,WAAA;AAE1D,EAAA,OAAO,IAAA,CAAK,IAAA,KAAS,cAAA,CAAe,cAAA,IAClC,KAAK,QAAA,KAAa,UAAA,IAClB,IAAA,CAAK,cAAA,EAAgB,IAAA,KAAS,cAAA,CAAe,WAAA,GAC3C,IAAA,CAAK,eAAe,WAAA,GACpB,MAAA;AACN,CAAA;AAEA,MAAM,mBAAA,GAAsB,CAAC,IAAA,KAC3B,IAAA,CAAK,WAAW,OAAA,EAAS,GAAG,EAAE,IAAA,EAAK;;;;"}
+{"version":3,"file":"ast-utils.mjs","sources":["../../src/rules/ast-utils.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\n\n/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */\n\nexport type UniformTupleShape = Readonly<{\n  /** The node an autofix must replace: the tuple, or the `readonly` operator. */\n  node: TSESTree.Node;\n  isReadonly: boolean;\n  /** Source text of the (single, shared) element type. */\n  elementText: string;\n  /** Number of leading fixed-position elements. */\n  fixedCount: number;\n  /** Whether a trailing `...V[]` rest element is present. */\n  hasRest: boolean;\n}>;\n\n/**\n * Recognizes a tuple whose every position has the *same* element type — the\n * hand-rolled spelling of ts-type-forge's length-constrained tuple family:\n *\n * | shape                | meaning                    |\n * | :------------------- | :------------------------- |\n * | `[V, ..., V]`        | `FixedLengthTuple<N, V>`   |\n * | `[V, ..., V, ...V[]]`| `MinLengthTuple<N, V>`     |\n *\n * Returns `undefined` for anything else. Deliberately narrow:\n *\n * - Element types are compared by normalized source text, so heterogeneous\n *   tuples are never matched.\n * - Optional (`[V?]`) and labelled (`[head: V]`) members are skipped, since\n *   rewriting them would drop information.\n * - A tuple that is only a rest element (`[...V[]]`) is not a length\n *   constraint at all.\n */\nexport const analyzeUniformTuple = (\n  tuple: TSESTree.TSTupleType,\n  sourceCode: TSESLint.SourceCode,\n): UniformTupleShape | undefined => {\n  const { parent } = tuple;\n\n  const isReadonly =\n    parent.type === AST_NODE_TYPES.TSTypeOperator &&\n    parent.operator === 'readonly';\n\n  const elements = tuple.elementTypes;\n\n  const last = elements.at(-1);\n\n  const hasRest = last?.type === AST_NODE_TYPES.TSRestType;\n\n  const leading = hasRest ? elements.slice(0, -1) : elements;\n\n  if (\n    leading.length === 0 ||\n    leading.some(\n      (element) =>\n        element.type === AST_NODE_TYPES.TSRestType ||\n        element.type === AST_NODE_TYPES.TSOptionalType ||\n        element.type === AST_NODE_TYPES.TSNamedTupleMember,\n    )\n  ) {\n    return undefined;\n  }\n\n  const restElementType =\n    last !== undefined && hasRest\n      ? getArrayElementType(last.typeAnnotation)\n      : undefined;\n\n  if (hasRest && restElementType === undefined) return undefined;\n\n  const [head] = leading;\n\n  if (head === undefined) return undefined;\n\n  const elementText = sourceCode.getText(head);\n\n  const expected = normalizeWhitespace(elementText);\n\n  const others = [\n    ...leading.slice(1),\n    ...(restElementType === undefined ? [] : [restElementType]),\n  ];\n\n  return others.every(\n    (element) => normalizeWhitespace(sourceCode.getText(element)) === expected,\n  )\n    ? {\n        node: isReadonly ? parent : tuple,\n        isReadonly,\n        elementText,\n        fixedCount: leading.length,\n        hasRest,\n      }\n    : undefined;\n};\n\n/** Unwraps `V[]` and `readonly V[]` to `V`. */\nconst getArrayElementType = (\n  node: TSESTree.TypeNode,\n): TSESTree.TypeNode | undefined => {\n  if (node.type === AST_NODE_TYPES.TSArrayType) return node.elementType;\n\n  return node.type === AST_NODE_TYPES.TSTypeOperator &&\n    node.operator === 'readonly' &&\n    node.typeAnnotation?.type === AST_NODE_TYPES.TSArrayType\n    ? node.typeAnnotation.elementType\n    : undefined;\n};\n\nconst normalizeWhitespace = (text: string): string =>\n  text.replaceAll(/\\s+/gu, ' ').trim();\n\n/* eslint-enable @typescript-eslint/prefer-readonly-parameter-types */\n"],"names":[],"mappings":";;AAsCO,MAAM,mBAAA,GAAsB,CACjC,KAAA,EACA,UAAA,KACkC;AAClC,EAAA,MAAM,EAAE,QAAO,GAAI,KAAA;AAEnB,EAAA,MAAM,aACJ,MAAA,CAAO,IAAA,KAAS,cAAA,CAAe,cAAA,IAC/B,OAAO,QAAA,KAAa,UAAA;AAEtB,EAAA,MAAM,WAAW,KAAA,CAAM,YAAA;AAEvB,EAAA,MAAM,IAAA,GAAO,QAAA,CAAS,EAAA,CAAG,EAAE,CAAA;AAE3B,EAAA,MAAM,OAAA,GAAU,IAAA,EAAM,IAAA,KAAS,cAAA,CAAe,UAAA;AAE9C,EAAA,MAAM,UAAU,OAAA,GAAU,QAAA,CAAS,KAAA,CAAM,CAAA,EAAG,EAAE,CAAA,GAAI,QAAA;AAElD,EAAA,IACE,OAAA,CAAQ,MAAA,KAAW,CAAA,IACnB,OAAA,CAAQ,IAAA;AAAA,IACN,CAAC,OAAA,KACC,OAAA,CAAQ,IAAA,KAAS,cAAA,CAAe,UAAA,IAChC,OAAA,CAAQ,IAAA,KAAS,cAAA,CAAe,cAAA,IAChC,OAAA,CAAQ,IAAA,KAAS,cAAA,CAAe;AAAA,GACpC,EACA;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,MAAM,kBACJ,IAAA,KAAS,MAAA,IAAa,UAClB,mBAAA,CAAoB,IAAA,CAAK,cAAc,CAAA,GACvC,MAAA;AAEN,EAAA,IAAI,OAAA,IAAW,eAAA,KAAoB,MAAA,EAAW,OAAO,MAAA;AAErD,EAAA,MAAM,CAAC,IAAI,CAAA,GAAI,OAAA;AAEf,EAAA,IAAI,IAAA,KAAS,QAAW,OAAO,MAAA;AAE/B,EAAA,MAAM,WAAA,GAAc,UAAA,CAAW,OAAA,CAAQ,IAAI,CAAA;AAE3C,EAAA,MAAM,QAAA,GAAW,oBAAoB,WAAW,CAAA;AAEhD,EAAA,MAAM,MAAA,GAAS;AAAA,IACb,GAAG,OAAA,CAAQ,KAAA,CAAM,CAAC,CAAA;AAAA,IAClB,GAAI,eAAA,KAAoB,MAAA,GAAY,EAAC,GAAI,CAAC,eAAe;AAAA,GAC3D;AAEA,EAAA,OAAO,MAAA,CAAO,KAAA;AAAA,IACZ,CAAC,OAAA,KAAY,mBAAA,CAAoB,WAAW,OAAA,CAAQ,OAAO,CAAC,CAAA,KAAM;AAAA,GACpE,GACI;AAAA,IACE,IAAA,EAAM,aAAa,MAAA,GAAS,KAAA;AAAA,IAC5B,UAAA;AAAA,IACA,WAAA;AAAA,IACA,YAAY,OAAA,CAAQ,MAAA;AAAA,IACpB;AAAA,GACF,GACA,MAAA;AACN;AAGA,MAAM,mBAAA,GAAsB,CAC1B,IAAA,KACkC;AAClC,EAAA,IAAI,IAAA,CAAK,IAAA,KAAS,cAAA,CAAe,WAAA,SAAoB,IAAA,CAAK,WAAA;AAE1D,EAAA,OAAO,IAAA,CAAK,IAAA,KAAS,cAAA,CAAe,cAAA,IAClC,KAAK,QAAA,KAAa,UAAA,IAClB,IAAA,CAAK,cAAA,EAAgB,IAAA,KAAS,cAAA,CAAe,WAAA,GAC3C,IAAA,CAAK,eAAe,WAAA,GACpB,MAAA;AACN,CAAA;AAEA,MAAM,mBAAA,GAAsB,CAAC,IAAA,KAC3B,IAAA,CAAK,WAAW,OAAA,EAAS,GAAG,EAAE,IAAA,EAAK;;;;"}

package/dist/rules/constants.d.mts

@@ -1,3 +1,14 @@
 export declare const TS_TYPE_FORGE_MODULE = "ts-type-forge";
-export declare const NON_EMPTY_ARRAY_TYPE_NAME = "NonEmptyArray";
+export declare const NON_EMPTY_TUPLE_TYPE_NAME = "NonEmptyTuple";
+export declare const MUTABLE_NON_EMPTY_TUPLE_TYPE_NAME = "MutableNonEmptyTuple";
+export declare const MIN_LENGTH_TUPLE_TYPE_NAME = "MinLengthTuple";
+export declare const MUTABLE_MIN_LENGTH_TUPLE_TYPE_NAME = "MutableMinLengthTuple";
+export declare const FIXED_LENGTH_TUPLE_TYPE_NAME = "FixedLengthTuple";
+export declare 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 declare const DEFAULT_MAX_TUPLE_LENGTH = 10;
 //# sourceMappingURL=constants.d.mts.map

package/dist/rules/constants.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.mts","sourceRoot":"","sources":["../../src/rules/constants.mts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,kBAAkB,CAAC;AAEpD,eAAO,MAAM,yBAAyB,kBAAkB,CAAC"}
+{"version":3,"file":"constants.d.mts","sourceRoot":"","sources":["../../src/rules/constants.mts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,kBAAkB,CAAC;AAEpD,eAAO,MAAM,yBAAyB,kBAAkB,CAAC;AAEzD,eAAO,MAAM,iCAAiC,yBAAyB,CAAC;AAExE,eAAO,MAAM,0BAA0B,mBAAmB,CAAC;AAE3D,eAAO,MAAM,kCAAkC,0BAA0B,CAAC;AAE1E,eAAO,MAAM,4BAA4B,qBAAqB,CAAC;AAE/D,eAAO,MAAM,oCAAoC,4BAA4B,CAAC;AAE9E;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,KAAK,CAAC"}

package/dist/rules/constants.mjs

@@ -1,5 +1,11 @@
 const TS_TYPE_FORGE_MODULE = "ts-type-forge";
-const NON_EMPTY_ARRAY_TYPE_NAME = "NonEmptyArray";
+const NON_EMPTY_TUPLE_TYPE_NAME = "NonEmptyTuple";
+const MUTABLE_NON_EMPTY_TUPLE_TYPE_NAME = "MutableNonEmptyTuple";
+const MIN_LENGTH_TUPLE_TYPE_NAME = "MinLengthTuple";
+const MUTABLE_MIN_LENGTH_TUPLE_TYPE_NAME = "MutableMinLengthTuple";
+const FIXED_LENGTH_TUPLE_TYPE_NAME = "FixedLengthTuple";
+const MUTABLE_FIXED_LENGTH_TUPLE_TYPE_NAME = "MutableFixedLengthTuple";
+const DEFAULT_MAX_TUPLE_LENGTH = 10;
 
-export { NON_EMPTY_ARRAY_TYPE_NAME, TS_TYPE_FORGE_MODULE };
+export { 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, TS_TYPE_FORGE_MODULE };
 //# sourceMappingURL=constants.mjs.map

package/dist/rules/constants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.mjs","sources":["../../src/rules/constants.mts"],"sourcesContent":["export const TS_TYPE_FORGE_MODULE = 'ts-type-forge';\n\nexport const NON_EMPTY_ARRAY_TYPE_NAME = 'NonEmptyArray';\n"],"names":[],"mappings":"AAAO,MAAM,oBAAA,GAAuB;AAE7B,MAAM,yBAAA,GAA4B;;;;"}
+{"version":3,"file":"constants.mjs","sources":["../../src/rules/constants.mts"],"sourcesContent":["export const TS_TYPE_FORGE_MODULE = 'ts-type-forge';\n\nexport const NON_EMPTY_TUPLE_TYPE_NAME = 'NonEmptyTuple';\n\nexport const MUTABLE_NON_EMPTY_TUPLE_TYPE_NAME = 'MutableNonEmptyTuple';\n\nexport const MIN_LENGTH_TUPLE_TYPE_NAME = 'MinLengthTuple';\n\nexport const MUTABLE_MIN_LENGTH_TUPLE_TYPE_NAME = 'MutableMinLengthTuple';\n\nexport const FIXED_LENGTH_TUPLE_TYPE_NAME = 'FixedLengthTuple';\n\nexport const MUTABLE_FIXED_LENGTH_TUPLE_TYPE_NAME = 'MutableFixedLengthTuple';\n\n/**\n * Upper bound for the `maxLength` option of `prefer-length-constrained-tuple`.\n * Beyond this, spelling the tuple out is usually intentional (e.g. a matrix\n * row), and the named form stops being more readable.\n */\nexport const DEFAULT_MAX_TUPLE_LENGTH = 10;\n"],"names":[],"mappings":"AAAO,MAAM,oBAAA,GAAuB;AAE7B,MAAM,yBAAA,GAA4B;AAElC,MAAM,iCAAA,GAAoC;AAE1C,MAAM,0BAAA,GAA6B;AAEnC,MAAM,kCAAA,GAAqC;AAE3C,MAAM,4BAAA,GAA+B;AAErC,MAAM,oCAAA,GAAuC;AAO7C,MAAM,wBAAA,GAA2B;;;;"}

package/dist/rules/prefer-canonical-length-constrained-tuple.d.mts

@@ -0,0 +1,11 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [
+    Readonly<{
+        importStyle?: 'global' | 'named';
+        maxLength?: number;
+    }>?
+];
+type MessageIds = 'useCanonicalTuple';
+export declare const preferCanonicalLengthConstrainedTuple: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-canonical-length-constrained-tuple.d.mts.map

package/dist/rules/prefer-canonical-length-constrained-tuple.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-canonical-length-constrained-tuple.d.mts","sourceRoot":"","sources":["../../src/rules/prefer-canonical-length-constrained-tuple.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAkBzD,KAAK,OAAO,GAAG,SAAS;IACtB,QAAQ,CAAC;QACP,WAAW,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;QACjC,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,UAAU,GAAG,mBAAmB,CAAC;AAQtC,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,UAAU,CACrE,UAAU,EACV,OAAO,CA6EC,CAAC"}

package/dist/rules/prefer-canonical-length-constrained-tuple.mjs

@@ -0,0 +1,81 @@
+import { analyzeUniformTuple } from './ast-utils.mjs';
+import { DEFAULT_MAX_TUPLE_LENGTH, NON_EMPTY_TUPLE_TYPE_NAME, MUTABLE_NON_EMPTY_TUPLE_TYPE_NAME, MIN_LENGTH_TUPLE_TYPE_NAME, MUTABLE_MIN_LENGTH_TUPLE_TYPE_NAME, FIXED_LENGTH_TUPLE_TYPE_NAME, MUTABLE_FIXED_LENGTH_TUPLE_TYPE_NAME } from './constants.mjs';
+import { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY, reportTupleRewrites } from './tuple-rule-utils.mjs';
+
+const MIN_FIXED_LENGTH = 2;
+const preferCanonicalLengthConstrainedTuple = {
+  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 = [];
+    return {
+      TSTupleType: (node) => {
+        const shape = analyzeUniformTuple(node, sourceCode);
+        if (shape === void 0 || shape.fixedCount > maxLength) return;
+        const canonicalName = canonicalNameFor(shape);
+        if (canonicalName === void 0) 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 }
+  ]
+};
+const canonicalNameFor = (shape) => {
+  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 void 0;
+  return isReadonly ? FIXED_LENGTH_TUPLE_TYPE_NAME : MUTABLE_FIXED_LENGTH_TUPLE_TYPE_NAME;
+};
+
+export { preferCanonicalLengthConstrainedTuple };
+//# sourceMappingURL=prefer-canonical-length-constrained-tuple.mjs.map

package/dist/rules/prefer-canonical-length-constrained-tuple.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-canonical-length-constrained-tuple.mjs","sources":["../../src/rules/prefer-canonical-length-constrained-tuple.mts"],"sourcesContent":["import { type TSESLint } from '@typescript-eslint/utils';\nimport { analyzeUniformTuple, type UniformTupleShape } from './ast-utils.mjs';\nimport {\n  DEFAULT_MAX_TUPLE_LENGTH,\n  FIXED_LENGTH_TUPLE_TYPE_NAME,\n  MIN_LENGTH_TUPLE_TYPE_NAME,\n  MUTABLE_FIXED_LENGTH_TUPLE_TYPE_NAME,\n  MUTABLE_MIN_LENGTH_TUPLE_TYPE_NAME,\n  MUTABLE_NON_EMPTY_TUPLE_TYPE_NAME,\n  NON_EMPTY_TUPLE_TYPE_NAME,\n} from './constants.mjs';\nimport {\n  DEFAULT_IMPORT_STYLE,\n  IMPORT_STYLE_SCHEMA_PROPERTY,\n  reportTupleRewrites,\n  type TupleRewrite,\n} from './tuple-rule-utils.mjs';\n\ntype Options = readonly [\n  Readonly<{\n    importStyle?: 'global' | 'named';\n    maxLength?: number;\n  }>?,\n];\n\ntype MessageIds = 'useCanonicalTuple';\n\n/**\n * A single fixed element without a rest (`[V]`) is left alone: it reads better\n * than `FixedLengthTuple<1, V>`.\n */\nconst MIN_FIXED_LENGTH = 2;\n\nexport const preferCanonicalLengthConstrainedTuple: TSESLint.RuleModule<\n  MessageIds,\n  Options\n> = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Replace uniform tuple spellings such as `[V, ...V[]]` / `[V, V, ...V[]]` / `[V, V, V]` with the canonical ts-type-forge tuple type.',\n    },\n    fixable: 'code',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          importStyle: IMPORT_STYLE_SCHEMA_PROPERTY,\n          maxLength: {\n            type: 'integer',\n            minimum: MIN_FIXED_LENGTH,\n            description: [\n              'Longest tuple the rule rewrites (default',\n              `${DEFAULT_MAX_TUPLE_LENGTH}).`,\n              'Longer tuples are usually spelled out on purpose, and the named',\n              'form stops being more readable.',\n            ].join(' '),\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n    messages: {\n      useCanonicalTuple:\n        'Replace `{{original}}` with `{{replacement}}` from ts-type-forge.',\n    },\n  },\n\n  create: (context) => {\n    const sourceCode = context.sourceCode;\n\n    const options = context.options[0];\n\n    const importStyle = options?.importStyle ?? DEFAULT_IMPORT_STYLE;\n\n    const maxLength = options?.maxLength ?? DEFAULT_MAX_TUPLE_LENGTH;\n\n    const mut_rewrites: TupleRewrite[] = [];\n\n    return {\n      TSTupleType: (node) => {\n        const shape = analyzeUniformTuple(node, sourceCode);\n\n        if (shape === undefined || shape.fixedCount > maxLength) return;\n\n        const canonicalName = canonicalNameFor(shape);\n\n        if (canonicalName === undefined) return;\n\n        mut_rewrites.push({\n          node: shape.node,\n          canonicalName,\n          typeArgs:\n            shape.fixedCount === 1\n              ? shape.elementText\n              : `${shape.fixedCount}, ${shape.elementText}`,\n        });\n      },\n      'Program:exit': () => {\n        reportTupleRewrites(\n          context,\n          mut_rewrites,\n          'useCanonicalTuple',\n          importStyle,\n        );\n      },\n    };\n  },\n  defaultOptions: [\n    { importStyle: DEFAULT_IMPORT_STYLE, maxLength: DEFAULT_MAX_TUPLE_LENGTH },\n  ],\n} as const;\n\n/**\n * The ts-type-forge type a given tuple shape spells out, or `undefined` when the\n * shape is deliberately left alone.\n *\n * | shape                 | readonly            | mutable                    |\n * | :-------------------- | :------------------ | :------------------------- |\n * | `[V, ...V[]]`         | `NonEmptyTuple`     | `MutableNonEmptyTuple`     |\n * | `[V, …×N, ...V[]]`    | `MinLengthTuple`    | `MutableMinLengthTuple`    |\n * | `[V, …×N]` (N >= 2)   | `FixedLengthTuple`  | `MutableFixedLengthTuple`  |\n */\nconst canonicalNameFor = (\n  // `UniformTupleShape` carries a `TSESTree.Node`, which is not deeply readonly.\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  shape: UniformTupleShape,\n): string | undefined => {\n  const { isReadonly, hasRest, fixedCount } = shape;\n\n  if (hasRest) {\n    if (fixedCount === 1) {\n      return isReadonly\n        ? NON_EMPTY_TUPLE_TYPE_NAME\n        : MUTABLE_NON_EMPTY_TUPLE_TYPE_NAME;\n    }\n\n    return isReadonly\n      ? MIN_LENGTH_TUPLE_TYPE_NAME\n      : MUTABLE_MIN_LENGTH_TUPLE_TYPE_NAME;\n  }\n\n  if (fixedCount < MIN_FIXED_LENGTH) return undefined;\n\n  return isReadonly\n    ? FIXED_LENGTH_TUPLE_TYPE_NAME\n    : MUTABLE_FIXED_LENGTH_TUPLE_TYPE_NAME;\n};\n"],"names":[],"mappings":";;;;AA+BA,MAAM,gBAAA,GAAmB,CAAA;AAElB,MAAM,qCAAA,GAGT;AAAA,EACF,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM,YAAA;AAAA,IACN,IAAA,EAAM;AAAA,MACJ,WAAA,EACE;AAAA,KACJ;AAAA,IACA,OAAA,EAAS,MAAA;AAAA,IACT,MAAA,EAAQ;AAAA,MACN;AAAA,QACE,IAAA,EAAM,QAAA;AAAA,QACN,UAAA,EAAY;AAAA,UACV,WAAA,EAAa,4BAAA;AAAA,UACb,SAAA,EAAW;AAAA,YACT,IAAA,EAAM,SAAA;AAAA,YACN,OAAA,EAAS,gBAAA;AAAA,YACT,WAAA,EAAa;AAAA,cACX,0CAAA;AAAA,cACA,GAAG,wBAAwB,CAAA,EAAA,CAAA;AAAA,cAC3B,iEAAA;AAAA,cACA;AAAA,aACF,CAAE,KAAK,GAAG;AAAA;AACZ,SACF;AAAA,QACA,oBAAA,EAAsB;AAAA;AACxB,KACF;AAAA,IACA,QAAA,EAAU;AAAA,MACR,iBAAA,EACE;AAAA;AACJ,GACF;AAAA,EAEA,MAAA,EAAQ,CAAC,OAAA,KAAY;AACnB,IAAA,MAAM,aAAa,OAAA,CAAQ,UAAA;AAE3B,IAAA,MAAM,OAAA,GAAU,OAAA,CAAQ,OAAA,CAAQ,CAAC,CAAA;AAEjC,IAAA,MAAM,WAAA,GAAc,SAAS,WAAA,IAAe,oBAAA;AAE5C,IAAA,MAAM,SAAA,GAAY,SAAS,SAAA,IAAa,wBAAA;AAExC,IAAA,MAAM,eAA+B,EAAC;AAEtC,IAAA,OAAO;AAAA,MACL,WAAA,EAAa,CAAC,IAAA,KAAS;AACrB,QAAA,MAAM,KAAA,GAAQ,mBAAA,CAAoB,IAAA,EAAM,UAAU,CAAA;AAElD,QAAA,IAAI,KAAA,KAAU,MAAA,IAAa,KAAA,CAAM,UAAA,GAAa,SAAA,EAAW;AAEzD,QAAA,MAAM,aAAA,GAAgB,iBAAiB,KAAK,CAAA;AAE5C,QAAA,IAAI,kBAAkB,MAAA,EAAW;AAEjC,QAAA,YAAA,CAAa,IAAA,CAAK;AAAA,UAChB,MAAM,KAAA,CAAM,IAAA;AAAA,UACZ,aAAA;AAAA,UACA,QAAA,EACE,KAAA,CAAM,UAAA,KAAe,CAAA,GACjB,KAAA,CAAM,WAAA,GACN,CAAA,EAAG,KAAA,CAAM,UAAU,CAAA,EAAA,EAAK,KAAA,CAAM,WAAW,CAAA;AAAA,SAChD,CAAA;AAAA,MACH,CAAA;AAAA,MACA,gBAAgB,MAAM;AACpB,QAAA,mBAAA;AAAA,UACE,OAAA;AAAA,UACA,YAAA;AAAA,UACA,mBAAA;AAAA,UACA;AAAA,SACF;AAAA,MACF;AAAA,KACF;AAAA,EACF,CAAA;AAAA,EACA,cAAA,EAAgB;AAAA,IACd,EAAE,WAAA,EAAa,oBAAA,EAAsB,SAAA,EAAW,wBAAA;AAAyB;AAE7E;AAYA,MAAM,gBAAA,GAAmB,CAGvB,KAAA,KACuB;AACvB,EAAA,MAAM,EAAE,UAAA,EAAY,OAAA,EAAS,UAAA,EAAW,GAAI,KAAA;AAE5C,EAAA,IAAI,OAAA,EAAS;AACX,IAAA,IAAI,eAAe,CAAA,EAAG;AACpB,MAAA,OAAO,aACH,yBAAA,GACA,iCAAA;AAAA,IACN;AAEA,IAAA,OAAO,aACH,0BAAA,GACA,kCAAA;AAAA,EACN;AAEA,EAAA,IAAI,UAAA,GAAa,kBAAkB,OAAO,MAAA;AAE1C,EAAA,OAAO,aACH,4BAAA,GACA,oCAAA;AACN,CAAA;;;;"}

package/dist/rules/rules.d.mts

@@ -1,6 +1,7 @@
 export declare const tsTypeForgeRules: {
-    readonly 'prefer-non-empty-array': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useNonEmptyArray", readonly [(Readonly<{
-        importStyle?: "global" | "named";
+    readonly 'prefer-canonical-length-constrained-tuple': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useCanonicalTuple", readonly [(Readonly<{
+        importStyle?: 'global' | 'named';
+        maxLength?: number;
     }> | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
 };
 //# sourceMappingURL=rules.d.mts.map

package/dist/rules/rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../src/rules/rules.mts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB;;;;CAEa,CAAC"}
+{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../src/rules/rules.mts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB;;;;;CAGa,CAAC"}

package/dist/rules/rules.mjs

@@ -1,7 +1,7 @@
-import { preferNonEmptyArray } from './prefer-non-empty-array.mjs';
+import { preferCanonicalLengthConstrainedTuple } from './prefer-canonical-length-constrained-tuple.mjs';
 
 const tsTypeForgeRules = {
-  "prefer-non-empty-array": preferNonEmptyArray
+  "prefer-canonical-length-constrained-tuple": preferCanonicalLengthConstrainedTuple
 };
 
 export { tsTypeForgeRules };

package/dist/rules/rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rules.mjs","sources":["../../src/rules/rules.mts"],"sourcesContent":["import { type ESLintPlugin } from '../types.mjs';\nimport { preferNonEmptyArray } from './prefer-non-empty-array.mjs';\n\nexport const tsTypeForgeRules = {\n  'prefer-non-empty-array': preferNonEmptyArray,\n} as const satisfies ESLintPlugin['rules'];\n"],"names":[],"mappings":";;AAGO,MAAM,gBAAA,GAAmB;AAAA,EAC9B,wBAAA,EAA0B;AAC5B;;;;"}
+{"version":3,"file":"rules.mjs","sources":["../../src/rules/rules.mts"],"sourcesContent":["import { type ESLintPlugin } from '../types.mjs';\nimport { preferCanonicalLengthConstrainedTuple } from './prefer-canonical-length-constrained-tuple.mjs';\n\nexport const tsTypeForgeRules = {\n  'prefer-canonical-length-constrained-tuple':\n    preferCanonicalLengthConstrainedTuple,\n} as const satisfies ESLintPlugin['rules'];\n"],"names":[],"mappings":";;AAGO,MAAM,gBAAA,GAAmB;AAAA,EAC9B,2CAAA,EACE;AACJ;;;;"}

package/dist/rules/tuple-rule-utils.d.mts

@@ -0,0 +1,37 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+/** `JSONSchema4`, reached through the public rule-module types. */
+type JsonSchema = Exclude<TSESLint.RuleModule<string, readonly unknown[]>['meta']['schema'], readonly unknown[]>;
+export type ImportStyle = 'global' | 'named';
+export declare const DEFAULT_IMPORT_STYLE: ImportStyle;
+export declare const IMPORT_STYLE_SCHEMA_PROPERTY: JsonSchema;
+/**
+ * Resolves how a ts-type-forge type name should be written in this file, and
+ * whether the autofix has to add an import for it.
+ *
+ * Returns `undefined` when the name is already bound to something else (a local
+ * alias, or an import from another module) — rewriting to it would then silently
+ * resolve to the wrong declaration, which is exactly what happens inside
+ * ts-type-forge's own sources.
+ */
+export declare const resolveTypeName: (program: TSESTree.Program, canonicalName: string, importStyle: ImportStyle) => Readonly<{
+    localName: string;
+    needsImport: boolean;
+}> | undefined;
+export type TupleRewrite = Readonly<{
+    node: TSESTree.Node;
+    canonicalName: string;
+    /** Text inside the `<...>` of the replacement, e.g. `'2, string'`. */
+    typeArgs: string;
+}>;
+/**
+ * Emits one report per rewrite, resolving each target name and attaching every
+ * required import to the *first* report.
+ *
+ * All import fixes must live on a single report: `insertTextBefore(program, …)`
+ * produces overlapping ranges, and ESLint merges each report's fixes into one
+ * span — so spreading them across reports makes the fixes conflict and only one
+ * survives per pass.
+ */
+export declare const reportTupleRewrites: <MessageIds extends string>(context: TSESLint.RuleContext<MessageIds, readonly unknown[]>, rewrites: readonly TupleRewrite[], messageId: MessageIds, importStyle: ImportStyle) => void;
+export {};
+//# sourceMappingURL=tuple-rule-utils.d.mts.map

package/dist/rules/tuple-rule-utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple-rule-utils.d.mts","sourceRoot":"","sources":["../../src/rules/tuple-rule-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAWxE,mEAAmE;AACnE,KAAK,UAAU,GAAG,OAAO,CACvB,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,EACjE,SAAS,OAAO,EAAE,CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE7C,eAAO,MAAM,oBAAoB,EAAE,WAAsB,CAAC;AAE1D,eAAO,MAAM,4BAA4B,EAAE,UAW1C,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,YACjB,QAAQ,CAAC,OAAO,iBACV,MAAM,eACR,WAAW,KACvB,QAAQ,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAAC,GAAG,SAa1D,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC;IAClC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAAI,UAAU,SAAS,MAAM,WAClD,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,SAAS,OAAO,EAAE,CAAC,YACnD,SAAS,YAAY,EAAE,aACtB,UAAU,eACR,WAAW,KACvB,IAsCF,CAAC"}