eslint-plugin-ts-type-forge 0.8.0 → 0.8.1

package/dist/index.mjs

@@ -1,3 +1,3 @@
 export { eslintPluginTsTypeForge } from './plugin.mjs';
-export { tsTypeForgeRules } from './rules/rules.mjs';
-//# sourceMappingURL=index.mjs.map
+export { tsTypeForgeRules } from './rules/index.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAKvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/plugin.mjs

@@ -1,37 +1,40 @@
-import { tsTypeForgeRules } from './rules/rules.mjs';
+import { tsTypeForgeRules } from './rules/index.mjs';
+
+
+
+
+
 
 const recommendedRules = {
-  "ts-type-forge/no-side-effect-import": "error",
-  "ts-type-forge/prefer-canonical-length-constrained-tuple": "error",
-  "ts-type-forge/prefer-canonical-mutable-record": "error",
-  "ts-type-forge/prefer-readonly-or-mutable-record": "error",
-  "ts-type-forge/prefer-strict-or-relaxed-utility-type": "error"
+    'ts-type-forge/no-side-effect-import': 'error',
+    'ts-type-forge/prefer-canonical-length-constrained-tuple': 'error',
+    'ts-type-forge/prefer-canonical-mutable-record': 'error',
+    'ts-type-forge/prefer-readonly-or-mutable-record': 'error',
+    'ts-type-forge/prefer-strict-or-relaxed-utility-type': 'error',
 };
 const recommendedConfig = {
-  name: "ts-type-forge/recommended",
-  plugins: {
-    // Resolved lazily so that this config registers the *same* object that
-    // `eslintPluginTsTypeForge` refers to. ESLint rejects a plugin name that
-    // maps to two different objects with `Cannot redefine plugin`, which is
-    // what a user combining this preset with their own
-    // `plugins: { 'ts-type-forge': eslintPluginTsTypeForge }` entry would hit
-    // if the preset embedded a separate copy of the plugin.
-    get "ts-type-forge"() {
-      return eslintPluginTsTypeForge;
-    }
-  },
-  rules: recommendedRules
-};
-const eslintPluginTsTypeForge = {
-  meta: {
-    name: "eslint-plugin-ts-type-forge"
-  },
-  rules: tsTypeForgeRules,
-  configs: {
-    /** Enables every rule of this plugin at `error`. */
-    recommended: recommendedConfig
-  }
+    name: 'ts-type-forge/recommended',
+    plugins: {
+
+
+
+
+
+
+        get 'ts-type-forge'() {
+            return eslintPluginTsTypeForge;
+        },
+    },
+    rules: recommendedRules,
 };
+export const eslintPluginTsTypeForge = {
+    meta: {
+        name: 'eslint-plugin-ts-type-forge',
+    },
+    rules: tsTypeForgeRules,
+    configs: {
 
-export { eslintPluginTsTypeForge };
-//# sourceMappingURL=plugin.mjs.map
+        recommended: recommendedConfig,
+    },
+};
+//# sourceMappingURL=plugin.mjs.map

package/dist/plugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.mjs","sources":["../src/plugin.mts"],"sourcesContent":["import { tsTypeForgeRules } from './rules/index.mjs';\nimport { type ESLintFlatConfig, type ESLintPlugin } from './types.mjs';\n\n/**\n * Every rule this plugin ships, at `error`.\n *\n * The `satisfies` clause below is keyed off {@link tsTypeForgeRules}, so adding\n * a rule without listing it here fails to type-check.\n */\nconst recommendedRules = {\n  'ts-type-forge/no-side-effect-import': 'error',\n  'ts-type-forge/prefer-canonical-length-constrained-tuple': 'error',\n  'ts-type-forge/prefer-canonical-mutable-record': 'error',\n  'ts-type-forge/prefer-readonly-or-mutable-record': 'error',\n  'ts-type-forge/prefer-strict-or-relaxed-utility-type': 'error',\n} as const satisfies Readonly<\n  Record<`ts-type-forge/${keyof typeof tsTypeForgeRules}`, 'error'>\n>;\n\nconst recommendedConfig = {\n  name: 'ts-type-forge/recommended',\n  plugins: {\n    // Resolved lazily so that this config registers the *same* object that\n    // `eslintPluginTsTypeForge` refers to. ESLint rejects a plugin name that\n    // maps to two different objects with `Cannot redefine plugin`, which is\n    // what a user combining this preset with their own\n    // `plugins: { 'ts-type-forge': eslintPluginTsTypeForge }` entry would hit\n    // if the preset embedded a separate copy of the plugin.\n    get 'ts-type-forge'(): ESLintPlugin {\n      return eslintPluginTsTypeForge;\n    },\n  },\n  rules: recommendedRules,\n} as const satisfies ESLintFlatConfig;\n\nexport const eslintPluginTsTypeForge = {\n  meta: {\n    name: 'eslint-plugin-ts-type-forge',\n  },\n  rules: tsTypeForgeRules,\n  configs: {\n    /** Enables every rule of this plugin at `error`. */\n    recommended: recommendedConfig,\n  },\n} as const satisfies ESLintPlugin;\n"],"names":[],"mappings":";;AASA,MAAM,gBAAA,GAAmB;AAAA,EACvB,qCAAA,EAAuC,OAAA;AAAA,EACvC,yDAAA,EAA2D,OAAA;AAAA,EAC3D,+CAAA,EAAiD,OAAA;AAAA,EACjD,iDAAA,EAAmD,OAAA;AAAA,EACnD,qDAAA,EAAuD;AACzD,CAAA;AAIA,MAAM,iBAAA,GAAoB;AAAA,EACxB,IAAA,EAAM,2BAAA;AAAA,EACN,OAAA,EAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOP,IAAI,eAAA,GAAgC;AAClC,MAAA,OAAO,uBAAA;AAAA,IACT;AAAA,GACF;AAAA,EACA,KAAA,EAAO;AACT,CAAA;AAEO,MAAM,uBAAA,GAA0B;AAAA,EACrC,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM;AAAA,GACR;AAAA,EACA,KAAA,EAAO,gBAAA;AAAA,EACP,OAAA,EAAS;AAAA;AAAA,IAEP,WAAA,EAAa;AAAA;AAEjB;;"}
+{"version":3,"file":"plugin.mjs","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAGrD;;;;;GAKG;AACH,MAAM,gBAAgB,GAAG;IACvB,qCAAqC,EAAE,OAAO;IAC9C,yDAAyD,EAAE,OAAO;IAClE,+CAA+C,EAAE,OAAO;IACxD,iDAAiD,EAAE,OAAO;IAC1D,qDAAqD,EAAE,OAAO;CAG/D,CAAC;AAEF,MAAM,iBAAiB,GAAG;IACxB,IAAI,EAAE,2BAA2B;IACjC,OAAO,EAAE;QACP,uEAAuE;QACvE,yEAAyE;QACzE,wEAAwE;QACxE,mDAAmD;QACnD,0EAA0E;QAC1E,wDAAwD;QACxD,IAAI,eAAe;YACjB,OAAO,uBAAuB,CAAC;QACjC,CAAC;KACF;IACD,KAAK,EAAE,gBAAgB;CACY,CAAC;AAEtC,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,IAAI,EAAE;QACJ,IAAI,EAAE,6BAA6B;KACpC;IACD,KAAK,EAAE,gBAAgB;IACvB,OAAO,EAAE;QACP,oDAAoD;QACpD,WAAW,EAAE,iBAAiB;KAC/B;CAC8B,CAAC"}

package/dist/rule-types.mjs

@@ -1,2 +1,3 @@
 
-//# sourceMappingURL=rule-types.mjs.map
+export {};
+//# sourceMappingURL=rule-types.mjs.map

package/dist/rule-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rule-types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"rule-types.mjs","sourceRoot":"","sources":["../src/rule-types.mts"],"names":[],"mappings":"AAAA,oBAAoB"}

package/dist/rules/ast-utils.mjs

@@ -1,123 +1,244 @@
-import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
-import { Arr, isRecord, hasKey, isNonNullObject } from 'ts-data-forge';
+import { AST_NODE_TYPES, ASTUtils, } from '@typescript-eslint/utils';
+import { Arr, hasKey, isNonNullObject, isRecord } from 'ts-data-forge';
 
-const isLocallyBound = (sourceCode, node, name) => {
-  const variable = ASTUtils.findVariable(sourceCode.getScope(node), name);
-  return variable !== null && Arr.isNonEmpty(variable.defs);
+
+
+
+
+
+
+
+
+
+
+export const isLocallyBound = (sourceCode, node, name) => {
+    const variable = ASTUtils.findVariable(sourceCode.getScope(node), name);
+    return variable !== null && Arr.isNonEmpty(variable.defs);
 };
-const analyzeUniformTuple = (tuple, sourceCode) => {
-  if (isInConditionalTypeExtendsClause(tuple)) return void 0;
-  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 ? Arr.butLast(elements) : elements;
-  if (Arr.isEmpty(leading) || leading.some(
-    (element) => element.type === AST_NODE_TYPES.TSRestType || element.type === AST_NODE_TYPES.TSOptionalType || element.type === AST_NODE_TYPES.TSNamedTupleMember
-  )) {
-    return 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 = [
-    ...Arr.tail(leading),
-    ...restElementType === void 0 ? [] : [restElementType]
-  ];
-  if (others.some(
-    (element) => normalizeWhitespace(sourceCode.getText(element)) !== expected
-  )) {
-    return void 0;
-  }
-  return definesRecursiveTypeAlias(tuple, sourceCode) ? void 0 : {
-    node: isReadonly ? parent : tuple,
-    isReadonly,
-    elementText,
-    fixedCount: leading.length,
-    hasRest
-  };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const analyzeUniformTuple = (tuple, sourceCode) => {
+    if (isInConditionalTypeExtendsClause(tuple))
+        return undefined;
+    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 ? Arr.butLast(elements) : elements;
+    if (Arr.isEmpty(leading) ||
+        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 = 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);
+    const expected = normalizeWhitespace(elementText);
+    const others = [
+        ...Arr.tail(leading),
+        ...(restElementType === undefined ? [] : [restElementType]),
+    ];
+    if (others.some((element) => normalizeWhitespace(sourceCode.getText(element)) !== expected)) {
+        return undefined;
+    }
+    return definesRecursiveTypeAlias(tuple, sourceCode)
+        ? undefined
+        : {
+            node: isReadonly ? parent : tuple,
+            isReadonly,
+            elementText,
+            fixedCount: leading.length,
+            hasRest,
+        };
 };
+
+
+
+
+
+
+
+
+
+
+
 const isInConditionalTypeExtendsClause = (node) => {
-  if (node.type === AST_NODE_TYPES.Program) return false;
-  const { parent } = node;
-  return parent.type === AST_NODE_TYPES.TSConditionalType && parent.extendsType === node || isInConditionalTypeExtendsClause(parent);
+
+    if (node.type === AST_NODE_TYPES.Program)
+        return false;
+    const { parent } = node;
+    return ((parent.type === AST_NODE_TYPES.TSConditionalType &&
+        parent.extendsType === node) ||
+        isInConditionalTypeExtendsClause(parent));
 };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 const definesRecursiveTypeAlias = (tuple, sourceCode) => {
-  const alias = enclosingTypeAlias(tuple);
-  if (alias === void 0) return false;
-  const references = aliasReferenceGraph(programOf(alias), sourceCode);
-  const mut_seen = /* @__PURE__ */ new Set();
-  const mut_queue = tuple.elementTypes.flatMap(
-    (element) => Array.from(referencedTypeNames(element, sourceCode))
-  );
-  while (true) {
-    const next = mut_queue.pop();
-    if (next === void 0) return false;
-    if (next === alias.id.name) return true;
-    if (mut_seen.has(next)) continue;
-    mut_seen.add(next);
-    const referenced = references.get(next);
-    if (referenced !== void 0) {
-      mut_queue.push(...referenced);
+    const alias = enclosingTypeAlias(tuple);
+    if (alias === undefined)
+        return false;
+    const references = aliasReferenceGraph(programOf(alias), sourceCode);
+    const mut_seen = new Set();
+    const mut_queue = tuple.elementTypes.flatMap((element) => Array.from(referencedTypeNames(element, sourceCode)));
+    while (true) {
+        const next = mut_queue.pop();
+        if (next === undefined)
+            return false;
+        if (next === alias.id.name)
+            return true;
+        if (mut_seen.has(next))
+            continue;
+        mut_seen.add(next);
+        const referenced = references.get(next);
+        if (referenced !== undefined) {
+            mut_queue.push(...referenced);
+        }
     }
-  }
 };
+
 const enclosingTypeAlias = (node) => {
-  if (node.type === AST_NODE_TYPES.TSTypeAliasDeclaration) return node;
-  if (node.type === AST_NODE_TYPES.Program) return void 0;
-  return enclosingTypeAlias(node.parent);
+    if (node.type === AST_NODE_TYPES.TSTypeAliasDeclaration)
+        return node;
+    if (node.type === AST_NODE_TYPES.Program)
+        return undefined;
+    return enclosingTypeAlias(node.parent);
 };
+
+
+
+
+
+
+
 const aliasReferenceGraph = (program, sourceCode) => {
-  const cached = aliasReferenceGraphCache.get(program);
-  if (cached !== void 0) return cached;
-  const mut_graph = /* @__PURE__ */ new Map();
-  walk(program, sourceCode, (visited) => {
-    if (visited.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {
-      mut_graph.set(
-        visited.id.name,
-        referencedTypeNames(visited.typeAnnotation, sourceCode)
-      );
-    }
-  });
-  aliasReferenceGraphCache.set(program, mut_graph);
-  return mut_graph;
+    const cached = aliasReferenceGraphCache.get(program);
+    if (cached !== undefined)
+        return cached;
+    const mut_graph = new Map();
+    walk(program, sourceCode, (visited) => {
+        if (visited.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {
+            mut_graph.set(visited.id.name, referencedTypeNames(visited.typeAnnotation, sourceCode));
+        }
+    });
+    aliasReferenceGraphCache.set(program, mut_graph);
+    return mut_graph;
 };
-const aliasReferenceGraphCache = /* @__PURE__ */ new WeakMap();
+const aliasReferenceGraphCache = new WeakMap();
 const programOf = (node) => node.type === AST_NODE_TYPES.Program ? node : programOf(node.parent);
+
 const referencedTypeNames = (node, sourceCode) => {
-  const mut_names = /* @__PURE__ */ new Set();
-  walk(node, sourceCode, (visited) => {
-    if (visited.type === AST_NODE_TYPES.TSTypeReference && visited.typeName.type === AST_NODE_TYPES.Identifier) {
-      mut_names.add(visited.typeName.name);
-    }
-  });
-  return mut_names;
+    const mut_names = new Set();
+    walk(node, sourceCode, (visited) => {
+        if (visited.type === AST_NODE_TYPES.TSTypeReference &&
+            visited.typeName.type === AST_NODE_TYPES.Identifier) {
+            mut_names.add(visited.typeName.name);
+        }
+    });
+    return mut_names;
 };
+
+
+
+
+
+
+
+
+
 const walk = (node, sourceCode, visit) => {
-  visit(node);
-  if (!isRecord(node)) return;
-  const keys = sourceCode.visitorKeys[node.type] ?? Object.keys(node).filter((key) => key !== "parent");
-  for (const key of keys) {
-    const value = hasKey(node, key) ? node[key] : void 0;
-    if (Arr.isArray(value)) {
-      for (const element of value) {
-        if (isNode(element)) walk(element, sourceCode, visit);
-      }
-    } else if (isNode(value)) {
-      walk(value, sourceCode, visit);
+    visit(node);
+    if (!isRecord(node))
+        return;
+    const keys = sourceCode.visitorKeys[node.type] ??
+        Object.keys(node).filter((key) => key !== 'parent');
+    for (const key of keys) {
+        const value = hasKey(node, key) ? node[key] : undefined;
+        if (Arr.isArray(value)) {
+            for (const element of value) {
+                if (isNode(element))
+                    walk(element, sourceCode, visit);
+            }
+        }
+        else if (isNode(value)) {
+            walk(value, sourceCode, visit);
+        }
     }
-  }
 };
-const isNode = (value) => isNonNullObject(value) && typeof value.type === "string";
+const isNode = (value) => isNonNullObject(value) &&
+    typeof value.type === 'string';
+
 const getArrayElementType = (node) => {
-  if (node.type === AST_NODE_TYPES.TSArrayType) return node.elementType;
-  return node.type === AST_NODE_TYPES.TSTypeOperator && node.operator === "readonly" && node.typeAnnotation?.type === AST_NODE_TYPES.TSArrayType ? node.typeAnnotation.elementType : void 0;
+    if (node.type === AST_NODE_TYPES.TSArrayType)
+        return node.elementType;
+    return node.type === AST_NODE_TYPES.TSTypeOperator &&
+        node.operator === 'readonly' &&
+        node.typeAnnotation?.type === AST_NODE_TYPES.TSArrayType
+        ? node.typeAnnotation.elementType
+        : undefined;
 };
-const normalizeWhitespace = (text) => text.replaceAll(/\s+/gu, " ").trim();
-
-export { analyzeUniformTuple, isLocallyBound };
-//# sourceMappingURL=ast-utils.mjs.map
+const normalizeWhitespace = (text) => text.replaceAll(/\s+/gu, ' ').trim();
+//# 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  ASTUtils,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { Arr, hasKey, isNonNullObject, isRecord } from 'ts-data-forge';\n\n/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */\n\n/**\n * Whether `name` resolves to a declaration in this file (a type alias, an\n * interface, a class, an import, …) rather than to the ambient standard-library\n * type of the same name.\n *\n * The `defs` check is what separates the two: ESLint materializes an *implicit*\n * global variable for every unresolved reference, so `findVariable` also\n * succeeds for `Exclude` in a file that never declares it. Only a variable with\n * at least one definition was actually written down somewhere in this file.\n */\nexport const isLocallyBound = (\n  sourceCode: TSESLint.SourceCode,\n  node: TSESTree.Node,\n  name: string,\n): boolean => {\n  const variable = ASTUtils.findVariable(sourceCode.getScope(node), name);\n\n  return variable !== null && Arr.isNonEmpty(variable.defs);\n};\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 * - A tuple inside the `extends` clause of a conditional type is a match\n *   pattern, not a type (see {@link isInConditionalTypeExtendsClause}).\n */\nexport const analyzeUniformTuple = (\n  tuple: TSESTree.TSTupleType,\n  sourceCode: TSESLint.SourceCode,\n): UniformTupleShape | undefined => {\n  if (isInConditionalTypeExtendsClause(tuple)) return undefined;\n\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 ? Arr.butLast(elements) : elements;\n\n  if (\n    Arr.isEmpty(leading) ||\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    ...Arr.tail(leading),\n    ...(restElementType === undefined ? [] : [restElementType]),\n  ];\n\n  if (\n    others.some(\n      (element) =>\n        normalizeWhitespace(sourceCode.getText(element)) !== expected,\n    )\n  ) {\n    return undefined;\n  }\n\n  return definesRecursiveTypeAlias(tuple, sourceCode)\n    ? undefined\n    : {\n        node: isReadonly ? parent : tuple,\n        isReadonly,\n        elementText,\n        fixedCount: leading.length,\n        hasRest,\n      };\n};\n\n/**\n * Whether `node` sits inside the `extends` clause of a conditional type, where\n * a tuple is a *match pattern* rather than a type.\n *\n * `[A, B] extends [true, true]` matches element-wise even while `A` and `B` are\n * still generic. The canonical spellings resolve through a mapped type\n * (`MutableFixedLengthTuple<N, V>` is `Mutable<FixedLengthTuple<N, V>>`), and\n * against one of those the checker defers the whole conditional instead —\n * yielding `boolean` where the tuple pattern yielded `true` or `false`, which\n * silently widens everything downstream. So those positions are left alone.\n */\nconst isInConditionalTypeExtendsClause = (node: TSESTree.Node): boolean => {\n  // The root has no parent, so it terminates the walk.\n  if (node.type === AST_NODE_TYPES.Program) return false;\n\n  const { parent } = node;\n\n  return (\n    (parent.type === AST_NODE_TYPES.TSConditionalType &&\n      parent.extendsType === node) ||\n    isInConditionalTypeExtendsClause(parent)\n  );\n};\n\n/**\n * Whether the tuple spells out an alias that its own element type leads back\n * to.\n *\n * A tuple literal is how TypeScript's cycle-breaking works: `type T = readonly\n * [T, T]` resolves, because the element positions are deferred. Rewriting it to\n * `FixedLengthTuple<2, T>` routes the same cycle through a mapped type, which\n * the checker will not compute — `T` becomes an error type, and every use of it\n * silently reads as `any`. `tsc` reports the alias once; the typed linter then\n * reports each use, which is how this was found.\n *\n * The cycle is often indirect. `LambdaApplication = readonly [LambdaTerm,\n * LambdaTerm]` looks fine on its own, and only recurses because `LambdaTerm` is\n * a union that includes `LambdaApplication`. So this follows references through\n * the other aliases in the file rather than looking for the enclosing name in\n * the element text.\n *\n * **Any cycle counts, which leaves some rewritable tuples alone.** Not every\n * cycle actually breaks: TypeScript resolves an object type, an array, a tuple\n * and a function type without resolving what is inside them, so `type Pair =\n * FixedLengthTuple<2, Foo>` alongside `type Foo = { p: Pair }` compiles, and so\n * does `type Tree = { kids: FixedLengthTuple<2, Tree> }`. Skipping those\n * constructs while following references was tried and does not hold up — the\n * deferral is undone by anything that asks for the structure, and that can sit\n * anywhere in the file:\n *\n * ```ts\n * type Pair = readonly [Foo, Foo]; // rewriting this breaks Pair and Foo\n * type Foo = Wrapper[number]; // …because of the indexed access here\n * type Wrapper = readonly Pair[];\n * ```\n *\n * Deciding it properly means knowing every use of every alias, which no\n * syntactic rule can do — so a cycle of any shape suppresses the rewrite. The\n * cost is a tuple left spelled out; the alternative is an autofix that turns a\n * type into `any`.\n *\n * A cycle closed through an `import` is not visible here and is not detected.\n */\nconst definesRecursiveTypeAlias = (\n  tuple: TSESTree.TSTupleType,\n  sourceCode: TSESLint.SourceCode,\n): boolean => {\n  const alias = enclosingTypeAlias(tuple);\n\n  if (alias === undefined) return false;\n\n  const references = aliasReferenceGraph(programOf(alias), sourceCode);\n\n  const mut_seen = new Set<string>();\n\n  const mut_queue: string[] = tuple.elementTypes.flatMap((element) =>\n    Array.from(referencedTypeNames(element, sourceCode)),\n  );\n\n  while (true) {\n    const next = mut_queue.pop();\n\n    if (next === undefined) return false;\n\n    if (next === alias.id.name) return true;\n\n    if (mut_seen.has(next)) continue;\n\n    mut_seen.add(next);\n\n    const referenced = references.get(next);\n\n    if (referenced !== undefined) {\n      mut_queue.push(...referenced);\n    }\n  }\n};\n\n/** The `type X = …` declaration `node` sits in, if any. */\nconst enclosingTypeAlias = (\n  node: TSESTree.Node,\n): TSESTree.TSTypeAliasDeclaration | undefined => {\n  if (node.type === AST_NODE_TYPES.TSTypeAliasDeclaration) return node;\n\n  if (node.type === AST_NODE_TYPES.Program) return undefined;\n\n  return enclosingTypeAlias(node.parent);\n};\n\n/**\n * Which other type names each `type X = …` in the file refers to, keyed by `X`.\n *\n * Built once per file and cached on the `Program` node: the search below runs\n * per candidate tuple, and rebuilding this for each of them made the rule cost\n * `O(tuples × file size)` — a full second on the largest generated files here.\n */\nconst aliasReferenceGraph = (\n  program: TSESTree.Program,\n  sourceCode: TSESLint.SourceCode,\n): ReadonlyMap<string, ReadonlySet<string>> => {\n  const cached = aliasReferenceGraphCache.get(program);\n\n  if (cached !== undefined) return cached;\n\n  const mut_graph = new Map<string, ReadonlySet<string>>();\n\n  walk(program, sourceCode, (visited) => {\n    if (visited.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {\n      mut_graph.set(\n        visited.id.name,\n        referencedTypeNames(visited.typeAnnotation, sourceCode),\n      );\n    }\n  });\n\n  aliasReferenceGraphCache.set(program, mut_graph);\n\n  return mut_graph;\n};\n\nconst aliasReferenceGraphCache = new WeakMap<\n  TSESTree.Program,\n  ReadonlyMap<string, ReadonlySet<string>>\n>();\n\nconst programOf = (node: TSESTree.Node): TSESTree.Program =>\n  node.type === AST_NODE_TYPES.Program ? node : programOf(node.parent);\n\n/** The names every `X` / `X<…>` reference in the subtree points at. */\nconst referencedTypeNames = (\n  node: TSESTree.Node,\n  sourceCode: TSESLint.SourceCode,\n): ReadonlySet<string> => {\n  const mut_names = new Set<string>();\n\n  walk(node, sourceCode, (visited) => {\n    if (\n      visited.type === AST_NODE_TYPES.TSTypeReference &&\n      visited.typeName.type === AST_NODE_TYPES.Identifier\n    ) {\n      mut_names.add(visited.typeName.name);\n    }\n  });\n\n  return mut_names;\n};\n\n/**\n * Visits `node` and its descendants.\n *\n * Children are found through the parser's visitor keys, so only the properties\n * that actually hold one are read. Reading every own property instead works\n * too, and is the fallback for a parser that declares no keys for a node type,\n * but it allocates an entry pair per property and walks `loc` / `range` as\n * well — on the generated rule-type files that alone was most of the cost.\n */\nconst walk = (\n  node: TSESTree.Node,\n  sourceCode: TSESLint.SourceCode,\n  visit: (visited: TSESTree.Node) => void,\n): void => {\n  visit(node);\n\n  if (!isRecord(node)) return;\n\n  const keys =\n    sourceCode.visitorKeys[node.type] ??\n    Object.keys(node).filter((key) => key !== 'parent');\n\n  for (const key of keys) {\n    const value: unknown = hasKey(node, key) ? node[key] : undefined;\n\n    if (Arr.isArray(value)) {\n      for (const element of value) {\n        if (isNode(element)) walk(element, sourceCode, visit);\n      }\n    } else if (isNode(value)) {\n      walk(value, sourceCode, visit);\n    }\n  }\n};\n\nconst isNode = (value: unknown): value is TSESTree.Node =>\n  isNonNullObject(value) &&\n  typeof (value as Readonly<{ type?: unknown }>).type === 'string';\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"],"names":[],"mappings":"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"}
+{"version":3,"file":"ast-utils.mjs","sourceRoot":"","sources":["../../src/rules/ast-utils.mts"],"names":[],"mappings":"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"}

package/dist/rules/constants.mjs

@@ -1,11 +1,14 @@
-const TS_TYPE_FORGE_MODULE = "ts-type-forge";
-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 { 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
+export const TS_TYPE_FORGE_MODULE = 'ts-type-forge';
+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';
+
+
+
+
+
+export const DEFAULT_MAX_TUPLE_LENGTH = 10;
+//# 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_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;;"}
+{"version":3,"file":"constants.mjs","sourceRoot":"","sources":["../../src/rules/constants.mts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC;AAEpD,MAAM,CAAC,MAAM,yBAAyB,GAAG,eAAe,CAAC;AAEzD,MAAM,CAAC,MAAM,iCAAiC,GAAG,sBAAsB,CAAC;AAExE,MAAM,CAAC,MAAM,0BAA0B,GAAG,gBAAgB,CAAC;AAE3D,MAAM,CAAC,MAAM,kCAAkC,GAAG,uBAAuB,CAAC;AAE1E,MAAM,CAAC,MAAM,4BAA4B,GAAG,kBAAkB,CAAC;AAE/D,MAAM,CAAC,MAAM,oCAAoC,GAAG,yBAAyB,CAAC;AAE9E;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,CAAC"}

package/dist/rules/import-style.mjs

@@ -1,29 +1,34 @@
 import { TS_TYPE_FORGE_MODULE } from './constants.mjs';
-import { getImportedLocalName, getTsTypeForgeImports, hasConflictingDeclaration } from './import-utils.mjs';
-
-const DEFAULT_IMPORT_STYLE = "named";
-const IMPORT_STYLE_SCHEMA_PROPERTY = {
-  type: "string",
-  enum: ["global", "named"],
-  description: [
-    "How the ts-type-forge type is brought into scope.",
-    "'named' (default) makes the autofix add the corresponding",
-    `\`import { type \u2026 } from '${TS_TYPE_FORGE_MODULE}';\``,
-    "when the name is not imported yet; 'global' assumes the",
-    "ambient globals of `ts-type-forge/global` and never touches",
-    "imports."
-  ].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" };
+import { getImportedLocalName, getTsTypeForgeImports, hasConflictingDeclaration, } from './import-utils.mjs';
+export const DEFAULT_IMPORT_STYLE = 'named';
+export const IMPORT_STYLE_SCHEMA_PROPERTY = {
+    type: 'string',
+    enum: ['global', 'named'],
+    description: [
+        'How the ts-type-forge type is brought into scope.',
+        "'named' (default) makes the autofix add the corresponding",
+        `\`import { type … } from '${TS_TYPE_FORGE_MODULE}';\``,
+        "when the name is not imported yet; 'global' assumes the",
+        'ambient globals of `ts-type-forge/global` and never touches',
+        'imports.',
+    ].join(' '),
 };
 
-export { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY, resolveTypeName };
-//# sourceMappingURL=import-style.mjs.map
+
+
+
+
+
+
+
+
+export const resolveTypeName = (program, canonicalName, importStyle) => {
+    const importedLocalName = getImportedLocalName(getTsTypeForgeImports(program), canonicalName);
+    if (importedLocalName !== undefined) {
+        return { localName: importedLocalName, needsImport: false };
+    }
+    return hasConflictingDeclaration(program, canonicalName)
+        ? undefined
+        : { localName: canonicalName, needsImport: importStyle === 'named' };
+};
+//# sourceMappingURL=import-style.mjs.map

package/dist/rules/import-style.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"import-style.mjs","sources":["../../src/rules/import-style.mts"],"sourcesContent":["import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';\nimport { TS_TYPE_FORGE_MODULE } from './constants.mjs';\nimport {\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 = 'named';\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    \"'named' (default) makes the autofix add the corresponding\",\n    `\\`import { type … } from '${TS_TYPE_FORGE_MODULE}';\\``,\n    \"when the name is not imported yet; 'global' assumes the\",\n    'ambient globals of `ts-type-forge/global` and never touches',\n    'imports.',\n  ].join(' '),\n};\n\n/**\n * Resolves how a ts-type-forge type name should be written in this file, and\n * whether the fix 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"],"names":[],"mappings":";;;AAkBO,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,2DAAA;AAAA,IACA,kCAA6B,oBAAoB,CAAA,IAAA,CAAA;AAAA,IACjD,yDAAA;AAAA,IACA,6DAAA;AAAA,IACA;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;;"}
+{"version":3,"file":"import-style.mjs","sourceRoot":"","sources":["../../src/rules/import-style.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EACL,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,oBAAoB,CAAC;AAY5B,MAAM,CAAC,MAAM,oBAAoB,GAAgB,OAAO,CAAC;AAEzD,MAAM,CAAC,MAAM,4BAA4B,GAAe;IACtD,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE;QACX,mDAAmD;QACnD,2DAA2D;QAC3D,6BAA6B,oBAAoB,MAAM;QACvD,yDAAyD;QACzD,6DAA6D;QAC7D,UAAU;KACX,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,OAAyB,EACzB,aAAqB,EACrB,WAAwB,EAC2C,EAAE;IACrE,MAAM,iBAAiB,GAAG,oBAAoB,CAC5C,qBAAqB,CAAC,OAAO,CAAC,EAC9B,aAAa,CACd,CAAC;IAEF,IAAI,iBAAiB,KAAK,SAAS,EAAE,CAAC;QACpC,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;IAC9D,CAAC;IAED,OAAO,yBAAyB,CAAC,OAAO,EAAE,aAAa,CAAC;QACtD,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,EAAE,SAAS,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,KAAK,OAAO,EAAE,CAAC;AACzE,CAAC,CAAC"}