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

package/dist/rules/prefer-canonical-mutable-record.mjs

@@ -1,83 +1,96 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
 import { Arr } from 'ts-data-forge';
 import { isLocallyBound } from './ast-utils.mjs';
-import { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY } from './import-style.mjs';
-import { getTsTypeForgeImports, getImportedLocalName } from './import-utils.mjs';
+import { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY, } from './import-style.mjs';
+import { getImportedLocalName, getTsTypeForgeImports, } from './import-utils.mjs';
 import { reportTypeRewrites } from './rewrite-rule-utils.mjs';
 
+
+
+
+
 const WRAPPED_RECORD_NAMES = [
-  "Record",
-  "ReadonlyRecord",
-  "MutableRecord"
+    'Record',
+    'ReadonlyRecord',
+    'MutableRecord',
 ];
-const MUTABLE_TYPE_NAME = "Mutable";
-const MUTABLE_RECORD_TYPE_NAME = "MutableRecord";
-const preferCanonicalMutableRecord = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Replace `Mutable<Record<K, V>>` (and `Mutable` applied to `ReadonlyRecord` / `MutableRecord`) with the canonical ts-type-forge `MutableRecord<K, V>`."
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          importStyle: IMPORT_STYLE_SCHEMA_PROPERTY
+const MUTABLE_TYPE_NAME = 'Mutable';
+const MUTABLE_RECORD_TYPE_NAME = 'MutableRecord';
+export const preferCanonicalMutableRecord = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Replace `Mutable<Record<K, V>>` (and `Mutable` applied to `ReadonlyRecord` / `MutableRecord`) with the canonical ts-type-forge `MutableRecord<K, V>`.',
         },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      useMutableRecord: "Replace `{{original}}` with `{{replacement}}` from ts-type-forge."
-    }
-  },
-  create: (context) => {
-    const importStyle = context.options[0]?.importStyle ?? DEFAULT_IMPORT_STYLE;
-    const sourceCode = context.sourceCode;
-    const tsTypeForgeImports = getTsTypeForgeImports(sourceCode.ast);
-    const referencesTsTypeForgeType = (node, canonicalName) => {
-      const typeName = node.typeName;
-      if (typeName.type !== AST_NODE_TYPES.Identifier) return false;
-      return typeName.name === getImportedLocalName(tsTypeForgeImports, canonicalName) || typeName.name === canonicalName && !isLocallyBound(sourceCode, node, canonicalName);
-    };
-    const mut_rewrites = [];
-    return {
-      TSTypeReference: (node) => {
-        if (!referencesTsTypeForgeType(node, MUTABLE_TYPE_NAME)) return;
-        const wrapped = node.typeArguments?.params;
-        if (wrapped === void 0 || !Arr.isFixedLengthArray(1, wrapped)) {
-          return;
-        }
-        const record = wrapped[0];
-        if (record.type !== AST_NODE_TYPES.TSTypeReference || WRAPPED_RECORD_NAMES.every(
-          (name) => !referencesTsTypeForgeType(record, name)
-        )) {
-          return;
-        }
-        const recordTypeArgs = record.typeArguments?.params;
-        if (recordTypeArgs === void 0 || !Arr.isFixedLengthArray(2, recordTypeArgs)) {
-          return;
-        }
-        const [K, V] = recordTypeArgs;
-        mut_rewrites.push({
-          node,
-          canonicalName: MUTABLE_RECORD_TYPE_NAME,
-          typeArgs: `${sourceCode.getText(K)}, ${sourceCode.getText(V)}`
-        });
-      },
-      "Program:exit": () => {
-        reportTypeRewrites(
-          context,
-          mut_rewrites,
-          "useMutableRecord",
-          importStyle
-        );
-      }
-    };
-  },
-  defaultOptions: [{ importStyle: DEFAULT_IMPORT_STYLE }]
-};
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    importStyle: IMPORT_STYLE_SCHEMA_PROPERTY,
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            useMutableRecord: 'Replace `{{original}}` with `{{replacement}}` from ts-type-forge.',
+        },
+    },
+    create: (context) => {
+        const importStyle = context.options[0]?.importStyle ?? DEFAULT_IMPORT_STYLE;
+        const sourceCode = context.sourceCode;
+        const tsTypeForgeImports = getTsTypeForgeImports(sourceCode.ast);
+
+
 
-export { preferCanonicalMutableRecord };
-//# sourceMappingURL=prefer-canonical-mutable-record.mjs.map
+
+
+
+
+
+        const referencesTsTypeForgeType = (
+
+        node, canonicalName) => {
+            const typeName = node.typeName;
+
+            if (typeName.type !== AST_NODE_TYPES.Identifier)
+                return false;
+            return (typeName.name ===
+                getImportedLocalName(tsTypeForgeImports, canonicalName) ||
+                (typeName.name === canonicalName &&
+                    !isLocallyBound(sourceCode, node, canonicalName)));
+        };
+        const mut_rewrites = [];
+        return {
+            TSTypeReference: (node) => {
+                if (!referencesTsTypeForgeType(node, MUTABLE_TYPE_NAME))
+                    return;
+                const wrapped = node.typeArguments?.params;
+                if (wrapped === undefined || !Arr.isFixedLengthArray(1, wrapped)) {
+                    return;
+                }
+                const record = wrapped[0];
+                if (record.type !== AST_NODE_TYPES.TSTypeReference ||
+                    WRAPPED_RECORD_NAMES.every((name) => !referencesTsTypeForgeType(record, name))) {
+                    return;
+                }
+                const recordTypeArgs = record.typeArguments?.params;
+                if (recordTypeArgs === undefined ||
+                    !Arr.isFixedLengthArray(2, recordTypeArgs)) {
+                    return;
+                }
+                const [K, V] = recordTypeArgs;
+                mut_rewrites.push({
+                    node,
+                    canonicalName: MUTABLE_RECORD_TYPE_NAME,
+                    typeArgs: `${sourceCode.getText(K)}, ${sourceCode.getText(V)}`,
+                });
+            },
+            'Program:exit': () => {
+                reportTypeRewrites(context, mut_rewrites, 'useMutableRecord', importStyle);
+            },
+        };
+    },
+    defaultOptions: [{ importStyle: DEFAULT_IMPORT_STYLE }],
+};
+//# sourceMappingURL=prefer-canonical-mutable-record.mjs.map

package/dist/rules/prefer-canonical-mutable-record.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-canonical-mutable-record.mjs","sources":["../../src/rules/prefer-canonical-mutable-record.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { Arr } from 'ts-data-forge';\nimport { isLocallyBound } from './ast-utils.mjs';\nimport {\n  DEFAULT_IMPORT_STYLE,\n  IMPORT_STYLE_SCHEMA_PROPERTY,\n} from './import-style.mjs';\nimport {\n  getImportedLocalName,\n  getTsTypeForgeImports,\n} from './import-utils.mjs';\nimport { reportTypeRewrites, type TypeRewrite } from './rewrite-rule-utils.mjs';\n\ntype Options = readonly [\n  Readonly<{\n    importStyle?: 'global' | 'named';\n  }>?,\n];\n\ntype MessageIds = 'useMutableRecord';\n\n/**\n * The record spellings that `Mutable<…>` collapses to `MutableRecord<K, V>`.\n * `Mutable` strips the `readonly` modifier from every property, so applied to\n * any of these it produces exactly the type `MutableRecord` spells directly.\n */\nconst WRAPPED_RECORD_NAMES = [\n  'Record',\n  'ReadonlyRecord',\n  'MutableRecord',\n] as const;\n\nconst MUTABLE_TYPE_NAME = 'Mutable';\n\nconst MUTABLE_RECORD_TYPE_NAME = 'MutableRecord';\n\nexport const preferCanonicalMutableRecord: TSESLint.RuleModule<\n  MessageIds,\n  Options\n> = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Replace `Mutable<Record<K, V>>` (and `Mutable` applied to `ReadonlyRecord` / `MutableRecord`) with the canonical ts-type-forge `MutableRecord<K, V>`.',\n    },\n    fixable: 'code',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          importStyle: IMPORT_STYLE_SCHEMA_PROPERTY,\n        },\n        additionalProperties: false,\n      },\n    ],\n    messages: {\n      useMutableRecord:\n        'Replace `{{original}}` with `{{replacement}}` from ts-type-forge.',\n    },\n  },\n\n  create: (context) => {\n    const importStyle = context.options[0]?.importStyle ?? DEFAULT_IMPORT_STYLE;\n\n    const sourceCode = context.sourceCode;\n\n    const tsTypeForgeImports = getTsTypeForgeImports(sourceCode.ast);\n\n    /**\n     * Whether this reference denotes the ts-type-forge type `canonicalName` —\n     * either through an import from ts-type-forge (aliases included) or as the\n     * bare ambient global. A name bound to anything else in this file (a local\n     * alias, an import from another module) denotes that declaration instead.\n     * The built-in `Record` goes through the same check: ts-type-forge exports\n     * no `Record`, so only the unbound global spelling matches.\n     */\n    const referencesTsTypeForgeType = (\n      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n      node: TSESTree.TSTypeReference,\n      canonicalName: string,\n    ): boolean => {\n      const typeName = node.typeName;\n\n      // `ns.Mutable` / `import('…').Mutable` never denote the ts-type-forge type.\n      if (typeName.type !== AST_NODE_TYPES.Identifier) return false;\n\n      return (\n        typeName.name ===\n          getImportedLocalName(tsTypeForgeImports, canonicalName) ||\n        (typeName.name === canonicalName &&\n          !isLocallyBound(sourceCode, node, canonicalName))\n      );\n    };\n\n    const mut_rewrites: TypeRewrite[] = [];\n\n    return {\n      TSTypeReference: (node) => {\n        if (!referencesTsTypeForgeType(node, MUTABLE_TYPE_NAME)) return;\n\n        const wrapped = node.typeArguments?.params;\n\n        if (wrapped === undefined || !Arr.isFixedLengthArray(1, wrapped)) {\n          return;\n        }\n\n        const record = wrapped[0];\n\n        if (\n          record.type !== AST_NODE_TYPES.TSTypeReference ||\n          WRAPPED_RECORD_NAMES.every(\n            (name) => !referencesTsTypeForgeType(record, name),\n          )\n        ) {\n          return;\n        }\n\n        const recordTypeArgs = record.typeArguments?.params;\n\n        if (\n          recordTypeArgs === undefined ||\n          !Arr.isFixedLengthArray(2, recordTypeArgs)\n        ) {\n          return;\n        }\n\n        const [K, V] = recordTypeArgs;\n\n        mut_rewrites.push({\n          node,\n          canonicalName: MUTABLE_RECORD_TYPE_NAME,\n          typeArgs: `${sourceCode.getText(K)}, ${sourceCode.getText(V)}`,\n        });\n      },\n      'Program:exit': () => {\n        reportTypeRewrites(\n          context,\n          mut_rewrites,\n          'useMutableRecord',\n          importStyle,\n        );\n      },\n    };\n  },\n  defaultOptions: [{ importStyle: DEFAULT_IMPORT_STYLE }],\n} as const;\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"prefer-canonical-mutable-record.mjs","sourceRoot":"","sources":["../../src/rules/prefer-canonical-mutable-record.mts"],"names":[],"mappings":"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"}

package/dist/rules/prefer-readonly-or-mutable-record.mjs

@@ -1,49 +1,45 @@
-import { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY } from './import-style.mjs';
-import { reportStdTypeReference } from './std-type-rule-utils.mjs';
+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([
-  ["Record", ["ReadonlyRecord", "MutableRecord"]]
+
+
+
+
+const ALTERNATIVES = new Map([
+    ['Record', ['ReadonlyRecord', 'MutableRecord']],
 ]);
-const preferReadonlyOrMutableRecord = {
-  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
+export const preferReadonlyOrMutableRecord = {
+    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.',
         },
-        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 }]
+        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 }],
 };
-
-export { preferReadonlyOrMutableRecord };
-//# sourceMappingURL=prefer-readonly-or-mutable-record.mjs.map
+//# sourceMappingURL=prefer-readonly-or-mutable-record.mjs.map

package/dist/rules/prefer-readonly-or-mutable-record.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-readonly-or-mutable-record.mjs","sources":["../../src/rules/prefer-readonly-or-mutable-record.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 = 'useReadonlyOrMutableRecord' | 'replaceWith';\n\n/**\n * `Record` says nothing about whether the properties may be reassigned, so the\n * mutability of every record type spelled with it is decided by whoever reads\n * it. The ts-type-forge pair spells it out.\n */\nconst ALTERNATIVES: StdTypeAlternatives = new Map([\n  ['Record', ['ReadonlyRecord', 'MutableRecord']],\n]);\n\nexport const preferReadonlyOrMutableRecord: TSESLint.RuleModule<\n  MessageIds,\n  Options\n> = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        '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.',\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      useReadonlyOrMutableRecord:\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          {\n            report: 'useReadonlyOrMutableRecord',\n            suggestion: 'replaceWith',\n          },\n          importStyle,\n        );\n      },\n    };\n  },\n  defaultOptions: [{ importStyle: DEFAULT_IMPORT_STYLE }],\n} as const;\n"],"names":[],"mappings":";;;AAuBA,MAAM,YAAA,uBAAwC,GAAA,CAAI;AAAA,EAChD,CAAC,QAAA,EAAU,CAAC,gBAAA,EAAkB,eAAe,CAAC;AAChD,CAAC,CAAA;AAEM,MAAM,6BAAA,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,0BAAA,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;AAAA,YACE,MAAA,EAAQ,4BAAA;AAAA,YACR,UAAA,EAAY;AAAA,WACd;AAAA,UACA;AAAA,SACF;AAAA,MACF;AAAA,KACF;AAAA,EACF,CAAA;AAAA,EACA,cAAA,EAAgB,CAAC,EAAE,WAAA,EAAa,sBAAsB;AACxD;;;;"}
+{"version":3,"file":"prefer-readonly-or-mutable-record.mjs","sourceRoot":"","sources":["../../src/rules/prefer-readonly-or-mutable-record.mts"],"names":[],"mappings":"AACA,OAAO,EACL,oBAAoB,EACpB,4BAA4B,GAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,sBAAsB,GAEvB,MAAM,2BAA2B,CAAC;AAUnC;;;;GAIG;AACH,MAAM,YAAY,GAAwB,IAAI,GAAG,CAAC;IAChD,CAAC,QAAQ,EAAE,CAAC,gBAAgB,EAAE,eAAe,CAAC,CAAC;CAChD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,6BAA6B,GAGtC;IACF,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EACT,+JAA+J;SAClK;QACD,cAAc,EAAE,IAAI;QACpB,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,WAAW,EAAE,4BAA4B;iBAC1C;gBACD,oBAAoB,EAAE,KAAK;aAC5B;SACF;QACD,QAAQ,EAAE;YACR,0BAA0B,EACxB,6EAA6E;YAC/E,WAAW,EAAE,4CAA4C;SAC1D;KACF;IAED,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE;QAClB,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,WAAW,IAAI,oBAAoB,CAAC;QAE5E,OAAO;YACL,eAAe,EAAE,CAAC,IAAI,EAAE,EAAE;gBACxB,sBAAsB,CACpB,OAAO,EACP,IAAI,EACJ,YAAY,EACZ;oBACE,MAAM,EAAE,4BAA4B;oBACpC,UAAU,EAAE,aAAa;iBAC1B,EACD,WAAW,CACZ,CAAC;YACJ,CAAC;SACF,CAAC;IACJ,CAAC;IACD,cAAc,EAAE,CAAC,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC;CAC/C,CAAC"}

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

@@ -1,49 +1,51 @@
-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"]]
+import { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY, } from './import-style.mjs';
+import { reportStdTypeReference, } from './std-type-rule-utils.mjs';
+
+
+
+
+
+
+
+
+
+
+
+const ALTERNATIVES = 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
+export 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.',
         },
-        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 }]
+        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
+//# sourceMappingURL=prefer-strict-or-relaxed-utility-type.mjs.map

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

@@ -1 +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;;;;"}
+{"version":3,"file":"prefer-strict-or-relaxed-utility-type.mjs","sourceRoot":"","sources":["../../src/rules/prefer-strict-or-relaxed-utility-type.mts"],"names":[],"mappings":"AACA,OAAO,EACL,oBAAoB,EACpB,4BAA4B,GAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,sBAAsB,GAEvB,MAAM,2BAA2B,CAAC;AAUnC;;;;;;;;;;GAUG;AACH,MAAM,YAAY,GAAwB,IAAI,GAAG,CAAC;IAChD,CAAC,SAAS,EAAE,CAAC,eAAe,EAAE,gBAAgB,CAAC,CAAC;IAChD,CAAC,SAAS,EAAE,CAAC,eAAe,EAAE,gBAAgB,CAAC,CAAC;IAChD,CAAC,MAAM,EAAE,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;IACvC,CAAC,MAAM,EAAE,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;CACxC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,gCAAgC,GAGzC;IACF,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EACT,4LAA4L;SAC/L;QACD,cAAc,EAAE,IAAI;QACpB,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,WAAW,EAAE,4BAA4B;iBAC1C;gBACD,oBAAoB,EAAE,KAAK;aAC5B;SACF;QACD,QAAQ,EAAE;YACR,kBAAkB,EAChB,6EAA6E;YAC/E,WAAW,EAAE,4CAA4C;SAC1D;KACF;IAED,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE;QAClB,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,WAAW,IAAI,oBAAoB,CAAC;QAE5E,OAAO;YACL,eAAe,EAAE,CAAC,IAAI,EAAE,EAAE;gBACxB,sBAAsB,CACpB,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,EAAE,MAAM,EAAE,oBAAoB,EAAE,UAAU,EAAE,aAAa,EAAE,EAC3D,WAAW,CACZ,CAAC;YACJ,CAAC;SACF,CAAC;IACJ,CAAC;IACD,cAAc,EAAE,CAAC,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC;CAC/C,CAAC"}

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

@@ -2,33 +2,36 @@ import { Arr } from 'ts-data-forge';
 import { resolveTypeName } from './import-style.mjs';
 import { buildTypeImportFix } from './import-utils.mjs';
 
-const reportTypeRewrites = (context, rewrites, messageId, importStyle) => {
-  const sourceCode = context.sourceCode;
-  const program = sourceCode.ast;
-  const resolved = rewrites.flatMap((rewrite) => {
-    const target = resolveTypeName(program, rewrite.canonicalName, importStyle);
-    return target === void 0 ? [] : [{ rewrite, target }];
-  });
-  const importNames = Array.from(
-    new Set(
-      resolved.filter(({ target }) => target.needsImport).map(({ rewrite }) => rewrite.canonicalName)
-    )
-  );
-  for (const [index, { rewrite, target }] of resolved.entries()) {
-    const replacement = `${target.localName}<${rewrite.typeArgs}>`;
-    context.report({
-      node: rewrite.node,
-      messageId,
-      data: { original: sourceCode.getText(rewrite.node), replacement },
-      fix: (fixer) => Arr.toPushed(
-        index === 0 ? importNames.flatMap(
-          (name) => buildTypeImportFix(fixer, program, name)
-        ) : [],
-        fixer.replaceText(rewrite.node, replacement)
-      )
+
+
+
+
+
+
+
+
+export const reportTypeRewrites = (context, rewrites, messageId, importStyle) => {
+    const sourceCode = context.sourceCode;
+    const program = sourceCode.ast;
+    const resolved = rewrites.flatMap((rewrite) => {
+        const target = resolveTypeName(program, rewrite.canonicalName, importStyle);
+
+
+        return target === undefined ? [] : [{ rewrite, target }];
     });
-  }
+    const importNames = Array.from(new Set(resolved
+        .filter(({ target }) => target.needsImport)
+        .map(({ rewrite }) => rewrite.canonicalName)));
+    for (const [index, { rewrite, target }] of resolved.entries()) {
+        const replacement = `${target.localName}<${rewrite.typeArgs}>`;
+        context.report({
+            node: rewrite.node,
+            messageId,
+            data: { original: sourceCode.getText(rewrite.node), replacement },
+            fix: (fixer) => Arr.toPushed(index === 0
+                ? importNames.flatMap((name) => buildTypeImportFix(fixer, program, name))
+                : [], fixer.replaceText(rewrite.node, replacement)),
+        });
+    }
 };
-
-export { reportTypeRewrites };
-//# sourceMappingURL=rewrite-rule-utils.mjs.map
+//# sourceMappingURL=rewrite-rule-utils.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"rewrite-rule-utils.mjs","sources":["../../src/rules/rewrite-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\n/** One deterministic replacement of a type node by a named ts-type-forge type. */\nexport type TypeRewrite = 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 reportTypeRewrites = <MessageIds extends string>(\n  context: TSESLint.RuleContext<MessageIds, readonly unknown[]>,\n  rewrites: readonly TypeRewrite[],\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":";;;;AAwBO,MAAM,kBAAA,GAAqB,CAChC,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":"rewrite-rule-utils.mjs","sourceRoot":"","sources":["../../src/rules/rewrite-rule-utils.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,EAAE,eAAe,EAAoB,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAYxD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,OAA6D,EAC7D,QAAgC,EAChC,SAAqB,EACrB,WAAwB,EAClB,EAAE;IACR,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAEtC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC;IAE/B,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC5C,MAAM,MAAM,GAAG,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;QAE5E,2EAA2E;QAC3E,0CAA0C;QAC1C,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;IAEH,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAC5B,IAAI,GAAG,CACL,QAAQ;SACL,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC;SAC1C,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,CAC/C,CACF,CAAC;IAEF,KAAK,MAAM,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,IAAI,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC;QAC9D,MAAM,WAAW,GAAG,GAAG,MAAM,CAAC,SAAS,IAAI,OAAO,CAAC,QAAQ,GAAG,CAAC;QAE/D,OAAO,CAAC,MAAM,CAAC;YACb,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,SAAS;YACT,IAAI,EAAE,EAAE,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE;YACjE,GAAG,EAAE,CAAC,KAAK,EAAE,EAAE,CACb,GAAG,CAAC,QAAQ,CACV,KAAK,KAAK,CAAC;gBACT,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAC3B,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,CACzC;gBACH,CAAC,CAAC,EAAE,EACN,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,EAAE,WAAW,CAAC,CAC7C;SACJ,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC"}

package/dist/rules/rules.d.mts

@@ -1,4 +1,5 @@
 export declare const tsTypeForgeRules: {
+    readonly 'no-side-effect-import': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeSideEffectImport", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-canonical-length-constrained-tuple': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useCanonicalTuple", readonly [(Readonly<{
         importStyle?: 'global' | 'named';
         maxLength?: number;

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

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

package/dist/rules/rules.mjs

@@ -1,14 +1,13 @@
+import { noSideEffectImport } from './no-side-effect-import.mjs';
 import { preferCanonicalLengthConstrainedTuple } from './prefer-canonical-length-constrained-tuple.mjs';
 import { preferCanonicalMutableRecord } from './prefer-canonical-mutable-record.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-mutable-record": preferCanonicalMutableRecord,
-  "prefer-readonly-or-mutable-record": preferReadonlyOrMutableRecord,
-  "prefer-strict-or-relaxed-utility-type": preferStrictOrRelaxedUtilityType
+export const tsTypeForgeRules = {
+    'no-side-effect-import': noSideEffectImport,
+    'prefer-canonical-length-constrained-tuple': preferCanonicalLengthConstrainedTuple,
+    'prefer-canonical-mutable-record': preferCanonicalMutableRecord,
+    'prefer-readonly-or-mutable-record': preferReadonlyOrMutableRecord,
+    'prefer-strict-or-relaxed-utility-type': preferStrictOrRelaxedUtilityType,
 };
-
-export { tsTypeForgeRules };
-//# sourceMappingURL=rules.mjs.map
+//# sourceMappingURL=rules.mjs.map

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';\nimport { preferCanonicalMutableRecord } from './prefer-canonical-mutable-record.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-canonical-mutable-record': preferCanonicalMutableRecord,\n  'prefer-readonly-or-mutable-record': preferReadonlyOrMutableRecord,\n  'prefer-strict-or-relaxed-utility-type': preferStrictOrRelaxedUtilityType,\n} as const satisfies ESLintPlugin['rules'];\n"],"names":[],"mappings":";;;;;AAMO,MAAM,gBAAA,GAAmB;AAAA,EAC9B,2CAAA,EACE,qCAAA;AAAA,EACF,iCAAA,EAAmC,4BAAA;AAAA,EACnC,mCAAA,EAAqC,6BAAA;AAAA,EACrC,uCAAA,EAAyC;AAC3C;;;;"}
+{"version":3,"file":"rules.mjs","sourceRoot":"","sources":["../../src/rules/rules.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,qCAAqC,EAAE,MAAM,iDAAiD,CAAC;AACxG,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AACxF,OAAO,EAAE,gCAAgC,EAAE,MAAM,6CAA6C,CAAC;AAE/F,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,uBAAuB,EAAE,kBAAkB;IAC3C,2CAA2C,EACzC,qCAAqC;IACvC,iCAAiC,EAAE,4BAA4B;IAC/D,mCAAmC,EAAE,6BAA6B;IAClE,uCAAuC,EAAE,gCAAgC;CACjC,CAAC"}