eslint-plugin-ts-type-forge 0.5.0 → 0.6.1

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;AAYxE,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,WAAqB,CAAC;AAEzD,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,IAuCF,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,30 +1,7 @@
 import { Arr } from 'ts-data-forge';
-import { TS_TYPE_FORGE_MODULE } from './constants.mjs';
-import { buildTypeImportFix, getImportedLocalName, getTsTypeForgeImports, hasConflictingDeclaration } from './import-utils.mjs';
+import { resolveTypeName } from './import-style.mjs';
+import { buildTypeImportFix } 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" };
-};
 const reportTupleRewrites = (context, rewrites, messageId, importStyle) => {
   const sourceCode = context.sourceCode;
   const program = sourceCode.ast;
@@ -53,5 +30,5 @@ const reportTupleRewrites = (context, rewrites, messageId, importStyle) => {
   }
 };
 
-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 { Arr } from 'ts-data-forge';\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 = '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 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        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":";;;;AAoBO,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;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,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;;;;"}
+{"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.5.0",
+  "version": "0.6.1",
   "private": false,
   "description": "ESLint rules that steer type declarations toward ts-type-forge idioms.",
   "keywords": [
@@ -37,7 +37,7 @@
   "dependencies": {
     "@typescript-eslint/utils": "~8.65.0",
     "ts-data-forge": "~14.0.0",
-    "ts-type-forge": "9.1.1"
+    "ts-type-forge": "9.1.3"
   },
   "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

@@ -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/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<{

package/src/rules/prefer-readonly-or-mutable-record.mts

@@ -0,0 +1,74 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+import {
+  DEFAULT_IMPORT_STYLE,
+  IMPORT_STYLE_SCHEMA_PROPERTY,
+} from './import-style.mjs';
+import {
+  reportStdTypeReference,
+  type StdTypeAlternatives,
+} from './std-type-rule-utils.mjs';
+
+type Options = readonly [
+  Readonly<{
+    importStyle?: 'global' | 'named';
+  }>?,
+];
+
+type MessageIds = 'useReadonlyOrMutableRecord' | 'replaceWith';
+
+/**
+ * `Record` says nothing about whether the properties may be reassigned, so the
+ * mutability of every record type spelled with it is decided by whoever reads
+ * it. The ts-type-forge pair spells it out.
+ */
+const ALTERNATIVES: StdTypeAlternatives = new Map([
+  ['Record', ['ReadonlyRecord', 'MutableRecord']],
+]);
+
+export const preferReadonlyOrMutableRecord: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      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.',
+    },
+    hasSuggestions: true,
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          importStyle: IMPORT_STYLE_SCHEMA_PROPERTY,
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      useReadonlyOrMutableRecord:
+        '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: 'useReadonlyOrMutableRecord',
+            suggestion: 'replaceWith',
+          },
+          importStyle,
+        );
+      },
+    };
+  },
+  defaultOptions: [{ importStyle: DEFAULT_IMPORT_STYLE }],
+} as const;

package/src/rules/prefer-readonly-or-mutable-record.test.mts

@@ -0,0 +1,160 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferReadonlyOrMutableRecord } from './prefer-readonly-or-mutable-record.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+  },
+});
+
+describe('prefer-readonly-or-mutable-record', () => {
+  tester.run(
+    'prefer-readonly-or-mutable-record',
+    preferReadonlyOrMutableRecord,
+    {
+      valid: [
+        {
+          name: 'accepts the ts-type-forge counterparts',
+          code: dedent`
+            type A = ReadonlyRecord<string, number>;
+            type B = MutableRecord<'a' | 'b', number>;
+          `,
+        },
+        {
+          name: 'ignores unrelated standard-library types',
+          code: 'type A = Readonly<Partial<{ a: 1 }>>;',
+        },
+        {
+          name: 'ignores a qualified name that merely ends in `Record`',
+          code: 'type A = Lib.Record<string, number>;',
+        },
+        {
+          name: 'ignores a locally declared type of the same name',
+          code: dedent`
+            type Record<K extends PropertyKey, V> = { readonly [P in K]: V };
+            type A = Record<string, number>;
+          `,
+        },
+        {
+          name: 'ignores a name imported from another module',
+          code: dedent`
+            import { type Record } from './my-types.mjs';
+            type A = Record<string, number>;
+          `,
+        },
+      ],
+      invalid: [
+        {
+          name: 'reports `Record` and suggests both counterparts',
+          code: 'type A = Record<string, number>;',
+          errors: [
+            {
+              messageId: 'useReadonlyOrMutableRecord',
+              data: {
+                name: 'Record',
+                alternatives: '`ReadonlyRecord` or `MutableRecord`',
+              },
+              suggestions: [
+                {
+                  messageId: 'replaceWith',
+                  data: { name: 'Record', replacement: 'ReadonlyRecord' },
+                  output: dedent`
+                    import { type ReadonlyRecord } from 'ts-type-forge';
+                    type A = ReadonlyRecord<string, number>;
+                  `,
+                },
+                {
+                  messageId: 'replaceWith',
+                  data: { name: 'Record', replacement: 'MutableRecord' },
+                  output: dedent`
+                    import { type MutableRecord } from 'ts-type-forge';
+                    type A = MutableRecord<string, number>;
+                  `,
+                },
+              ],
+            },
+          ],
+        },
+        {
+          name: 'touches no import under the `global` import style',
+          options: [{ importStyle: 'global' }],
+          code: 'type A = Record<string, number>;',
+          errors: [
+            {
+              messageId: 'useReadonlyOrMutableRecord',
+              suggestions: [
+                {
+                  messageId: 'replaceWith',
+                  output: 'type A = ReadonlyRecord<string, number>;',
+                },
+                {
+                  messageId: 'replaceWith',
+                  output: 'type A = MutableRecord<string, number>;',
+                },
+              ],
+            },
+          ],
+        },
+        {
+          name: 'reuses an existing ts-type-forge import, alias included',
+          code: dedent`
+            import { type ReadonlyRecord as RRecord } from 'ts-type-forge';
+            type A = Record<string, number>;
+          `,
+          errors: [
+            {
+              messageId: 'useReadonlyOrMutableRecord',
+              suggestions: [
+                {
+                  messageId: 'replaceWith',
+                  data: { name: 'Record', replacement: 'RRecord' },
+                  output: dedent`
+                    import { type ReadonlyRecord as RRecord } from 'ts-type-forge';
+                    type A = RRecord<string, number>;
+                  `,
+                },
+                {
+                  messageId: 'replaceWith',
+                  data: { name: 'Record', replacement: 'MutableRecord' },
+                  output: dedent`
+                    import { type MutableRecord } from 'ts-type-forge';
+                    import { type ReadonlyRecord as RRecord } from 'ts-type-forge';
+                    type A = MutableRecord<string, number>;
+                  `,
+                },
+              ],
+            },
+          ],
+        },
+        {
+          name: 'reports `Record` in a type-parameter constraint too',
+          code: 'type A<T extends Record<string, unknown>> = keyof T;',
+          errors: [
+            {
+              messageId: 'useReadonlyOrMutableRecord',
+              suggestions: [
+                {
+                  messageId: 'replaceWith',
+                  output: dedent`
+                    import { type ReadonlyRecord } from 'ts-type-forge';
+                    type A<T extends ReadonlyRecord<string, unknown>> = keyof T;
+                  `,
+                },
+                {
+                  messageId: 'replaceWith',
+                  output: dedent`
+                    import { type MutableRecord } from 'ts-type-forge';
+                    type A<T extends MutableRecord<string, unknown>> = keyof T;
+                  `,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  );
+});