eslint-plugin-ts-fortress 0.2.0 → 0.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 ESLint rules that steer schema definitions toward
 [`ts-fortress`](https://www.npmjs.com/package/ts-fortress) idioms. Every rule is
-auto-fixable.
+auto-fixable, and every rewrite is **type-preserving**.
 
 ## Installation
 
@@ -15,6 +15,39 @@ configured TypeScript project is not required.
 
 ## Usage (flat config)
 
+The plugin ships a `recommended` config preset that registers the plugin and
+turns on **every** rule at `error`:
+
+```ts
+// eslint.config.mts
+import { eslintPluginTsFortress } from 'eslint-plugin-ts-fortress';
+
+export default [eslintPluginTsFortress.configs.recommended];
+```
+
+Since the preset is a plain flat-config object, individual rules can be
+adjusted by a later config entry:
+
+```ts
+// eslint.config.mts
+import {
+    eslintPluginTsFortress,
+    type EslintTsFortressRules,
+} from 'eslint-plugin-ts-fortress';
+
+export default [
+    eslintPluginTsFortress.configs.recommended,
+    {
+        files: ['src/legacy/**'],
+        rules: {
+            'ts-fortress/prefer-canonical-length-constrained-type': 'off',
+        } satisfies Partial<EslintTsFortressRules>,
+    },
+];
+```
+
+Or register the plugin yourself and pick the rules one by one:
+
 ```ts
 // eslint.config.mts
 import {
@@ -26,7 +59,7 @@ export default [
     {
         plugins: { 'ts-fortress': eslintPluginTsFortress },
         rules: {
-            'ts-fortress/prefer-non-empty-array': 'error',
+            'ts-fortress/prefer-canonical-length-constrained-type': 'error',
         } satisfies Partial<EslintTsFortressRules>,
     },
 ];
@@ -34,43 +67,87 @@ export default [
 
 ## Rules
 
-| Rule                     | Description                                             |
-| ------------------------ | ------------------------------------------------------- |
-| `prefer-non-empty-array` | Replace `minLengthArray(1, …)` with `nonEmptyArray(…)`. |
+| Rule                                       | Description                                                                                   |
+| :----------------------------------------- | :-------------------------------------------------------------------------------------------- |
+| `prefer-canonical-length-constrained-type` | Normalize a length-constrained array combinator with degenerate bounds to its canonical form. |
+
+### `prefer-canonical-length-constrained-type`
 
-### `prefer-non-empty-array`
+Several of ts-fortress's array combinators build the very same type once their
+length arguments hit a degenerate value. The rule rewrites each of those to the
+combinator that names the constraint directly:
 
-`t.minLengthArray(1, x)` and `t.nonEmptyArray(x)` build the **same type** —
-`NonEmptyArray<A>` is defined as `MinLengthArray<1, A>` — so the rewrite is
-type-preserving. `nonEmptyArray` states the intent directly and, when no
-explicit `typeName` is given, reports the clearer `NonEmptyArray<…>` instead of
-`MinLengthArray<1, …>` in validation errors.
+| ❌ written as                 | ✅ canonical form        | why they are the same type                                         |
+| :---------------------------- | :----------------------- | :----------------------------------------------------------------- |
+| `minLengthArray(1, x)`        | `nonEmptyArray(x)`       | `NonEmptyArray<A>` is defined as `MinLengthArray<1, A>`            |
+| `minLengthTuple(0, x)`        | `array(x)`               | `MinLengthTuple<0, A>` is `readonly A[]` — no constraint at all    |
+| `maxLengthTuple(0, x)`        | `fixedLengthTuple(0, x)` | both are `readonly []`                                             |
+| `boundedLengthTuple(n, n, x)` | `fixedLengthTuple(n, x)` | the length union collapses to its single member                    |
+| `boundedLengthTuple(0, n, x)` | `maxLengthTuple(n, x)`   | `MaxLengthTuple<N, A>` is defined as `BoundedLengthTuple<0, N, A>` |
 
 ```ts
 import * as t from 'ts-fortress';
 
 // ❌
 const Tags = t.minLengthArray(1, t.string());
+const Rgb = t.boundedLengthTuple(3, 3, t.number());
+const Page = t.boundedLengthTuple(0, 20, t.string());
 
 // ✅
 const Tags = t.nonEmptyArray(t.string());
+const Rgb = t.fixedLengthTuple(3, t.number());
+const Page = t.maxLengthTuple(20, t.string());
 ```
 
+Each rewrite keeps the accepted values, the `defaultValue`, and the options
+object exactly as they were. The only observable change is the default
+`typeName` — and the `details.kind` of the length error derived from it — which
+becomes the one that names the constraint actually being checked.
+
+#### Why the branded `*Array` family is left alone
+
+`boundedLengthArray(0, n, x)` and `boundedLengthArray(n, n, x)` look like the
+same degenerate cases, but their types are branded rather than structural, and
+the analogous rewrites would silently change them:
+
+- `BoundedLengthArray<Min, Max, A>` is
+  `MaxLengthArray<Max, A> & MinLengthArray<Min, A>`, so rewriting
+  `boundedLengthArray(0, n, x)` to `maxLengthArray(n, x)` **drops** the
+  `MinLengthArray<0, A>` brand — a widening.
+- `FixedLengthArray<N, A>` additionally intersects the exact tuple
+  `FixedLengthTuple<N, A>` for `N <= 10`, so rewriting
+  `boundedLengthArray(n, n, x)` to `fixedLengthArray(n, x)` **adds** a
+  constraint — a narrowing.
+
+Neither is a pure rename, so the rule does not report them.
+
+#### Bounds above the structural cap
+
+The `*Tuple` combinators only encode lengths up to `10` (ts-type-forge's
+`StructuralPrefixLength`); past that they fall back to an overload that drops
+the constraint from the result type. The rule therefore only fires when the
+bound it carries over to the other combinator is a literal within `0..10`.
+
+#### Imports
+
 Both the namespace style (`import * as t from 'ts-fortress'`) and named imports
 — including aliases — are recognized, and the autofix reuses whatever binding
-the file already has, adding `import { nonEmptyArray } from 'ts-fortress';`
-only when a named call needs it.
-
-The rule deliberately leaves alone:
-
-- other minimum lengths (`minLengthArray(2, …)` is `MinLengthArray<2, …>`);
-- `minLengthTuple(1, …)`, which produces the structural
-  `readonly [A, ...A[]]` tuple rather than the branded `NonEmptyArray`;
-- calls passing a `defaultValue` option, because `nonEmptyArray` types it as
-  `NonEmptyTuple<A>` while `minLengthArray` types it as the branded
-  `MinLengthArray<1, A>` — a blind rewrite could stop type-checking. A
-  `typeName`-only options object is safe and is rewritten;
-- files that already bind the name `nonEmptyArray` to something else.
+the file already has, adding `import { … } from 'ts-fortress';` only when a
+named call needs one.
+
+#### The rule deliberately leaves alone
+
+- non-degenerate bounds (`minLengthArray(2, …)`, `boundedLengthTuple(1, 3, …)`);
+- computed bounds and calls with explicit type arguments, since the literal is
+  what makes the two forms equivalent;
+- `minLengthArray(1, …)` calls passing a `defaultValue`, because
+  `nonEmptyArray` types that option as `NonEmptyTuple<A>` while
+  `minLengthArray` types it as the branded `MinLengthArray<1, A>` — a blind
+  rewrite could stop type-checking. A `typeName`-only options object is safe
+  and is rewritten. (The other rewrites type `defaultValue` identically, so
+  they keep it.)
+- calls where the target name is already bound to something else at the call
+  site.
 
 ## License
 

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 export { eslintPluginTsFortress } from './plugin.mjs';
 export type { EslintTsFortressRules, EslintTsFortressRulesOption, } from './rule-types.mjs';
 export { tsFortressRules } from './rules/index.mjs';
-export { type ESLintPlugin } from './types.mjs';
+export { type ESLintFlatConfig, type ESLintPlugin } from './types.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,YAAY,EACV,qBAAqB,EACrB,2BAA2B,GAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,YAAY,EACV,qBAAqB,EACrB,2BAA2B,GAC5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/plugin.d.mts

@@ -1,3 +1,22 @@
 import { type ESLintPlugin } from './types.mjs';
-export declare const eslintPluginTsFortress: ESLintPlugin;
+export declare const eslintPluginTsFortress: {
+    readonly meta: {
+        readonly name: 'eslint-plugin-ts-fortress';
+    };
+    readonly rules: {
+        readonly 'prefer-canonical-length-constrained-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useCanonicalType", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    };
+    readonly configs: {
+        /** Enables every rule of this plugin at `error`. */
+        readonly recommended: {
+            readonly name: 'ts-fortress/recommended';
+            readonly plugins: {
+                readonly 'ts-fortress': ESLintPlugin;
+            };
+            readonly rules: {
+                readonly 'ts-fortress/prefer-canonical-length-constrained-type': 'error';
+            };
+        };
+    };
+};
 //# sourceMappingURL=plugin.d.mts.map

package/dist/plugin.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.mts","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,eAAO,MAAM,sBAAsB,EAAE,YAK3B,CAAC"}
+{"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,sBAAsB;;iBAE/B,IAAI,EAAE,2BAA2B;;;;;;QAIjC,oDAAoD;iBACpD,WAAW;2BAtBP,yBAAyB;;yBAQzB,aAAa,EAAI,YAAY;;;iFAdqB,OAAO;;;;CA8BhC,CAAC"}

package/dist/plugin.mjs

@@ -1,10 +1,32 @@
 import { tsFortressRules } from './rules/rules.mjs';
 
+const recommendedRules = {
+  "ts-fortress/prefer-canonical-length-constrained-type": "error"
+};
+const recommendedConfig = {
+  name: "ts-fortress/recommended",
+  plugins: {
+    // Resolved lazily so that this config registers the *same* object that
+    // `eslintPluginTsFortress` refers to. ESLint rejects a plugin name that
+    // maps to two different objects with `Cannot redefine plugin`, which is
+    // what a user combining this preset with their own
+    // `plugins: { 'ts-fortress': eslintPluginTsFortress }` entry would hit if
+    // the preset embedded a separate copy of the plugin.
+    get "ts-fortress"() {
+      return eslintPluginTsFortress;
+    }
+  },
+  rules: recommendedRules
+};
 const eslintPluginTsFortress = {
   meta: {
     name: "eslint-plugin-ts-fortress"
   },
-  rules: tsFortressRules
+  rules: tsFortressRules,
+  configs: {
+    /** Enables every rule of this plugin at `error`. */
+    recommended: recommendedConfig
+  }
 };
 
 export { eslintPluginTsFortress };

package/dist/plugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.mjs","sources":["../src/plugin.mts"],"sourcesContent":["import { tsFortressRules } from './rules/index.mjs';\nimport { type ESLintPlugin } from './types.mjs';\n\nexport const eslintPluginTsFortress: ESLintPlugin = {\n  meta: {\n    name: 'eslint-plugin-ts-fortress',\n  },\n  rules: tsFortressRules,\n} as const;\n"],"names":[],"mappings":";;AAGO,MAAM,sBAAA,GAAuC;AAAA,EAClD,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM;AAAA,GACR;AAAA,EACA,KAAA,EAAO;AACT;;;;"}
+{"version":3,"file":"plugin.mjs","sources":["../src/plugin.mts"],"sourcesContent":["import { tsFortressRules } 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 tsFortressRules}, so adding\n * a rule without listing it here fails to type-check.\n */\nconst recommendedRules = {\n  'ts-fortress/prefer-canonical-length-constrained-type': 'error',\n} as const satisfies Readonly<\n  Record<`ts-fortress/${keyof typeof tsFortressRules}`, 'error'>\n>;\n\nconst recommendedConfig = {\n  name: 'ts-fortress/recommended',\n  plugins: {\n    // Resolved lazily so that this config registers the *same* object that\n    // `eslintPluginTsFortress` 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-fortress': eslintPluginTsFortress }` entry would hit if\n    // the preset embedded a separate copy of the plugin.\n    get 'ts-fortress'(): ESLintPlugin {\n      return eslintPluginTsFortress;\n    },\n  },\n  rules: recommendedRules,\n} as const satisfies ESLintFlatConfig;\n\nexport const eslintPluginTsFortress = {\n  meta: {\n    name: 'eslint-plugin-ts-fortress',\n  },\n  rules: tsFortressRules,\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,sDAAA,EAAwD;AAC1D,CAAA;AAIA,MAAM,iBAAA,GAAoB;AAAA,EACxB,IAAA,EAAM,yBAAA;AAAA,EACN,OAAA,EAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOP,IAAI,aAAA,GAA8B;AAChC,MAAA,OAAO,sBAAA;AAAA,IACT;AAAA,GACF;AAAA,EACA,KAAA,EAAO;AACT,CAAA;AAEO,MAAM,sBAAA,GAAyB;AAAA,EACpC,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM;AAAA,GACR;AAAA,EACA,KAAA,EAAO,eAAA;AAAA,EACP,OAAA,EAAS;AAAA;AAAA,IAEP,WAAA,EAAa;AAAA;AAEjB;;;;"}

package/dist/rule-types.d.mts

@@ -2,7 +2,7 @@ import { type Linter } from 'eslint';
 import { type TypeEq } from 'ts-type-forge';
 import { type tsFortressRules } from './rules/index.mjs';
 /**
- * @description Replace `minLengthArray(1, ...)` with `nonEmptyArray(...)` from ts-fortress.
+ * @description Normalize a length-constrained ts-fortress array combinator whose bounds are degenerate (e.g. `minLengthArray(1, x)`, `boundedLengthTuple(n, n, x)`) to the combinator that names that constraint directly.
  *
  *  ```md
  *  | key        | value      |
@@ -12,11 +12,11 @@ import { type tsFortressRules } from './rules/index.mjs';
  *  | fixable    | code       |
  *  ```
  */
-declare namespace PreferNonEmptyArray {
+declare namespace PreferCanonicalLengthConstrainedType {
     type RuleEntry = Linter.StringSeverity;
 }
 export type EslintTsFortressRules = Readonly<{
-    'ts-fortress/prefer-non-empty-array': PreferNonEmptyArray.RuleEntry;
+    'ts-fortress/prefer-canonical-length-constrained-type': PreferCanonicalLengthConstrainedType.RuleEntry;
 }>;
 export type EslintTsFortressRulesOption = Readonly<Record<never, never>>;
 type AssertTrue<B extends true> = B;

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,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,kBAAU,mBAAmB,CAAC;IAC5B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,oCAAoC,EAAE,mBAAmB,CAAC,SAAS,CAAC;CACrE,CAAC,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAIzE,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAEpC,MAAM,MAAM,kBAAkB,GAAG,UAAU,CACzC,MAAM,CACJ,MAAM,qBAAqB,EAC3B,eAAe,MAAM,OAAO,eAAe,EAAE,CAC9C,CACF,CAAC"}
+{"version":3,"file":"rule-types.d.mts","sourceRoot":"","sources":["../src/rule-types.mts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,kBAAU,oCAAoC,CAAC;IAC7C,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,sDAAsD,EAAE,oCAAoC,CAAC,SAAS,CAAC;CACxG,CAAC,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAIzE,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAEpC,MAAM,MAAM,kBAAkB,GAAG,UAAU,CACzC,MAAM,CACJ,MAAM,qBAAqB,EAC3B,eAAe,MAAM,OAAO,eAAe,EAAE,CAC9C,CACF,CAAC"}

package/dist/rules/constants.d.mts

@@ -1,4 +1,17 @@
 export declare const TS_FORTRESS_MODULE = "ts-fortress";
+export declare const ARRAY_FN = "array";
+export declare const BOUNDED_LENGTH_TUPLE_FN = "boundedLengthTuple";
+export declare const FIXED_LENGTH_TUPLE_FN = "fixedLengthTuple";
+export declare const MAX_LENGTH_TUPLE_FN = "maxLengthTuple";
 export declare const MIN_LENGTH_ARRAY_FN = "minLengthArray";
+export declare const MIN_LENGTH_TUPLE_FN = "minLengthTuple";
 export declare const NON_EMPTY_ARRAY_FN = "nonEmptyArray";
+/**
+ * Inclusive upper bound of ts-type-forge's `StructuralPrefixLength` (`0..10`) —
+ * the lengths the structural `*Tuple` combinators encode in their result type.
+ * A bound outside this range selects a different overload (one that drops the
+ * constraint), so a rewrite that carries a bound over to another combinator
+ * only stays type-identical while the bound is within it.
+ */
+export declare const STRUCTURAL_PREFIX_CAP = 10;
 //# sourceMappingURL=constants.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.mts","sourceRoot":"","sources":["../../src/rules/constants.mts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,gBAAgB,CAAC;AAEhD,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,eAAO,MAAM,kBAAkB,kBAAkB,CAAC"}
+{"version":3,"file":"constants.d.mts","sourceRoot":"","sources":["../../src/rules/constants.mts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,gBAAgB,CAAC;AAEhD,eAAO,MAAM,QAAQ,UAAU,CAAC;AAEhC,eAAO,MAAM,uBAAuB,uBAAuB,CAAC;AAE5D,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AAExD,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAElD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC"}

package/dist/rules/constants.mjs

@@ -1,6 +1,12 @@
 const TS_FORTRESS_MODULE = "ts-fortress";
+const ARRAY_FN = "array";
+const BOUNDED_LENGTH_TUPLE_FN = "boundedLengthTuple";
+const FIXED_LENGTH_TUPLE_FN = "fixedLengthTuple";
+const MAX_LENGTH_TUPLE_FN = "maxLengthTuple";
 const MIN_LENGTH_ARRAY_FN = "minLengthArray";
+const MIN_LENGTH_TUPLE_FN = "minLengthTuple";
 const NON_EMPTY_ARRAY_FN = "nonEmptyArray";
+const STRUCTURAL_PREFIX_CAP = 10;
 
-export { MIN_LENGTH_ARRAY_FN, NON_EMPTY_ARRAY_FN, TS_FORTRESS_MODULE };
+export { ARRAY_FN, BOUNDED_LENGTH_TUPLE_FN, FIXED_LENGTH_TUPLE_FN, MAX_LENGTH_TUPLE_FN, MIN_LENGTH_ARRAY_FN, MIN_LENGTH_TUPLE_FN, NON_EMPTY_ARRAY_FN, STRUCTURAL_PREFIX_CAP, TS_FORTRESS_MODULE };
 //# sourceMappingURL=constants.mjs.map

package/dist/rules/constants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.mjs","sources":["../../src/rules/constants.mts"],"sourcesContent":["export const TS_FORTRESS_MODULE = 'ts-fortress';\n\nexport const MIN_LENGTH_ARRAY_FN = 'minLengthArray';\n\nexport const NON_EMPTY_ARRAY_FN = 'nonEmptyArray';\n"],"names":[],"mappings":"AAAO,MAAM,kBAAA,GAAqB;AAE3B,MAAM,mBAAA,GAAsB;AAE5B,MAAM,kBAAA,GAAqB;;;;"}
+{"version":3,"file":"constants.mjs","sources":["../../src/rules/constants.mts"],"sourcesContent":["export const TS_FORTRESS_MODULE = 'ts-fortress';\n\nexport const ARRAY_FN = 'array';\n\nexport const BOUNDED_LENGTH_TUPLE_FN = 'boundedLengthTuple';\n\nexport const FIXED_LENGTH_TUPLE_FN = 'fixedLengthTuple';\n\nexport const MAX_LENGTH_TUPLE_FN = 'maxLengthTuple';\n\nexport const MIN_LENGTH_ARRAY_FN = 'minLengthArray';\n\nexport const MIN_LENGTH_TUPLE_FN = 'minLengthTuple';\n\nexport const NON_EMPTY_ARRAY_FN = 'nonEmptyArray';\n\n/**\n * Inclusive upper bound of ts-type-forge's `StructuralPrefixLength` (`0..10`) —\n * the lengths the structural `*Tuple` combinators encode in their result type.\n * A bound outside this range selects a different overload (one that drops the\n * constraint), so a rewrite that carries a bound over to another combinator\n * only stays type-identical while the bound is within it.\n */\nexport const STRUCTURAL_PREFIX_CAP = 10;\n"],"names":[],"mappings":"AAAO,MAAM,kBAAA,GAAqB;AAE3B,MAAM,QAAA,GAAW;AAEjB,MAAM,uBAAA,GAA0B;AAEhC,MAAM,qBAAA,GAAwB;AAE9B,MAAM,mBAAA,GAAsB;AAE5B,MAAM,mBAAA,GAAsB;AAE5B,MAAM,mBAAA,GAAsB;AAE5B,MAAM,kBAAA,GAAqB;AAS3B,MAAM,qBAAA,GAAwB;;;;"}

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

@@ -25,16 +25,23 @@ export declare const getImportedLocalName: (importDeclarations: readonly TSESTre
  */
 export declare const buildCalleeResolver: (importDeclarations: readonly TSESTree.ImportDeclaration[]) => ((callee: TSESTree.Expression) => ResolvedCallee | undefined);
 /**
- * Whether the file already binds `name` to something that is not the
- * ts-fortress export of the same name — a local declaration or an import from
- * another module. Autofixes that introduce `name` must bail out in that case,
+ * Whether `name` resolves, at `node`, to a binding that is not a ts-fortress
+ * import — a local declaration, a parameter, or an import from another module.
+ * An autofix that makes a call reference `name` must bail out in that case,
  * because the rewritten call would resolve to the wrong binding.
+ *
+ * Scope-based rather than a scan of the top-level statements, so a binding that
+ * merely shadows the ts-fortress one around the call site is caught too.
  */
-export declare const hasConflictingDeclaration: (program: TSESTree.Program, name: string) => boolean;
+export declare const hasForeignBinding: (sourceCode: TSESLint.SourceCode, node: TSESTree.Node, name: string) => boolean;
 /**
- * Inserts `import { <name> } from 'ts-fortress';` at the top of the file.
- * Placement is deliberately naive: prettier-plugin-organize-imports (or any
- * equivalent) merges and sorts it afterwards.
+ * Inserts `import { <name> } from 'ts-fortress';` for each name at the top of
+ * the file. Placement is deliberately naive: prettier-plugin-organize-imports
+ * (or any equivalent) merges and sorts them afterwards.
+ *
+ * All names go into a single fix on purpose: ESLint merges the fixes of one
+ * report into one edit span, so two reports each inserting at the start of the
+ * file would conflict and one of them would be dropped.
  */
-export declare const buildImportFix: (fixer: TSESLint.RuleFixer, program: TSESTree.Program, name: string) => readonly TSESLint.RuleFix[];
+export declare const buildImportsFix: (fixer: TSESLint.RuleFixer, program: TSESTree.Program, names: readonly string[]) => readonly TSESLint.RuleFix[];
 //# sourceMappingURL=import-utils.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"import-utils.d.mts","sourceRoot":"","sources":["../../src/rules/import-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAKlC,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,4EAA4E;IAC5E,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC5B,2EAA2E;IAC3E,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC,CAAC;AAEH,qEAAqE;AACrE,eAAO,MAAM,oBAAoB,YACtB,QAAQ,CAAC,OAAO,KACxB,SAAS,QAAQ,CAAC,iBAAiB,EAKnC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,uBACX,SAAS,QAAQ,CAAC,iBAAiB,EAAE,gBAC3C,MAAM,KACnB,MAAM,GAAG,SASK,CAAC;AAElB;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,uBACV,SAAS,QAAQ,CAAC,iBAAiB,EAAE,KACxD,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,KAAK,cAAc,GAAG,SAAS,CAkD9D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,YAC3B,QAAQ,CAAC,OAAO,QACnB,MAAM,KACX,OAgBC,CAAC;AAEL;;;;GAIG;AACH,eAAO,MAAM,cAAc,UAClB,QAAQ,CAAC,SAAS,WAChB,QAAQ,CAAC,OAAO,QACnB,MAAM,KACX,SAAS,QAAQ,CAAC,OAAO,EAMhB,CAAC"}
+{"version":3,"file":"import-utils.d.mts","sourceRoot":"","sources":["../../src/rules/import-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAKlC,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,4EAA4E;IAC5E,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC5B,2EAA2E;IAC3E,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC,CAAC;AAEH,qEAAqE;AACrE,eAAO,MAAM,oBAAoB,YACtB,QAAQ,CAAC,OAAO,KACxB,SAAS,QAAQ,CAAC,iBAAiB,EAKnC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,uBACX,SAAS,QAAQ,CAAC,iBAAiB,EAAE,gBAC3C,MAAM,KACnB,MAAM,GAAG,SASK,CAAC;AAElB;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,uBACV,SAAS,QAAQ,CAAC,iBAAiB,EAAE,KACxD,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,KAAK,cAAc,GAAG,SAAS,CAkD9D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,eAChB,QAAQ,CAAC,UAAU,QACzB,QAAQ,CAAC,IAAI,QACb,MAAM,KACX,OAgBF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,UACnB,QAAQ,CAAC,SAAS,WAChB,QAAQ,CAAC,OAAO,SAClB,SAAS,MAAM,EAAE,KACvB,SAAS,QAAQ,CAAC,OAAO,EAUX,CAAC"}

package/dist/rules/import-utils.mjs

@@ -35,34 +35,23 @@ const buildCalleeResolver = (importDeclarations) => {
     } : void 0;
   };
 };
-const hasConflictingDeclaration = (program, name) => program.body.some((node) => {
-  if (node.type === AST_NODE_TYPES.ImportDeclaration) {
-    return node.source.value !== TS_FORTRESS_MODULE && node.specifiers.some((specifier) => specifier.local.name === name);
+const hasForeignBinding = (sourceCode, node, name) => {
+  for (let mut_scope = sourceCode.getScope(node); mut_scope !== null; mut_scope = mut_scope.upper) {
+    const variable = mut_scope.set.get(name);
+    if (variable !== void 0) {
+      return variable.defs.some((def) => !isTsFortressImportDef(def.node));
+    }
   }
-  return declaresName(
-    node.type === AST_NODE_TYPES.ExportNamedDeclaration || node.type === AST_NODE_TYPES.ExportDefaultDeclaration ? node.declaration : node,
-    name
-  );
-});
-const buildImportFix = (fixer, program, name) => [
+  return false;
+};
+const buildImportsFix = (fixer, program, names) => names.length === 0 ? [] : [
   fixer.insertTextBefore(
     program,
-    `import { ${name} } from '${TS_FORTRESS_MODULE}';
-`
+    names.map((name) => `import { ${name} } from '${TS_FORTRESS_MODULE}';
+`).join("")
   )
 ];
-const declaresName = (node, name) => {
-  if (node === null || node === void 0) return false;
-  if (node.type === AST_NODE_TYPES.TSTypeAliasDeclaration || node.type === AST_NODE_TYPES.TSInterfaceDeclaration || node.type === AST_NODE_TYPES.TSEnumDeclaration) {
-    return node.id.name === name;
-  }
-  if (node.type === AST_NODE_TYPES.ClassDeclaration || node.type === AST_NODE_TYPES.FunctionDeclaration) {
-    return node.id?.name === name;
-  }
-  return node.type === AST_NODE_TYPES.VariableDeclaration && node.declarations.some(
-    (declarator) => declarator.id.type === AST_NODE_TYPES.Identifier && declarator.id.name === name
-  );
-};
+const isTsFortressImportDef = (node) => (node.type === AST_NODE_TYPES.ImportSpecifier || node.type === AST_NODE_TYPES.ImportDefaultSpecifier || node.type === AST_NODE_TYPES.ImportNamespaceSpecifier) && node.parent.type === AST_NODE_TYPES.ImportDeclaration && node.parent.source.value === TS_FORTRESS_MODULE;
 
-export { buildCalleeResolver, buildImportFix, getImportedLocalName, getTsFortressImports, hasConflictingDeclaration };
+export { buildCalleeResolver, buildImportsFix, getImportedLocalName, getTsFortressImports, hasForeignBinding };
 //# sourceMappingURL=import-utils.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"import-utils.mjs","sources":["../../src/rules/import-utils.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { TS_FORTRESS_MODULE } from './constants.mjs';\n\n/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */\n\nexport type ResolvedCallee = Readonly<{\n  /** The canonical (imported) ts-fortress name, regardless of local alias. */\n  canonicalName: string;\n  /** The identifier node to rewrite when replacing the callee name. */\n  propertyNode: TSESTree.Node;\n  /** Whether the call was made through a namespace import (`t.foo(...)`). */\n  isNamespace: boolean;\n}>;\n\n/** Every `import ... from 'ts-fortress'` declaration in the file. */\nexport const getTsFortressImports = (\n  program: TSESTree.Program,\n): readonly TSESTree.ImportDeclaration[] =>\n  program.body.filter(\n    (node): node is TSESTree.ImportDeclaration =>\n      node.type === AST_NODE_TYPES.ImportDeclaration &&\n      node.source.value === TS_FORTRESS_MODULE,\n  );\n\n/**\n * Returns the in-scope local name a given ts-fortress export is imported as\n * (handling aliases such as `import { nonEmptyArray as nea }` → `'nea'`), or\n * `undefined` when it is not imported. Used so autofixes reference the binding\n * that actually exists rather than the canonical name.\n */\nexport const getImportedLocalName = (\n  importDeclarations: readonly TSESTree.ImportDeclaration[],\n  importedName: string,\n): string | undefined =>\n  importDeclarations\n    .flatMap((declaration) => declaration.specifiers)\n    .find(\n      (specifier) =>\n        specifier.type === AST_NODE_TYPES.ImportSpecifier &&\n        (specifier.imported.type === AST_NODE_TYPES.Identifier\n          ? specifier.imported.name\n          : specifier.imported.value) === importedName,\n    )?.local.name;\n\n/**\n * Builds a resolver that maps a call expression's callee to the canonical\n * ts-fortress function it refers to. Handles named imports (including aliases)\n * and namespace imports (`import * as t` → `t.foo(...)`) — the latter being the\n * idiomatic way to consume ts-fortress. Returns `undefined` for any callee that\n * does not reference the given ts-fortress imports.\n */\nexport const buildCalleeResolver = (\n  importDeclarations: readonly TSESTree.ImportDeclaration[],\n): ((callee: TSESTree.Expression) => ResolvedCallee | undefined) => {\n  const specifiers = importDeclarations.flatMap(\n    (declaration) => declaration.specifiers,\n  );\n\n  const namespaceNames = new Set(\n    specifiers\n      .filter(\n        (specifier) =>\n          specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier,\n      )\n      .map((specifier) => specifier.local.name),\n  );\n\n  const localToCanonical = new Map<string, string>(\n    specifiers.flatMap((specifier) => {\n      if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) return [];\n\n      const importedName =\n        specifier.imported.type === AST_NODE_TYPES.Identifier\n          ? specifier.imported.name\n          : specifier.imported.value;\n\n      return typeof importedName === 'string'\n        ? [[specifier.local.name, importedName] as const]\n        : [];\n    }),\n  );\n\n  return (callee) => {\n    if (callee.type === AST_NODE_TYPES.Identifier) {\n      const canonicalName = localToCanonical.get(callee.name);\n\n      return canonicalName === undefined\n        ? undefined\n        : { canonicalName, propertyNode: callee, isNamespace: false };\n    }\n\n    return callee.type === AST_NODE_TYPES.MemberExpression &&\n      !callee.computed &&\n      callee.object.type === AST_NODE_TYPES.Identifier &&\n      namespaceNames.has(callee.object.name) &&\n      callee.property.type === AST_NODE_TYPES.Identifier\n      ? {\n          canonicalName: callee.property.name,\n          propertyNode: callee.property,\n          isNamespace: true,\n        }\n      : undefined;\n  };\n};\n\n/**\n * Whether the file already binds `name` to something that is not the\n * ts-fortress export of the same name — a local declaration or an import from\n * another module. Autofixes that introduce `name` must bail out in that case,\n * because the rewritten call would resolve to the wrong binding.\n */\nexport const hasConflictingDeclaration = (\n  program: TSESTree.Program,\n  name: string,\n): boolean =>\n  program.body.some((node) => {\n    if (node.type === AST_NODE_TYPES.ImportDeclaration) {\n      return (\n        node.source.value !== TS_FORTRESS_MODULE &&\n        node.specifiers.some((specifier) => specifier.local.name === name)\n      );\n    }\n\n    return declaresName(\n      node.type === AST_NODE_TYPES.ExportNamedDeclaration ||\n        node.type === AST_NODE_TYPES.ExportDefaultDeclaration\n        ? node.declaration\n        : node,\n      name,\n    );\n  });\n\n/**\n * Inserts `import { <name> } from 'ts-fortress';` at the top of the file.\n * Placement is deliberately naive: prettier-plugin-organize-imports (or any\n * equivalent) merges and sorts it afterwards.\n */\nexport const buildImportFix = (\n  fixer: TSESLint.RuleFixer,\n  program: TSESTree.Program,\n  name: string,\n): readonly TSESLint.RuleFix[] =>\n  [\n    fixer.insertTextBefore(\n      program,\n      `import { ${name} } from '${TS_FORTRESS_MODULE}';\\n`,\n    ),\n  ] as const;\n\nconst declaresName = (\n  node: TSESTree.Node | null | undefined,\n  name: string,\n): boolean => {\n  if (node === null || node === undefined) return false;\n\n  if (\n    node.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||\n    node.type === AST_NODE_TYPES.TSInterfaceDeclaration ||\n    node.type === AST_NODE_TYPES.TSEnumDeclaration\n  ) {\n    return node.id.name === name;\n  }\n\n  if (\n    node.type === AST_NODE_TYPES.ClassDeclaration ||\n    node.type === AST_NODE_TYPES.FunctionDeclaration\n  ) {\n    return node.id?.name === name;\n  }\n\n  return (\n    node.type === AST_NODE_TYPES.VariableDeclaration &&\n    node.declarations.some(\n      (declarator) =>\n        declarator.id.type === AST_NODE_TYPES.Identifier &&\n        declarator.id.name === name,\n    )\n  );\n};\n\n/* eslint-enable @typescript-eslint/prefer-readonly-parameter-types */\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"import-utils.mjs","sources":["../../src/rules/import-utils.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { TS_FORTRESS_MODULE } from './constants.mjs';\n\n/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */\n\nexport type ResolvedCallee = Readonly<{\n  /** The canonical (imported) ts-fortress name, regardless of local alias. */\n  canonicalName: string;\n  /** The identifier node to rewrite when replacing the callee name. */\n  propertyNode: TSESTree.Node;\n  /** Whether the call was made through a namespace import (`t.foo(...)`). */\n  isNamespace: boolean;\n}>;\n\n/** Every `import ... from 'ts-fortress'` declaration in the file. */\nexport const getTsFortressImports = (\n  program: TSESTree.Program,\n): readonly TSESTree.ImportDeclaration[] =>\n  program.body.filter(\n    (node): node is TSESTree.ImportDeclaration =>\n      node.type === AST_NODE_TYPES.ImportDeclaration &&\n      node.source.value === TS_FORTRESS_MODULE,\n  );\n\n/**\n * Returns the in-scope local name a given ts-fortress export is imported as\n * (handling aliases such as `import { nonEmptyArray as nea }` → `'nea'`), or\n * `undefined` when it is not imported. Used so autofixes reference the binding\n * that actually exists rather than the canonical name.\n */\nexport const getImportedLocalName = (\n  importDeclarations: readonly TSESTree.ImportDeclaration[],\n  importedName: string,\n): string | undefined =>\n  importDeclarations\n    .flatMap((declaration) => declaration.specifiers)\n    .find(\n      (specifier) =>\n        specifier.type === AST_NODE_TYPES.ImportSpecifier &&\n        (specifier.imported.type === AST_NODE_TYPES.Identifier\n          ? specifier.imported.name\n          : specifier.imported.value) === importedName,\n    )?.local.name;\n\n/**\n * Builds a resolver that maps a call expression's callee to the canonical\n * ts-fortress function it refers to. Handles named imports (including aliases)\n * and namespace imports (`import * as t` → `t.foo(...)`) — the latter being the\n * idiomatic way to consume ts-fortress. Returns `undefined` for any callee that\n * does not reference the given ts-fortress imports.\n */\nexport const buildCalleeResolver = (\n  importDeclarations: readonly TSESTree.ImportDeclaration[],\n): ((callee: TSESTree.Expression) => ResolvedCallee | undefined) => {\n  const specifiers = importDeclarations.flatMap(\n    (declaration) => declaration.specifiers,\n  );\n\n  const namespaceNames = new Set(\n    specifiers\n      .filter(\n        (specifier) =>\n          specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier,\n      )\n      .map((specifier) => specifier.local.name),\n  );\n\n  const localToCanonical = new Map<string, string>(\n    specifiers.flatMap((specifier) => {\n      if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) return [];\n\n      const importedName =\n        specifier.imported.type === AST_NODE_TYPES.Identifier\n          ? specifier.imported.name\n          : specifier.imported.value;\n\n      return typeof importedName === 'string'\n        ? [[specifier.local.name, importedName] as const]\n        : [];\n    }),\n  );\n\n  return (callee) => {\n    if (callee.type === AST_NODE_TYPES.Identifier) {\n      const canonicalName = localToCanonical.get(callee.name);\n\n      return canonicalName === undefined\n        ? undefined\n        : { canonicalName, propertyNode: callee, isNamespace: false };\n    }\n\n    return callee.type === AST_NODE_TYPES.MemberExpression &&\n      !callee.computed &&\n      callee.object.type === AST_NODE_TYPES.Identifier &&\n      namespaceNames.has(callee.object.name) &&\n      callee.property.type === AST_NODE_TYPES.Identifier\n      ? {\n          canonicalName: callee.property.name,\n          propertyNode: callee.property,\n          isNamespace: true,\n        }\n      : undefined;\n  };\n};\n\n/**\n * Whether `name` resolves, at `node`, to a binding that is not a ts-fortress\n * import — a local declaration, a parameter, or an import from another module.\n * An autofix that makes a call reference `name` must bail out in that case,\n * because the rewritten call would resolve to the wrong binding.\n *\n * Scope-based rather than a scan of the top-level statements, so a binding that\n * merely shadows the ts-fortress one around the call site is caught too.\n */\nexport const hasForeignBinding = (\n  sourceCode: TSESLint.SourceCode,\n  node: TSESTree.Node,\n  name: string,\n): boolean => {\n  for (\n    let mut_scope: TSESLint.Scope.Scope | null = sourceCode.getScope(node);\n    mut_scope !== null;\n    mut_scope = mut_scope.upper\n  ) {\n    const variable = mut_scope.set.get(name);\n\n    // The innermost binding wins, so the first scope that declares `name`\n    // decides — an outer ts-fortress import does not rescue a shadowed name.\n    if (variable !== undefined) {\n      return variable.defs.some((def) => !isTsFortressImportDef(def.node));\n    }\n  }\n\n  return false;\n};\n\n/**\n * Inserts `import { <name> } from 'ts-fortress';` for each name at the top of\n * the file. Placement is deliberately naive: prettier-plugin-organize-imports\n * (or any equivalent) merges and sorts them afterwards.\n *\n * All names go into a single fix on purpose: ESLint merges the fixes of one\n * report into one edit span, so two reports each inserting at the start of the\n * file would conflict and one of them would be dropped.\n */\nexport const buildImportsFix = (\n  fixer: TSESLint.RuleFixer,\n  program: TSESTree.Program,\n  names: readonly string[],\n): readonly TSESLint.RuleFix[] =>\n  names.length === 0\n    ? ([] as const)\n    : ([\n        fixer.insertTextBefore(\n          program,\n          names\n            .map((name) => `import { ${name} } from '${TS_FORTRESS_MODULE}';\\n`)\n            .join(''),\n        ),\n      ] as const);\n\nconst isTsFortressImportDef = (node: TSESTree.Node): boolean =>\n  (node.type === AST_NODE_TYPES.ImportSpecifier ||\n    node.type === AST_NODE_TYPES.ImportDefaultSpecifier ||\n    node.type === AST_NODE_TYPES.ImportNamespaceSpecifier) &&\n  node.parent.type === AST_NODE_TYPES.ImportDeclaration &&\n  node.parent.source.value === TS_FORTRESS_MODULE;\n\n/* eslint-enable @typescript-eslint/prefer-readonly-parameter-types */\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,6 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [];
+type MessageIds = 'useCanonicalType';
+export declare const preferCanonicalLengthConstrainedType: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-canonical-length-constrained-type.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-canonical-length-constrained-type.d.mts","sourceRoot":"","sources":["../../src/rules/prefer-canonical-length-constrained-type.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAmBlC,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,KAAK,UAAU,GAAG,kBAAkB,CAAC;AAyFrC,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,UAAU,CACpE,UAAU,EACV,OAAO,CA+HC,CAAC"}