eslint-plugin-ts-type-forge 0.4.3 → 0.6.0

package/dist/rules/prefer-strict-or-relaxed-utility-type.mjs

@@ -0,0 +1,49 @@
+import { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY } from './import-style.mjs';
+import { reportStdTypeReference } from './std-type-rule-utils.mjs';
+
+const ALTERNATIVES = /* @__PURE__ */ new Map([
+  ["Exclude", ["StrictExclude", "RelaxedExclude"]],
+  ["Extract", ["StrictExtract", "RelaxedExtract"]],
+  ["Omit", ["StrictOmit", "RelaxedOmit"]],
+  ["Pick", ["StrictPick", "RelaxedPick"]]
+]);
+const preferStrictOrRelaxedUtilityType = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Replace the built-in `Exclude` / `Extract` / `Omit` / `Pick` with the ts-type-forge `Strict*` or `Relaxed*` counterpart, so that the unchecked second argument becomes an explicit choice."
+    },
+    hasSuggestions: true,
+    schema: [
+      {
+        type: "object",
+        properties: {
+          importStyle: IMPORT_STYLE_SCHEMA_PROPERTY
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      useStrictOrRelaxed: "Use {{alternatives}} from ts-type-forge instead of the built-in `{{name}}`.",
+      replaceWith: "Replace `{{name}}` with `{{replacement}}`."
+    }
+  },
+  create: (context) => {
+    const importStyle = context.options[0]?.importStyle ?? DEFAULT_IMPORT_STYLE;
+    return {
+      TSTypeReference: (node) => {
+        reportStdTypeReference(
+          context,
+          node,
+          ALTERNATIVES,
+          { report: "useStrictOrRelaxed", suggestion: "replaceWith" },
+          importStyle
+        );
+      }
+    };
+  },
+  defaultOptions: [{ importStyle: DEFAULT_IMPORT_STYLE }]
+};
+
+export { preferStrictOrRelaxedUtilityType };
+//# sourceMappingURL=prefer-strict-or-relaxed-utility-type.mjs.map

package/dist/rules/prefer-strict-or-relaxed-utility-type.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-strict-or-relaxed-utility-type.mjs","sources":["../../src/rules/prefer-strict-or-relaxed-utility-type.mts"],"sourcesContent":["import { type TSESLint } from '@typescript-eslint/utils';\nimport {\n  DEFAULT_IMPORT_STYLE,\n  IMPORT_STYLE_SCHEMA_PROPERTY,\n} from './import-style.mjs';\nimport {\n  reportStdTypeReference,\n  type StdTypeAlternatives,\n} from './std-type-rule-utils.mjs';\n\ntype Options = readonly [\n  Readonly<{\n    importStyle?: 'global' | 'named';\n  }>?,\n];\n\ntype MessageIds = 'useStrictOrRelaxed' | 'replaceWith';\n\n/**\n * The standard-library types whose second argument is unchecked, and the\n * ts-type-forge pair that makes the choice explicit.\n *\n * `Strict*` constrains the second argument (`U extends T` / `K extends keyof T`),\n * so a key that does not exist — typically a leftover after a rename — is a\n * compile error instead of a silently empty result. `Relaxed*` keeps the\n * standard-library behavior for the cases that genuinely need it (a subtrahend\n * that is not provably part of the union, a key set computed from a still\n * deferred type parameter).\n */\nconst ALTERNATIVES: StdTypeAlternatives = new Map([\n  ['Exclude', ['StrictExclude', 'RelaxedExclude']],\n  ['Extract', ['StrictExtract', 'RelaxedExtract']],\n  ['Omit', ['StrictOmit', 'RelaxedOmit']],\n  ['Pick', ['StrictPick', 'RelaxedPick']],\n]);\n\nexport const preferStrictOrRelaxedUtilityType: TSESLint.RuleModule<\n  MessageIds,\n  Options\n> = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Replace the built-in `Exclude` / `Extract` / `Omit` / `Pick` with the ts-type-forge `Strict*` or `Relaxed*` counterpart, so that the unchecked second argument becomes an explicit choice.',\n    },\n    hasSuggestions: true,\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          importStyle: IMPORT_STYLE_SCHEMA_PROPERTY,\n        },\n        additionalProperties: false,\n      },\n    ],\n    messages: {\n      useStrictOrRelaxed:\n        'Use {{alternatives}} from ts-type-forge instead of the built-in `{{name}}`.',\n      replaceWith: 'Replace `{{name}}` with `{{replacement}}`.',\n    },\n  },\n\n  create: (context) => {\n    const importStyle = context.options[0]?.importStyle ?? DEFAULT_IMPORT_STYLE;\n\n    return {\n      TSTypeReference: (node) => {\n        reportStdTypeReference(\n          context,\n          node,\n          ALTERNATIVES,\n          { report: 'useStrictOrRelaxed', suggestion: 'replaceWith' },\n          importStyle,\n        );\n      },\n    };\n  },\n  defaultOptions: [{ importStyle: DEFAULT_IMPORT_STYLE }],\n} as const;\n"],"names":[],"mappings":";;;AA6BA,MAAM,YAAA,uBAAwC,GAAA,CAAI;AAAA,EAChD,CAAC,SAAA,EAAW,CAAC,eAAA,EAAiB,gBAAgB,CAAC,CAAA;AAAA,EAC/C,CAAC,SAAA,EAAW,CAAC,eAAA,EAAiB,gBAAgB,CAAC,CAAA;AAAA,EAC/C,CAAC,MAAA,EAAQ,CAAC,YAAA,EAAc,aAAa,CAAC,CAAA;AAAA,EACtC,CAAC,MAAA,EAAQ,CAAC,YAAA,EAAc,aAAa,CAAC;AACxC,CAAC,CAAA;AAEM,MAAM,gCAAA,GAGT;AAAA,EACF,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM,YAAA;AAAA,IACN,IAAA,EAAM;AAAA,MACJ,WAAA,EACE;AAAA,KACJ;AAAA,IACA,cAAA,EAAgB,IAAA;AAAA,IAChB,MAAA,EAAQ;AAAA,MACN;AAAA,QACE,IAAA,EAAM,QAAA;AAAA,QACN,UAAA,EAAY;AAAA,UACV,WAAA,EAAa;AAAA,SACf;AAAA,QACA,oBAAA,EAAsB;AAAA;AACxB,KACF;AAAA,IACA,QAAA,EAAU;AAAA,MACR,kBAAA,EACE,6EAAA;AAAA,MACF,WAAA,EAAa;AAAA;AACf,GACF;AAAA,EAEA,MAAA,EAAQ,CAAC,OAAA,KAAY;AACnB,IAAA,MAAM,WAAA,GAAc,OAAA,CAAQ,OAAA,CAAQ,CAAC,GAAG,WAAA,IAAe,oBAAA;AAEvD,IAAA,OAAO;AAAA,MACL,eAAA,EAAiB,CAAC,IAAA,KAAS;AACzB,QAAA,sBAAA;AAAA,UACE,OAAA;AAAA,UACA,IAAA;AAAA,UACA,YAAA;AAAA,UACA,EAAE,MAAA,EAAQ,oBAAA,EAAsB,UAAA,EAAY,aAAA,EAAc;AAAA,UAC1D;AAAA,SACF;AAAA,MACF;AAAA,KACF;AAAA,EACF,CAAA;AAAA,EACA,cAAA,EAAgB,CAAC,EAAE,WAAA,EAAa,sBAAsB;AACxD;;;;"}

package/dist/rules/rules.d.mts

@@ -3,5 +3,11 @@ export declare const tsTypeForgeRules: {
         importStyle?: 'global' | 'named';
         maxLength?: number;
     }> | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-readonly-or-mutable-record': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceWith" | "useReadonlyOrMutableRecord", readonly [(Readonly<{
+        importStyle?: 'global' | 'named';
+    }> | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-strict-or-relaxed-utility-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceWith" | "useStrictOrRelaxed", readonly [(Readonly<{
+        importStyle?: 'global' | 'named';
+    }> | 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;;;;;CAGa,CAAC"}
+{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../src/rules/rules.mts"],"names":[],"mappings":"AAKA,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAKa,CAAC"}

package/dist/rules/rules.mjs

@@ -1,7 +1,11 @@
 import { preferCanonicalLengthConstrainedTuple } from './prefer-canonical-length-constrained-tuple.mjs';
+import { preferReadonlyOrMutableRecord } from './prefer-readonly-or-mutable-record.mjs';
+import { preferStrictOrRelaxedUtilityType } from './prefer-strict-or-relaxed-utility-type.mjs';
 
 const tsTypeForgeRules = {
-  "prefer-canonical-length-constrained-tuple": preferCanonicalLengthConstrainedTuple
+  "prefer-canonical-length-constrained-tuple": preferCanonicalLengthConstrainedTuple,
+  "prefer-readonly-or-mutable-record": preferReadonlyOrMutableRecord,
+  "prefer-strict-or-relaxed-utility-type": preferStrictOrRelaxedUtilityType
 };
 
 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 { 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;;;;"}
+{"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';\nimport { preferReadonlyOrMutableRecord } from './prefer-readonly-or-mutable-record.mjs';\nimport { preferStrictOrRelaxedUtilityType } from './prefer-strict-or-relaxed-utility-type.mjs';\n\nexport const tsTypeForgeRules = {\n  'prefer-canonical-length-constrained-tuple':\n    preferCanonicalLengthConstrainedTuple,\n  'prefer-readonly-or-mutable-record': preferReadonlyOrMutableRecord,\n  'prefer-strict-or-relaxed-utility-type': preferStrictOrRelaxedUtilityType,\n} as const satisfies ESLintPlugin['rules'];\n"],"names":[],"mappings":";;;;AAKO,MAAM,gBAAA,GAAmB;AAAA,EAC9B,2CAAA,EACE,qCAAA;AAAA,EACF,mCAAA,EAAqC,6BAAA;AAAA,EACrC,uCAAA,EAAyC;AAC3C;;;;"}

package/dist/rules/std-type-rule-utils.d.mts

@@ -0,0 +1,22 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import { type ImportStyle } from './import-style.mjs';
+/**
+ * The ts-type-forge replacements offered for one standard-library type, in the
+ * order they are suggested.
+ */
+export type StdTypeAlternatives = ReadonlyMap<string, readonly string[]>;
+/**
+ * Reports a reference to a banned standard-library type and offers one
+ * suggestion per ts-type-forge alternative.
+ *
+ * Choosing between the alternatives is a semantic decision — `StrictExclude`
+ * additionally checks that the subtrahend is part of the union, `ReadonlyRecord`
+ * and `MutableRecord` describe different types — so this is deliberately *not*
+ * an autofix. Each suggestion carries its own import fix, which is safe because
+ * ESLint applies suggestions one at a time.
+ */
+export declare const reportStdTypeReference: <MessageIds extends string>(context: TSESLint.RuleContext<MessageIds, readonly unknown[]>, node: TSESTree.TSTypeReference, alternatives: StdTypeAlternatives, messageIds: Readonly<{
+    report: MessageIds;
+    suggestion: MessageIds;
+}>, importStyle: ImportStyle) => void;
+//# sourceMappingURL=std-type-rule-utils.d.mts.map

package/dist/rules/std-type-rule-utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"std-type-rule-utils.d.mts","sourceRoot":"","sources":["../../src/rules/std-type-rule-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAKvE;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;AAEzE;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,GAAI,UAAU,SAAS,MAAM,WACrD,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,SAAS,OAAO,EAAE,CAAC,QACvD,QAAQ,CAAC,eAAe,gBAChB,mBAAmB,cACrB,QAAQ,CAAC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC,eACvD,WAAW,KACvB,IA4CF,CAAC"}

package/dist/rules/std-type-rule-utils.mjs

@@ -0,0 +1,40 @@
+import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import { resolveTypeName } from './import-style.mjs';
+import { buildTypeImportFix } from './import-utils.mjs';
+
+const reportStdTypeReference = (context, node, alternatives, messageIds, importStyle) => {
+  const typeName = node.typeName;
+  if (typeName.type !== AST_NODE_TYPES.Identifier) return;
+  const stdName = typeName.name;
+  const candidates = alternatives.get(stdName);
+  if (candidates === void 0) return;
+  if (isLocallyBound(context.sourceCode, node, stdName)) return;
+  const program = context.sourceCode.ast;
+  context.report({
+    node: typeName,
+    messageId: messageIds.report,
+    data: { name: stdName, alternatives: formatAlternatives(candidates) },
+    suggest: candidates.flatMap((candidate) => {
+      const target = resolveTypeName(program, candidate, importStyle);
+      return target === void 0 ? [] : [
+        {
+          messageId: messageIds.suggestion,
+          data: { name: stdName, replacement: target.localName },
+          fix: (fixer) => Arr.toPushed(
+            target.needsImport ? buildTypeImportFix(fixer, program, candidate) : [],
+            fixer.replaceText(typeName, target.localName)
+          )
+        }
+      ];
+    })
+  });
+};
+const formatAlternatives = (candidates) => candidates.map((candidate) => `\`${candidate}\``).join(" or ");
+const isLocallyBound = (sourceCode, node, name) => {
+  const variable = ASTUtils.findVariable(sourceCode.getScope(node), name);
+  return variable !== null && Arr.isNonEmpty(variable.defs);
+};
+
+export { reportStdTypeReference };
+//# sourceMappingURL=std-type-rule-utils.mjs.map

package/dist/rules/std-type-rule-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"std-type-rule-utils.mjs","sources":["../../src/rules/std-type-rule-utils.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  ASTUtils,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { Arr } from 'ts-data-forge';\nimport { resolveTypeName, type ImportStyle } from './import-style.mjs';\nimport { buildTypeImportFix } from './import-utils.mjs';\n\n/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */\n\n/**\n * The ts-type-forge replacements offered for one standard-library type, in the\n * order they are suggested.\n */\nexport type StdTypeAlternatives = ReadonlyMap<string, readonly string[]>;\n\n/**\n * Reports a reference to a banned standard-library type and offers one\n * suggestion per ts-type-forge alternative.\n *\n * Choosing between the alternatives is a semantic decision — `StrictExclude`\n * additionally checks that the subtrahend is part of the union, `ReadonlyRecord`\n * and `MutableRecord` describe different types — so this is deliberately *not*\n * an autofix. Each suggestion carries its own import fix, which is safe because\n * ESLint applies suggestions one at a time.\n */\nexport const reportStdTypeReference = <MessageIds extends string>(\n  context: TSESLint.RuleContext<MessageIds, readonly unknown[]>,\n  node: TSESTree.TSTypeReference,\n  alternatives: StdTypeAlternatives,\n  messageIds: Readonly<{ report: MessageIds; suggestion: MessageIds }>,\n  importStyle: ImportStyle,\n): void => {\n  const typeName = node.typeName;\n\n  // `ns.Pick` / `import('…').Pick` never denote the standard-library type.\n  if (typeName.type !== AST_NODE_TYPES.Identifier) return;\n\n  const stdName = typeName.name;\n\n  const candidates = alternatives.get(stdName);\n\n  if (candidates === undefined) return;\n\n  // A file that declares — or imports — its own `Pick` does not mean the\n  // standard-library one, so there is nothing to steer.\n  if (isLocallyBound(context.sourceCode, node, stdName)) return;\n\n  const program = context.sourceCode.ast;\n\n  context.report({\n    node: typeName,\n    messageId: messageIds.report,\n    data: { name: stdName, alternatives: formatAlternatives(candidates) },\n    suggest: candidates.flatMap((candidate) => {\n      const target = resolveTypeName(program, candidate, importStyle);\n\n      // The replacement name is already bound to something else in this file,\n      // so rewriting to it would resolve to the wrong declaration.\n      return target === undefined\n        ? []\n        : [\n            {\n              messageId: messageIds.suggestion,\n              data: { name: stdName, replacement: target.localName },\n              fix: (fixer: TSESLint.RuleFixer): readonly TSESLint.RuleFix[] =>\n                Arr.toPushed(\n                  target.needsImport\n                    ? buildTypeImportFix(fixer, program, candidate)\n                    : [],\n                  fixer.replaceText(typeName, target.localName),\n                ),\n            },\n          ];\n    }),\n  });\n};\n\n/** `['StrictPick', 'RelaxedPick']` → `` '`StrictPick` or `RelaxedPick`' ``. */\nconst formatAlternatives = (candidates: readonly string[]): string =>\n  candidates.map((candidate) => `\\`${candidate}\\``).join(' or ');\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 */\nconst 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"],"names":[],"mappings":";;;;;AA4BO,MAAM,yBAAyB,CACpC,OAAA,EACA,IAAA,EACA,YAAA,EACA,YACA,WAAA,KACS;AACT,EAAA,MAAM,WAAW,IAAA,CAAK,QAAA;AAGtB,EAAA,IAAI,QAAA,CAAS,IAAA,KAAS,cAAA,CAAe,UAAA,EAAY;AAEjD,EAAA,MAAM,UAAU,QAAA,CAAS,IAAA;AAEzB,EAAA,MAAM,UAAA,GAAa,YAAA,CAAa,GAAA,CAAI,OAAO,CAAA;AAE3C,EAAA,IAAI,eAAe,MAAA,EAAW;AAI9B,EAAA,IAAI,cAAA,CAAe,OAAA,CAAQ,UAAA,EAAY,IAAA,EAAM,OAAO,CAAA,EAAG;AAEvD,EAAA,MAAM,OAAA,GAAU,QAAQ,UAAA,CAAW,GAAA;AAEnC,EAAA,OAAA,CAAQ,MAAA,CAAO;AAAA,IACb,IAAA,EAAM,QAAA;AAAA,IACN,WAAW,UAAA,CAAW,MAAA;AAAA,IACtB,MAAM,EAAE,IAAA,EAAM,SAAS,YAAA,EAAc,kBAAA,CAAmB,UAAU,CAAA,EAAE;AAAA,IACpE,OAAA,EAAS,UAAA,CAAW,OAAA,CAAQ,CAAC,SAAA,KAAc;AACzC,MAAA,MAAM,MAAA,GAAS,eAAA,CAAgB,OAAA,EAAS,SAAA,EAAW,WAAW,CAAA;AAI9D,MAAA,OAAO,MAAA,KAAW,MAAA,GACd,EAAC,GACD;AAAA,QACE;AAAA,UACE,WAAW,UAAA,CAAW,UAAA;AAAA,UACtB,MAAM,EAAE,IAAA,EAAM,OAAA,EAAS,WAAA,EAAa,OAAO,SAAA,EAAU;AAAA,UACrD,GAAA,EAAK,CAAC,KAAA,KACJ,GAAA,CAAI,QAAA;AAAA,YACF,OAAO,WAAA,GACH,kBAAA,CAAmB,OAAO,OAAA,EAAS,SAAS,IAC5C,EAAC;AAAA,YACL,KAAA,CAAM,WAAA,CAAY,QAAA,EAAU,MAAA,CAAO,SAAS;AAAA;AAC9C;AACJ,OACF;AAAA,IACN,CAAC;AAAA,GACF,CAAA;AACH;AAGA,MAAM,kBAAA,GAAqB,CAAC,UAAA,KAC1B,UAAA,CAAW,GAAA,CAAI,CAAC,SAAA,KAAc,CAAA,EAAA,EAAK,SAAS,CAAA,EAAA,CAAI,CAAA,CAAE,IAAA,CAAK,MAAM,CAAA;AAY/D,MAAM,cAAA,GAAiB,CACrB,UAAA,EACA,IAAA,EACA,IAAA,KACY;AACZ,EAAA,MAAM,WAAW,QAAA,CAAS,YAAA,CAAa,WAAW,QAAA,CAAS,IAAI,GAAG,IAAI,CAAA;AAEtE,EAAA,OAAO,QAAA,KAAa,IAAA,IAAQ,GAAA,CAAI,UAAA,CAAW,SAAS,IAAI,CAAA;AAC1D,CAAA;;;;"}

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

@@ -1,22 +1,5 @@
 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;
+import { type ImportStyle } from './import-style.mjs';
 export type TupleRewrite = Readonly<{
     node: TSESTree.Node;
     canonicalName: string;
@@ -33,5 +16,4 @@ export type TupleRewrite = Readonly<{
  * 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

@@ -1 +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"}
+{"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;AAExE,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAKvE,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,IAuCF,CAAC"}

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

@@ -1,29 +1,7 @@
-import { TS_TYPE_FORGE_MODULE } from './constants.mjs';
-import { buildTypeImportFix, getImportedLocalName, getTsTypeForgeImports, hasConflictingDeclaration } from './import-utils.mjs';
+import { Arr } from 'ts-data-forge';
+import { resolveTypeName } from './import-style.mjs';
+import { buildTypeImportFix } 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;
@@ -42,15 +20,15 @@ const reportTupleRewrites = (context, rewrites, messageId, importStyle) => {
       node: rewrite.node,
       messageId,
       data: { original: sourceCode.getText(rewrite.node), replacement },
-      fix: (fixer) => [
-        ...index === 0 ? importNames.flatMap(
+      fix: (fixer) => Arr.toPushed(
+        index === 0 ? importNames.flatMap(
           (name) => buildTypeImportFix(fixer, program, name)
         ) : [],
         fixer.replaceText(rewrite.node, replacement)
-      ]
+      )
     });
   }
 };
 
-export { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY, reportTupleRewrites, resolveTypeName };
+export { reportTupleRewrites };
 //# sourceMappingURL=tuple-rule-utils.mjs.map

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

@@ -1 +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"],"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;;;;"}
+{"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 { Arr } from 'ts-data-forge';\nimport { resolveTypeName, type ImportStyle } from './import-style.mjs';\nimport { buildTypeImportFix } from './import-utils.mjs';\n\n/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */\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        Arr.toPushed(\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"],"names":[],"mappings":";;;;AAuBO,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,KACJ,GAAA,CAAI,QAAA;AAAA,QACF,KAAA,KAAU,IACN,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,KACH,CAAA;AAAA,EACH;AACF;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-ts-type-forge",
-  "version": "0.4.3",
+  "version": "0.6.0",
   "private": false,
   "description": "ESLint rules that steer type declarations toward ts-type-forge idioms.",
   "keywords": [
@@ -35,8 +35,9 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@typescript-eslint/utils": "8.65.0",
-    "ts-type-forge": "9.1.1"
+    "@typescript-eslint/utils": "~8.65.0",
+    "ts-data-forge": "~14.0.0",
+    "ts-type-forge": "9.1.2"
   },
   "devDependencies": {
     "@typescript-eslint/parser": "8.65.0",

package/src/plugin.mts

@@ -9,6 +9,8 @@ import { type ESLintFlatConfig, type ESLintPlugin } from './types.mjs';
  */
 const recommendedRules = {
   'ts-type-forge/prefer-canonical-length-constrained-tuple': 'error',
+  'ts-type-forge/prefer-readonly-or-mutable-record': 'error',
+  'ts-type-forge/prefer-strict-or-relaxed-utility-type': 'error',
 } as const satisfies Readonly<
   Record<`ts-type-forge/${keyof typeof tsTypeForgeRules}`, 'error'>
 >;

package/src/rule-types.mts

@@ -53,7 +53,7 @@ namespace PreferCanonicalLengthConstrainedTuple {
    *           "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 … } from 'ts-type-forge';` when the name is not imported yet."
+   *         "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';` when the name is not imported yet; 'global' assumes the ambient globals of `ts-type-forge/global` and never touches imports."
    *       },
    *       "maxLength": {
    *         "type": "integer",
@@ -76,12 +76,104 @@ namespace PreferCanonicalLengthConstrainedTuple {
     | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>;
 }
 
+/**
+ * @description Replace the built-in `Record` with the ts-type-forge `ReadonlyRecord` or `MutableRecord`, so that the mutability of the record is stated rather than implied.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | false      |
+ *  ```
+ */
+namespace PreferReadonlyOrMutableRecord {
+  /**
+   * ### schema
+   *
+   * ```json
+   * [
+   *   {
+   *     "type": "object",
+   *     "properties": {
+   *       "importStyle": {
+   *         "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';` when the name is not imported yet; 'global' assumes the ambient globals of `ts-type-forge/global` and never touches imports."
+   *       }
+   *     },
+   *     "additionalProperties": false
+   *   }
+   * ]
+   * ```
+   */
+  export type Options = NonNullable<
+    RuleOptionsOf<'prefer-readonly-or-mutable-record'>[0]
+  >;
+
+  export type RuleEntry =
+    | 'off'
+    | Linter.Severity
+    | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>;
+}
+
+/**
+ * @description Replace the built-in `Exclude` / `Extract` / `Omit` / `Pick` with the ts-type-forge `Strict*` or `Relaxed*` counterpart, so that the unchecked second argument becomes an explicit choice.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | false      |
+ *  ```
+ */
+namespace PreferStrictOrRelaxedUtilityType {
+  /**
+   * ### schema
+   *
+   * ```json
+   * [
+   *   {
+   *     "type": "object",
+   *     "properties": {
+   *       "importStyle": {
+   *         "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';` when the name is not imported yet; 'global' assumes the ambient globals of `ts-type-forge/global` and never touches imports."
+   *       }
+   *     },
+   *     "additionalProperties": false
+   *   }
+   * ]
+   * ```
+   */
+  export type Options = NonNullable<
+    RuleOptionsOf<'prefer-strict-or-relaxed-utility-type'>[0]
+  >;
+
+  export type RuleEntry =
+    | 'off'
+    | Linter.Severity
+    | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>;
+}
+
 export type EslintTsTypeForgeRules = Readonly<{
   'ts-type-forge/prefer-canonical-length-constrained-tuple': PreferCanonicalLengthConstrainedTuple.RuleEntry;
+  'ts-type-forge/prefer-readonly-or-mutable-record': PreferReadonlyOrMutableRecord.RuleEntry;
+  'ts-type-forge/prefer-strict-or-relaxed-utility-type': PreferStrictOrRelaxedUtilityType.RuleEntry;
 }>;
 
 export type EslintTsTypeForgeRulesOption = Readonly<{
   'ts-type-forge/prefer-canonical-length-constrained-tuple': PreferCanonicalLengthConstrainedTuple.Options;
+  'ts-type-forge/prefer-readonly-or-mutable-record': PreferReadonlyOrMutableRecord.Options;
+  'ts-type-forge/prefer-strict-or-relaxed-utility-type': PreferStrictOrRelaxedUtilityType.Options;
 }>;
 
 // If this assertion fails to type-check, this generated file has drifted from

package/src/rules/ast-utils.mts

@@ -3,6 +3,7 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
@@ -35,11 +36,15 @@ export type UniformTupleShape = Readonly<{
  *   rewriting them would drop information.
  * - A tuple that is only a rest element (`[...V[]]`) is not a length
  *   constraint at all.
+ * - A tuple inside the `extends` clause of a conditional type is a match
+ *   pattern, not a type (see {@link isInConditionalTypeExtendsClause}).
  */
 export const analyzeUniformTuple = (
   tuple: TSESTree.TSTupleType,
   sourceCode: TSESLint.SourceCode,
 ): UniformTupleShape | undefined => {
+  if (isInConditionalTypeExtendsClause(tuple)) return undefined;
+
   const { parent } = tuple;
 
   const isReadonly =
@@ -52,10 +57,10 @@ export const analyzeUniformTuple = (
 
   const hasRest = last?.type === AST_NODE_TYPES.TSRestType;
 
-  const leading = hasRest ? elements.slice(0, -1) : elements;
+  const leading = hasRest ? Arr.butLast(elements) : elements;
 
   if (
-    leading.length === 0 ||
+    Arr.isEmpty(leading) ||
     leading.some(
       (element) =>
         element.type === AST_NODE_TYPES.TSRestType ||
@@ -82,7 +87,7 @@ export const analyzeUniformTuple = (
   const expected = normalizeWhitespace(elementText);
 
   const others = [
-    ...leading.slice(1),
+    ...Arr.tail(leading),
     ...(restElementType === undefined ? [] : [restElementType]),
   ];
 
@@ -99,6 +104,30 @@ export const analyzeUniformTuple = (
     : undefined;
 };
 
+/**
+ * Whether `node` sits inside the `extends` clause of a conditional type, where
+ * a tuple is a *match pattern* rather than a type.
+ *
+ * `[A, B] extends [true, true]` matches element-wise even while `A` and `B` are
+ * still generic. The canonical spellings resolve through a mapped type
+ * (`MutableFixedLengthTuple<N, V>` is `Mutable<FixedLengthTuple<N, V>>`), and
+ * against one of those the checker defers the whole conditional instead —
+ * yielding `boolean` where the tuple pattern yielded `true` or `false`, which
+ * silently widens everything downstream. So those positions are left alone.
+ */
+const isInConditionalTypeExtendsClause = (node: TSESTree.Node): boolean => {
+  // The root has no parent, so it terminates the walk.
+  if (node.type === AST_NODE_TYPES.Program) return false;
+
+  const { parent } = node;
+
+  return (
+    (parent.type === AST_NODE_TYPES.TSConditionalType &&
+      parent.extendsType === node) ||
+    isInConditionalTypeExtendsClause(parent)
+  );
+};
+
 /** Unwraps `V[]` and `readonly V[]` to `V`. */
 const getArrayElementType = (
   node: TSESTree.TypeNode,

package/src/rules/import-style.mts

@@ -0,0 +1,60 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import { TS_TYPE_FORGE_MODULE } from './constants.mjs';
+import {
+  getImportedLocalName,
+  getTsTypeForgeImports,
+  hasConflictingDeclaration,
+} from './import-utils.mjs';
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+/** `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 const DEFAULT_IMPORT_STYLE: ImportStyle = 'named';
+
+export const IMPORT_STYLE_SCHEMA_PROPERTY: JsonSchema = {
+  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(' '),
+};
+
+/**
+ * Resolves how a ts-type-forge type name should be written in this file, and
+ * whether the fix 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 const resolveTypeName = (
+  program: TSESTree.Program,
+  canonicalName: string,
+  importStyle: ImportStyle,
+): Readonly<{ localName: string; needsImport: boolean }> | undefined => {
+  const importedLocalName = getImportedLocalName(
+    getTsTypeForgeImports(program),
+    canonicalName,
+  );
+
+  if (importedLocalName !== undefined) {
+    return { localName: importedLocalName, needsImport: false };
+  }
+
+  return hasConflictingDeclaration(program, canonicalName)
+    ? undefined
+    : { localName: canonicalName, needsImport: importStyle === 'named' };
+};

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

@@ -12,9 +12,8 @@ import {
 import {
   DEFAULT_IMPORT_STYLE,
   IMPORT_STYLE_SCHEMA_PROPERTY,
-  reportTupleRewrites,
-  type TupleRewrite,
-} from './tuple-rule-utils.mjs';
+} from './import-style.mjs';
+import { reportTupleRewrites, type TupleRewrite } from './tuple-rule-utils.mjs';
 
 type Options = readonly [
   Readonly<{