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

package/README.md

@@ -3,7 +3,9 @@
 ESLint rules that steer TypeScript **type declarations** toward
 [`ts-type-forge`](https://www.npmjs.com/package/ts-type-forge) idioms — replacing
 hand-rolled uniform tuple spellings with the library's named length-constrained
-tuple types. Every rule is auto-fixable, and every rewrite is **type-preserving**.
+tuple types, and the standard library's under-specified `Exclude` / `Extract` /
+`Omit` / `Pick` / `Record` with counterparts that state what was left implicit.
+Every rewrite is **type-preserving**.
 
 ## Installation
 
@@ -70,9 +72,13 @@ export default [
 
 ## Rules
 
-| Rule                                        | Description                                                                              |
-| :------------------------------------------ | :--------------------------------------------------------------------------------------- |
-| `prefer-canonical-length-constrained-tuple` | Replace hand-rolled uniform tuple spellings with the canonical ts-type-forge tuple type. |
+| Rule                                        | Fix        | Description                                                                               |
+| :------------------------------------------ | :--------- | :---------------------------------------------------------------------------------------- |
+| `prefer-canonical-length-constrained-tuple` | autofix    | Replace hand-rolled uniform tuple spellings with the canonical ts-type-forge tuple type.  |
+| `prefer-strict-or-relaxed-utility-type`     | suggestion | Replace `Exclude` / `Extract` / `Omit` / `Pick` with the `Strict*` or `Relaxed*` variant. |
+| `prefer-readonly-or-mutable-record`         | suggestion | Replace `Record` with `ReadonlyRecord` or `MutableRecord`.                                |
+
+### `prefer-canonical-length-constrained-tuple`
 
 It covers the whole uniform-tuple family:
 
@@ -112,7 +118,7 @@ type AtLeastTwo = MutableMinLengthTuple<2, string>;
 Single-element tuples without a rest (`readonly [V]`) are left alone — they read
 better as-is than `FixedLengthTuple<1, V>`.
 
-### The rule deliberately leaves alone
+#### The rule deliberately leaves alone
 
 - heterogeneous tuples (`readonly [string, number]`);
 - labelled members (`readonly [head: V, ...tail: V[]]`), because rewriting them
@@ -121,21 +127,82 @@ better as-is than `FixedLengthTuple<1, V>`.
 - files that already bind the target name to something else (a local alias, or
   an import from another module).
 
+### `prefer-strict-or-relaxed-utility-type`
+
+`Exclude<T, U>`, `Extract<T, U>`, `Omit<T, K>` and `Pick<T, K>` do not constrain
+their second argument, so a member or key that is not part of `T` is silently
+accepted — typically producing an empty result instead of the compile error that
+would have pointed at the leftover of a rename.
+
+ts-type-forge splits each one in two, and this rule makes the choice explicit:
+
+| built-in        | checks the second argument | keeps the built-in behavior |
+| :-------------- | :------------------------- | :-------------------------- |
+| `Exclude<T, U>` | `StrictExclude<T, U>`      | `RelaxedExclude<T, U>`      |
+| `Extract<T, U>` | `StrictExtract<T, U>`      | `RelaxedExtract<T, U>`      |
+| `Omit<T, K>`    | `StrictOmit<T, K>`         | `RelaxedOmit<T, K>`         |
+| `Pick<T, K>`    | `StrictPick<T, K>`         | `RelaxedPick<T, K>`         |
+
+```ts
+// ❌
+type Remaining = Exclude<'a' | 'b' | 'c', 'a'>;
+type PublicInfo = Omit<Person, 'email'>;
+
+// ✅ — the key is checked against the union / `keyof T`
+type Remaining = StrictExclude<'a' | 'b' | 'c', 'a'>;
+type PublicInfo = StrictOmit<Person, 'email'>;
+
+// ✅ — deliberately unchecked (the subtrahend need not be part of `T`)
+type NonStrings = RelaxedExclude<string | number | boolean, string>;
+```
+
+Reach for `Relaxed*` when the second argument genuinely need not be part of the
+first — a key set computed from a still deferred type parameter, or a subtraction
+whose subtrahend is only partly present.
+
+### `prefer-readonly-or-mutable-record`
+
+`Record<K, V>` says nothing about whether the properties may be reassigned, so
+the mutability of every record spelled with it is decided by whoever reads it.
+
+```ts
+// ❌
+type Config = Record<string, string | number>;
+
+// ✅
+type Config = ReadonlyRecord<string, string | number>;
+type Counters = MutableRecord<string, number>;
+```
+
+### Both rules deliberately leave alone
+
+- qualified names (`Utils.Pick<…>`) — they never denote the standard-library
+  type;
+- files that declare or import their own `Pick` / `Record` / …, for the same
+  reason;
+- the choice itself: replacing `Exclude` with `StrictExclude` can turn working
+  code into a compile error, and `Record` maps onto two different types, so
+  these rules report **suggestions** rather than an autofix. Editors offer both
+  replacements; `--fix` changes nothing.
+
 ## Options
 
-| Option        | Type                  | Default    | Description                                               |
-| :------------ | :-------------------- | :--------- | :-------------------------------------------------------- |
-| `importStyle` | `'global' \| 'named'` | `'global'` | How the ts-type-forge type is brought into scope.         |
-| `maxLength`   | `integer`             | `10`       | Longest tuple `prefer-length-constrained-tuple` rewrites. |
+`importStyle` is accepted by every rule; `maxLength` only by
+`prefer-canonical-length-constrained-tuple`.
+
+| Option        | Type                  | Default   | Description                                                         |
+| :------------ | :-------------------- | :-------- | :------------------------------------------------------------------ |
+| `importStyle` | `'global' \| 'named'` | `'named'` | How the ts-type-forge type is brought into scope.                   |
+| `maxLength`   | `integer`             | `10`      | Longest tuple `prefer-canonical-length-constrained-tuple` rewrites. |
 
 - `'global'` — the ambient globals of `ts-type-forge/global` are in use
-  (`/// <reference types="ts-type-forge/global" />`), so the autofix only
-  rewrites the type and never touches imports.
-- `'named'` — the autofix additionally inserts
+  (`/// <reference types="ts-type-forge/global" />`), so the fix only rewrites
+  the type and never touches imports.
+- `'named'` — the fix additionally inserts
   `import { type … } from 'ts-type-forge';` when the name is not imported yet.
 
 Either way, if the file already imports the target type from `ts-type-forge`
-(possibly under an alias), the autofix reuses that binding.
+(possibly under an alias), the fix reuses that binding.
 
 ```ts
 {

package/dist/plugin.d.mts

@@ -8,6 +8,12 @@ export declare const eslintPluginTsTypeForge: {
             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>;
     };
     readonly configs: {
         /** Enables every rule of this plugin at `error`. */
@@ -18,6 +24,8 @@ export declare const eslintPluginTsTypeForge: {
             };
             readonly rules: {
                 readonly 'ts-type-forge/prefer-canonical-length-constrained-tuple': 'error';
+                readonly 'ts-type-forge/prefer-readonly-or-mutable-record': 'error';
+                readonly 'ts-type-forge/prefer-strict-or-relaxed-utility-type': 'error';
             };
         };
     };

package/dist/plugin.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.mts","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AACA,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AA8BvE,eAAO,MAAM,uBAAuB;;iBAEhC,IAAI,EAAE,6BAA6B;;;;;;;;;QAInC,oDAAoD;iBACpD,WAAW;2BAtBP,2BAA2B;;yBAQ3B,eAAe,EAAI,YAAY;;;oFAdsB,OAAO;;;;CA8BnC,CAAC"}
+{"version":3,"file":"plugin.d.mts","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AACA,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAgCvE,eAAO,MAAM,uBAAuB;;iBAEhC,IAAI,EAAE,6BAA6B;;;;;;;;;;;;;;;QAInC,oDAAoD;iBACpD,WAAW;2BAtBP,2BAA2B;;yBAQ3B,eAAe,EAAI,YAAY;;;oFAhBsB,OAAO;4EACf,OAAO;gFACH,OAAO;;;;CA8B/B,CAAC"}

package/dist/plugin.mjs

@@ -1,7 +1,9 @@
 import { tsTypeForgeRules } from './rules/rules.mjs';
 
 const recommendedRules = {
-  "ts-type-forge/prefer-canonical-length-constrained-tuple": "error"
+  "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"
 };
 const recommendedConfig = {
   name: "ts-type-forge/recommended",

package/dist/plugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.mjs","sources":["../src/plugin.mts"],"sourcesContent":["import { tsTypeForgeRules } from './rules/index.mjs';\nimport { type ESLintFlatConfig, type ESLintPlugin } from './types.mjs';\n\n/**\n * Every rule this plugin ships, at `error`.\n *\n * The `satisfies` clause below is keyed off {@link tsTypeForgeRules}, so adding\n * a rule without listing it here fails to type-check.\n */\nconst recommendedRules = {\n  'ts-type-forge/prefer-canonical-length-constrained-tuple': 'error',\n} as const satisfies Readonly<\n  Record<`ts-type-forge/${keyof typeof tsTypeForgeRules}`, 'error'>\n>;\n\nconst recommendedConfig = {\n  name: 'ts-type-forge/recommended',\n  plugins: {\n    // Resolved lazily so that this config registers the *same* object that\n    // `eslintPluginTsTypeForge` refers to. ESLint rejects a plugin name that\n    // maps to two different objects with `Cannot redefine plugin`, which is\n    // what a user combining this preset with their own\n    // `plugins: { 'ts-type-forge': eslintPluginTsTypeForge }` entry would hit\n    // if the preset embedded a separate copy of the plugin.\n    get 'ts-type-forge'(): ESLintPlugin {\n      return eslintPluginTsTypeForge;\n    },\n  },\n  rules: recommendedRules,\n} as const satisfies ESLintFlatConfig;\n\nexport const eslintPluginTsTypeForge = {\n  meta: {\n    name: 'eslint-plugin-ts-type-forge',\n  },\n  rules: tsTypeForgeRules,\n  configs: {\n    /** Enables every rule of this plugin at `error`. */\n    recommended: recommendedConfig,\n  },\n} as const satisfies ESLintPlugin;\n"],"names":[],"mappings":";;AASA,MAAM,gBAAA,GAAmB;AAAA,EACvB,yDAAA,EAA2D;AAC7D,CAAA;AAIA,MAAM,iBAAA,GAAoB;AAAA,EACxB,IAAA,EAAM,2BAAA;AAAA,EACN,OAAA,EAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOP,IAAI,eAAA,GAAgC;AAClC,MAAA,OAAO,uBAAA;AAAA,IACT;AAAA,GACF;AAAA,EACA,KAAA,EAAO;AACT,CAAA;AAEO,MAAM,uBAAA,GAA0B;AAAA,EACrC,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM;AAAA,GACR;AAAA,EACA,KAAA,EAAO,gBAAA;AAAA,EACP,OAAA,EAAS;AAAA;AAAA,IAEP,WAAA,EAAa;AAAA;AAEjB;;;;"}
+{"version":3,"file":"plugin.mjs","sources":["../src/plugin.mts"],"sourcesContent":["import { tsTypeForgeRules } from './rules/index.mjs';\nimport { type ESLintFlatConfig, type ESLintPlugin } from './types.mjs';\n\n/**\n * Every rule this plugin ships, at `error`.\n *\n * The `satisfies` clause below is keyed off {@link tsTypeForgeRules}, so adding\n * a rule without listing it here fails to type-check.\n */\nconst recommendedRules = {\n  'ts-type-forge/prefer-canonical-length-constrained-tuple': 'error',\n  'ts-type-forge/prefer-readonly-or-mutable-record': 'error',\n  'ts-type-forge/prefer-strict-or-relaxed-utility-type': 'error',\n} as const satisfies Readonly<\n  Record<`ts-type-forge/${keyof typeof tsTypeForgeRules}`, 'error'>\n>;\n\nconst recommendedConfig = {\n  name: 'ts-type-forge/recommended',\n  plugins: {\n    // Resolved lazily so that this config registers the *same* object that\n    // `eslintPluginTsTypeForge` refers to. ESLint rejects a plugin name that\n    // maps to two different objects with `Cannot redefine plugin`, which is\n    // what a user combining this preset with their own\n    // `plugins: { 'ts-type-forge': eslintPluginTsTypeForge }` entry would hit\n    // if the preset embedded a separate copy of the plugin.\n    get 'ts-type-forge'(): ESLintPlugin {\n      return eslintPluginTsTypeForge;\n    },\n  },\n  rules: recommendedRules,\n} as const satisfies ESLintFlatConfig;\n\nexport const eslintPluginTsTypeForge = {\n  meta: {\n    name: 'eslint-plugin-ts-type-forge',\n  },\n  rules: tsTypeForgeRules,\n  configs: {\n    /** Enables every rule of this plugin at `error`. */\n    recommended: recommendedConfig,\n  },\n} as const satisfies ESLintPlugin;\n"],"names":[],"mappings":";;AASA,MAAM,gBAAA,GAAmB;AAAA,EACvB,yDAAA,EAA2D,OAAA;AAAA,EAC3D,iDAAA,EAAmD,OAAA;AAAA,EACnD,qDAAA,EAAuD;AACzD,CAAA;AAIA,MAAM,iBAAA,GAAoB;AAAA,EACxB,IAAA,EAAM,2BAAA;AAAA,EACN,OAAA,EAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOP,IAAI,eAAA,GAAgC;AAClC,MAAA,OAAO,uBAAA;AAAA,IACT;AAAA,GACF;AAAA,EACA,KAAA,EAAO;AACT,CAAA;AAEO,MAAM,uBAAA,GAA0B;AAAA,EACrC,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM;AAAA,GACR;AAAA,EACA,KAAA,EAAO,gBAAA;AAAA,EACP,OAAA,EAAS;AAAA;AAAA,IAEP,WAAA,EAAa;AAAA;AAEjB;;;;"}

package/dist/rule-types.d.mts

@@ -51,11 +51,89 @@ declare namespace PreferCanonicalLengthConstrainedTuple {
     type Options = NonNullable<RuleOptionsOf<'prefer-canonical-length-constrained-tuple'>[0]>;
     type RuleEntry = 'off' | Linter.Severity | 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      |
+ *  ```
+ */
+declare 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
+     *   }
+     * ]
+     * ```
+     */
+    type Options = NonNullable<RuleOptionsOf<'prefer-readonly-or-mutable-record'>[0]>;
+    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      |
+ *  ```
+ */
+declare 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
+     *   }
+     * ]
+     * ```
+     */
+    type Options = NonNullable<RuleOptionsOf<'prefer-strict-or-relaxed-utility-type'>[0]>;
+    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;
 }>;
 type AssertTrue<B extends true> = B;
 export type RuleNamesAreInSync = AssertTrue<TypeEq<keyof EslintTsTypeForgeRules, `ts-type-forge/${keyof typeof tsTypeForgeRules}`>>;

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

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

package/dist/rules/import-style.d.mts

@@ -0,0 +1,21 @@
+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 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 declare const resolveTypeName: (program: TSESTree.Program, canonicalName: string, importStyle: ImportStyle) => Readonly<{
+    localName: string;
+    needsImport: boolean;
+}> | undefined;
+export {};
+//# sourceMappingURL=import-style.d.mts.map

package/dist/rules/import-style.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-style.d.mts","sourceRoot":"","sources":["../../src/rules/import-style.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAUxE,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"}

package/dist/rules/import-style.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"import-style.mjs","sources":["../../src/rules/import-style.mts"],"sourcesContent":["import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';\nimport { TS_TYPE_FORGE_MODULE } from './constants.mjs';\nimport {\n  getImportedLocalName,\n  getTsTypeForgeImports,\n  hasConflictingDeclaration,\n} from './import-utils.mjs';\n\n/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */\n\n/** `JSONSchema4`, reached through the public rule-module types. */\ntype JsonSchema = Exclude<\n  TSESLint.RuleModule<string, readonly unknown[]>['meta']['schema'],\n  readonly unknown[]\n>;\n\nexport type ImportStyle = 'global' | 'named';\n\nexport const DEFAULT_IMPORT_STYLE: ImportStyle = 'named';\n\nexport const IMPORT_STYLE_SCHEMA_PROPERTY: JsonSchema = {\n  type: 'string',\n  enum: ['global', 'named'],\n  description: [\n    'How the ts-type-forge type is brought into scope.',\n    \"'named' (default) makes the autofix add the corresponding\",\n    `\\`import { type … } from '${TS_TYPE_FORGE_MODULE}';\\``,\n    \"when the name is not imported yet; 'global' assumes the\",\n    'ambient globals of `ts-type-forge/global` and never touches',\n    'imports.',\n  ].join(' '),\n};\n\n/**\n * Resolves how a ts-type-forge type name should be written in this file, and\n * whether the fix has to add an import for it.\n *\n * Returns `undefined` when the name is already bound to something else (a local\n * alias, or an import from another module) — rewriting to it would then silently\n * resolve to the wrong declaration, which is exactly what happens inside\n * ts-type-forge's own sources.\n */\nexport const resolveTypeName = (\n  program: TSESTree.Program,\n  canonicalName: string,\n  importStyle: ImportStyle,\n): Readonly<{ localName: string; needsImport: boolean }> | undefined => {\n  const importedLocalName = getImportedLocalName(\n    getTsTypeForgeImports(program),\n    canonicalName,\n  );\n\n  if (importedLocalName !== undefined) {\n    return { localName: importedLocalName, needsImport: false };\n  }\n\n  return hasConflictingDeclaration(program, canonicalName)\n    ? undefined\n    : { localName: canonicalName, needsImport: importStyle === 'named' };\n};\n"],"names":[],"mappings":";;;AAkBO,MAAM,oBAAA,GAAoC;AAE1C,MAAM,4BAAA,GAA2C;AAAA,EACtD,IAAA,EAAM,QAAA;AAAA,EACN,IAAA,EAAM,CAAC,QAAA,EAAU,OAAO,CAAA;AAAA,EACxB,WAAA,EAAa;AAAA,IACX,mDAAA;AAAA,IACA,2DAAA;AAAA,IACA,kCAA6B,oBAAoB,CAAA,IAAA,CAAA;AAAA,IACjD,yDAAA;AAAA,IACA,6DAAA;AAAA,IACA;AAAA,GACF,CAAE,KAAK,GAAG;AACZ;AAWO,MAAM,eAAA,GAAkB,CAC7B,OAAA,EACA,aAAA,EACA,WAAA,KACsE;AACtE,EAAA,MAAM,iBAAA,GAAoB,oBAAA;AAAA,IACxB,sBAAsB,OAAO,CAAA;AAAA,IAC7B;AAAA,GACF;AAEA,EAAA,IAAI,sBAAsB,MAAA,EAAW;AACnC,IAAA,OAAO,EAAE,SAAA,EAAW,iBAAA,EAAmB,WAAA,EAAa,KAAA,EAAM;AAAA,EAC5D;AAEA,EAAA,OAAO,yBAAA,CAA0B,OAAA,EAAS,aAAa,CAAA,GACnD,MAAA,GACA,EAAE,SAAA,EAAW,aAAA,EAAe,WAAA,EAAa,WAAA,KAAgB,OAAA,EAAQ;AACvE;;;;"}

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

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

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

@@ -1,6 +1,7 @@
 import { analyzeUniformTuple } from './ast-utils.mjs';
 import { DEFAULT_MAX_TUPLE_LENGTH, NON_EMPTY_TUPLE_TYPE_NAME, MUTABLE_NON_EMPTY_TUPLE_TYPE_NAME, MIN_LENGTH_TUPLE_TYPE_NAME, MUTABLE_MIN_LENGTH_TUPLE_TYPE_NAME, FIXED_LENGTH_TUPLE_TYPE_NAME, MUTABLE_FIXED_LENGTH_TUPLE_TYPE_NAME } from './constants.mjs';
-import { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY, reportTupleRewrites } from './tuple-rule-utils.mjs';
+import { DEFAULT_IMPORT_STYLE, IMPORT_STYLE_SCHEMA_PROPERTY } from './import-style.mjs';
+import { reportTupleRewrites } from './tuple-rule-utils.mjs';
 
 const MIN_FIXED_LENGTH = 2;
 const preferCanonicalLengthConstrainedTuple = {

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

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

package/dist/rules/prefer-readonly-or-mutable-record.d.mts

@@ -0,0 +1,10 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [
+    Readonly<{
+        importStyle?: 'global' | 'named';
+    }>?
+];
+type MessageIds = 'useReadonlyOrMutableRecord' | 'replaceWith';
+export declare const preferReadonlyOrMutableRecord: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-readonly-or-mutable-record.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-readonly-or-mutable-record.d.mts","sourceRoot":"","sources":["../../src/rules/prefer-readonly-or-mutable-record.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAUzD,KAAK,OAAO,GAAG,SAAS;IACtB,QAAQ,CAAC;QACP,WAAW,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;KAClC,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,UAAU,GAAG,4BAA4B,GAAG,aAAa,CAAC;AAW/D,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,UAAU,CAC7D,UAAU,EACV,OAAO,CA4CC,CAAC"}

package/dist/rules/prefer-readonly-or-mutable-record.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([
+  ["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
+        },
+        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

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

@@ -0,0 +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;;;;"}

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

@@ -0,0 +1,10 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [
+    Readonly<{
+        importStyle?: 'global' | 'named';
+    }>?
+];
+type MessageIds = 'useStrictOrRelaxed' | 'replaceWith';
+export declare const preferStrictOrRelaxedUtilityType: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-strict-or-relaxed-utility-type.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-strict-or-relaxed-utility-type.d.mts","sourceRoot":"","sources":["../../src/rules/prefer-strict-or-relaxed-utility-type.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAUzD,KAAK,OAAO,GAAG,SAAS;IACtB,QAAQ,CAAC;QACP,WAAW,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;KAClC,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,UAAU,GAAG,oBAAoB,GAAG,aAAa,CAAC;AAoBvD,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,UAAU,CAChE,UAAU,EACV,OAAO,CAyCC,CAAC"}

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"}