eslint-plugin-ts-data-forge 0.6.1 → 0.7.0

package/README.md

@@ -72,6 +72,7 @@ export default [
 | `prefer-canonical-length-guard`        | Normalize array-length checks to the canonical `Arr` guard (`xs.length > 0` → `Arr.isNonEmpty`, `Arr.isFixedLengthArray(0, xs)` → `Arr.isEmpty`, `Arr.isFixedLengthTuple(0, xs)` → `Arr.isEmptyTuple`, …). |
 | `prefer-canonical-length-cast`         | Normalize a degenerate `Arr` length cast to the canonical one (`Arr.asMinLengthArray(1, xs)` → `Arr.asNonEmptyArray(xs)`, `Arr.asBoundedLengthArray(n, n, xs)` → `Arr.asFixedLengthArray(n, xs)`, …).      |
 | `prefer-arr-is-array`                  | Replace `Array.isArray` with `Arr.isArray`.                                                                                                                                                                |
+| `prefer-arr-scan`                      | Report an accumulated value rebuilt for every element (`xs.map((_, i) => f(...xs.slice(0, i + 1)))`, or a `reduce` that appends to its accumulator) and point at `Arr.scan`. Fixes the `reduce` form.      |
 | `prefer-arr-sum`                       | Replace `xs.reduce((a, b) => a + b, 0)` with `Arr.sum(xs)` / `Arr.sumBy(xs, fn)`.                                                                                                                          |
 | `prefer-as-int`                        | Replace branded-number assertions (`x as Int`) with `asInt(x)`-style casts.                                                                                                                                |
 | `prefer-is-non-null-object`            | Replace `typeof u === 'object' && u !== null` with `isNonNullObject(u)`.                                                                                                                                   |

package/dist/index.mjs

@@ -1,3 +1,3 @@
 export { eslintPluginTsDataForge } from './plugin.mjs';
-export { tsDataForgeRules } from './rules/rules.mjs';
-//# sourceMappingURL=index.mjs.map
+export { tsDataForgeRules } from './rules/index.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAKvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/plugin.d.mts

@@ -8,6 +8,7 @@ export declare const eslintPluginTsDataForge: {
         readonly 'prefer-canonical-length-guard': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useCanonicalGuard" | "useIsBoundedLengthArray" | "useIsFixedLengthArray" | "useIsMaxLengthArray" | "useIsMinLengthArray" | "useIsNonEmpty", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         readonly 'prefer-canonical-length-cast': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useCanonicalCast", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         readonly 'prefer-arr-is-array': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useArrIsArray", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        readonly 'prefer-arr-scan': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferArrScanAccumulate" | "preferArrScanPrefix", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         readonly 'prefer-arr-sum': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useArrSum" | "useArrSumBy", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         readonly 'prefer-as-int': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useBrandedNumberCastFunction", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         readonly 'prefer-is-non-null-object': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNonNullObject", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
@@ -34,6 +35,7 @@ export declare const eslintPluginTsDataForge: {
                 readonly 'ts-data-forge/prefer-canonical-length-cast': 'error';
                 readonly 'ts-data-forge/prefer-canonical-length-guard': 'error';
                 readonly 'ts-data-forge/prefer-arr-is-array': 'error';
+                readonly 'ts-data-forge/prefer-arr-scan': 'error';
                 readonly 'ts-data-forge/prefer-arr-sum': 'error';
                 readonly 'ts-data-forge/prefer-as-int': 'error';
                 readonly 'ts-data-forge/prefer-is-non-null-object': 'error';

package/dist/plugin.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.mts","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AA6CvE,eAAO,MAAM,uBAAuB;;iBAEhC,IAAI,EAAE,6BAA6B;;;;;;;;;;;;;;;;;;;;;;QAInC,oDAAoD;iBACpD,WAAW;2BAtBP,2BAA2B;;yBAQ3B,eAAe,EAAI,YAAY;;;yEA7BW,OAAO;uEACT,OAAO;wEACN,OAAO;8DACjB,OAAO;yDACZ,OAAO;wDACR,OAAO;oEACK,OAAO;gEACX,OAAO;uEACA,OAAO;oEACV,OAAO;sEACL,OAAO;gEACb,OAAO;oEACH,OAAO;+EACI,OAAO;6EACT,OAAO;;;;CA+B5B,CAAC"}
+{"version":3,"file":"plugin.d.mts","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AA8CvE,eAAO,MAAM,uBAAuB;;iBAEhC,IAAI,EAAE,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;QAInC,oDAAoD;iBACpD,WAAW;2BAtBP,2BAA2B;;yBAQ3B,eAAe,EAAI,YAAY;;;yEA9BW,OAAO;uEACT,OAAO;wEACN,OAAO;8DACjB,OAAO;0DACX,OAAO;yDACR,OAAO;wDACR,OAAO;oEACK,OAAO;gEACX,OAAO;uEACA,OAAO;oEACV,OAAO;sEACL,OAAO;gEACb,OAAO;oEACH,OAAO;+EACI,OAAO;6EACT,OAAO;;;;CA+B5B,CAAC"}

package/dist/plugin.mjs

@@ -1,47 +1,51 @@
-import { tsDataForgeRules } from './rules/rules.mjs';
+import { tsDataForgeRules } from './rules/index.mjs';
+
+
+
+
+
 
 const recommendedRules = {
-  "ts-data-forge/prefer-canonical-array-slicing": "error",
-  "ts-data-forge/prefer-canonical-length-cast": "error",
-  "ts-data-forge/prefer-canonical-length-guard": "error",
-  "ts-data-forge/prefer-arr-is-array": "error",
-  "ts-data-forge/prefer-arr-sum": "error",
-  "ts-data-forge/prefer-as-int": "error",
-  "ts-data-forge/prefer-is-non-null-object": "error",
-  "ts-data-forge/prefer-range-for-loop": "error",
-  "ts-data-forge/prefer-is-record-and-has-key": "error",
-  "ts-data-forge/prefer-num-safe-parse-int": "error",
-  "ts-data-forge/prefer-num-safe-parse-float": "error",
-  "ts-data-forge/no-side-effect-import": "error",
-  "ts-data-forge/no-unnecessary-type-guard": "error",
-  "ts-data-forge/prefer-comparison-over-nullish-guard": "error",
-  "ts-data-forge/prefer-obj-over-entries-round-trip": "error"
+    'ts-data-forge/prefer-canonical-array-slicing': 'error',
+    'ts-data-forge/prefer-canonical-length-cast': 'error',
+    'ts-data-forge/prefer-canonical-length-guard': 'error',
+    'ts-data-forge/prefer-arr-is-array': 'error',
+    'ts-data-forge/prefer-arr-scan': 'error',
+    'ts-data-forge/prefer-arr-sum': 'error',
+    'ts-data-forge/prefer-as-int': 'error',
+    'ts-data-forge/prefer-is-non-null-object': 'error',
+    'ts-data-forge/prefer-range-for-loop': 'error',
+    'ts-data-forge/prefer-is-record-and-has-key': 'error',
+    'ts-data-forge/prefer-num-safe-parse-int': 'error',
+    'ts-data-forge/prefer-num-safe-parse-float': 'error',
+    'ts-data-forge/no-side-effect-import': 'error',
+    'ts-data-forge/no-unnecessary-type-guard': 'error',
+    'ts-data-forge/prefer-comparison-over-nullish-guard': 'error',
+    'ts-data-forge/prefer-obj-over-entries-round-trip': 'error',
 };
 const recommendedConfig = {
-  name: "ts-data-forge/recommended",
-  plugins: {
-    // Resolved lazily so that this config registers the *same* object that
-    // `eslintPluginTsDataForge` 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-data-forge': eslintPluginTsDataForge }` entry would hit
-    // if the preset embedded a separate copy of the plugin.
-    get "ts-data-forge"() {
-      return eslintPluginTsDataForge;
-    }
-  },
-  rules: recommendedRules
-};
-const eslintPluginTsDataForge = {
-  meta: {
-    name: "eslint-plugin-ts-data-forge"
-  },
-  rules: tsDataForgeRules,
-  configs: {
-    /** Enables every rule of this plugin at `error`. */
-    recommended: recommendedConfig
-  }
+    name: 'ts-data-forge/recommended',
+    plugins: {
+
+
+
+
+
+
+        get 'ts-data-forge'() {
+            return eslintPluginTsDataForge;
+        },
+    },
+    rules: recommendedRules,
 };
+export const eslintPluginTsDataForge = {
+    meta: {
+        name: 'eslint-plugin-ts-data-forge',
+    },
+    rules: tsDataForgeRules,
+    configs: {
 
-export { eslintPluginTsDataForge };
-//# sourceMappingURL=plugin.mjs.map
+        recommended: recommendedConfig,
+    },
+};
+//# sourceMappingURL=plugin.mjs.map

package/dist/plugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.mjs","sources":["../src/plugin.mts"],"sourcesContent":["import { type ReadonlyRecord } from 'ts-type-forge';\nimport { tsDataForgeRules } 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 tsDataForgeRules}, so adding\n * a rule without listing it here fails to type-check.\n */\nconst recommendedRules = {\n  'ts-data-forge/prefer-canonical-array-slicing': 'error',\n  'ts-data-forge/prefer-canonical-length-cast': 'error',\n  'ts-data-forge/prefer-canonical-length-guard': 'error',\n  'ts-data-forge/prefer-arr-is-array': 'error',\n  'ts-data-forge/prefer-arr-sum': 'error',\n  'ts-data-forge/prefer-as-int': 'error',\n  'ts-data-forge/prefer-is-non-null-object': 'error',\n  'ts-data-forge/prefer-range-for-loop': 'error',\n  'ts-data-forge/prefer-is-record-and-has-key': 'error',\n  'ts-data-forge/prefer-num-safe-parse-int': 'error',\n  'ts-data-forge/prefer-num-safe-parse-float': 'error',\n  'ts-data-forge/no-side-effect-import': 'error',\n  'ts-data-forge/no-unnecessary-type-guard': 'error',\n  'ts-data-forge/prefer-comparison-over-nullish-guard': 'error',\n  'ts-data-forge/prefer-obj-over-entries-round-trip': 'error',\n} as const satisfies ReadonlyRecord<\n  `ts-data-forge/${keyof typeof tsDataForgeRules}`,\n  'error'\n>;\n\nconst recommendedConfig = {\n  name: 'ts-data-forge/recommended',\n  plugins: {\n    // Resolved lazily so that this config registers the *same* object that\n    // `eslintPluginTsDataForge` 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-data-forge': eslintPluginTsDataForge }` entry would hit\n    // if the preset embedded a separate copy of the plugin.\n    get 'ts-data-forge'(): ESLintPlugin {\n      return eslintPluginTsDataForge;\n    },\n  },\n  rules: recommendedRules,\n} as const satisfies ESLintFlatConfig;\n\nexport const eslintPluginTsDataForge = {\n  meta: {\n    name: 'eslint-plugin-ts-data-forge',\n  },\n  rules: tsDataForgeRules,\n  configs: {\n    /** Enables every rule of this plugin at `error`. */\n    recommended: recommendedConfig,\n  },\n} as const satisfies ESLintPlugin;\n"],"names":[],"mappings":";;AAUA,MAAM,gBAAA,GAAmB;AAAA,EACvB,8CAAA,EAAgD,OAAA;AAAA,EAChD,4CAAA,EAA8C,OAAA;AAAA,EAC9C,6CAAA,EAA+C,OAAA;AAAA,EAC/C,mCAAA,EAAqC,OAAA;AAAA,EACrC,8BAAA,EAAgC,OAAA;AAAA,EAChC,6BAAA,EAA+B,OAAA;AAAA,EAC/B,yCAAA,EAA2C,OAAA;AAAA,EAC3C,qCAAA,EAAuC,OAAA;AAAA,EACvC,4CAAA,EAA8C,OAAA;AAAA,EAC9C,yCAAA,EAA2C,OAAA;AAAA,EAC3C,2CAAA,EAA6C,OAAA;AAAA,EAC7C,qCAAA,EAAuC,OAAA;AAAA,EACvC,yCAAA,EAA2C,OAAA;AAAA,EAC3C,oDAAA,EAAsD,OAAA;AAAA,EACtD,kDAAA,EAAoD;AACtD,CAAA;AAKA,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","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAGrD;;;;;GAKG;AACH,MAAM,gBAAgB,GAAG;IACvB,8CAA8C,EAAE,OAAO;IACvD,4CAA4C,EAAE,OAAO;IACrD,6CAA6C,EAAE,OAAO;IACtD,mCAAmC,EAAE,OAAO;IAC5C,+BAA+B,EAAE,OAAO;IACxC,8BAA8B,EAAE,OAAO;IACvC,6BAA6B,EAAE,OAAO;IACtC,yCAAyC,EAAE,OAAO;IAClD,qCAAqC,EAAE,OAAO;IAC9C,4CAA4C,EAAE,OAAO;IACrD,yCAAyC,EAAE,OAAO;IAClD,2CAA2C,EAAE,OAAO;IACpD,qCAAqC,EAAE,OAAO;IAC9C,yCAAyC,EAAE,OAAO;IAClD,oDAAoD,EAAE,OAAO;IAC7D,kDAAkD,EAAE,OAAO;CAI5D,CAAC;AAEF,MAAM,iBAAiB,GAAG;IACxB,IAAI,EAAE,2BAA2B;IACjC,OAAO,EAAE;QACP,uEAAuE;QACvE,yEAAyE;QACzE,wEAAwE;QACxE,mDAAmD;QACnD,0EAA0E;QAC1E,wDAAwD;QACxD,IAAI,eAAe;YACjB,OAAO,uBAAuB,CAAC;QACjC,CAAC;KACF;IACD,KAAK,EAAE,gBAAgB;CACY,CAAC;AAEtC,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,IAAI,EAAE;QACJ,IAAI,EAAE,6BAA6B;KACpC;IACD,KAAK,EAAE,gBAAgB;IACvB,OAAO,EAAE;QACP,oDAAoD;QACpD,WAAW,EAAE,iBAAiB;KAC/B;CAC8B,CAAC"}

package/dist/rule-types.d.mts

@@ -64,6 +64,20 @@ declare namespace PreferCanonicalLengthCast {
 declare namespace PreferArrIsArray {
     type RuleEntry = Linter.StringSeverity;
 }
+/**
+ * @description Report an accumulated value rebuilt from scratch for every element — `xs.map((_, i) => f(...xs.slice(0, i + 1)))`, or a `reduce` that spreads its accumulator into a new array — and point at `Arr.scan` from ts-data-forge, which does the same in one pass
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferArrScan {
+    type RuleEntry = Linter.StringSeverity;
+}
 /**
  * @description Replace `xs.reduce((a, b) => a + b, 0)` with `Arr.sum(xs)` or `Arr.sumBy(xs, fn)` from ts-data-forge.
  *
@@ -245,6 +259,7 @@ export type EslintTsDataForgeRules = Readonly<{
     'ts-data-forge/prefer-canonical-length-guard': PreferCanonicalLengthGuard.RuleEntry;
     'ts-data-forge/prefer-canonical-length-cast': PreferCanonicalLengthCast.RuleEntry;
     'ts-data-forge/prefer-arr-is-array': PreferArrIsArray.RuleEntry;
+    'ts-data-forge/prefer-arr-scan': PreferArrScan.RuleEntry;
     'ts-data-forge/prefer-arr-sum': PreferArrSum.RuleEntry;
     'ts-data-forge/prefer-as-int': PreferAsInt.RuleEntry;
     'ts-data-forge/prefer-is-non-null-object': PreferIsNonNullObject.RuleEntry;

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

@@ -1 +1 @@
-{"version":3,"file":"rule-types.d.mts","sourceRoot":"","sources":["../src/rule-types.mts"],"names":[],"mappings":"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"}
+{"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;AAErC,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,2BAA2B,CAAC;IACpC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,0BAA0B,CAAC;IACnC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,yBAAyB,CAAC;IAClC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,gBAAgB,CAAC;IACzB,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,aAAa,CAAC;IACtB,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,YAAY,CAAC;IACrB,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,WAAW,CAAC;IACpB,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,qBAAqB,CAAC;IAC9B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,kBAAkB,CAAC;IAC3B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,uBAAuB,CAAC;IAChC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,qBAAqB,CAAC;IAC9B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,uBAAuB,CAAC;IAChC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,kBAAkB,CAAC;IAC3B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,sBAAsB,CAAC;IAC/B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,KAAY,OAAO,GAAG,WAAW,CAC/B,aAAa,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAC9C,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,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,6BAA6B,CAAC;IACtC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,8CAA8C,EAAE,2BAA2B,CAAC,SAAS,CAAC;IACtF,6CAA6C,EAAE,0BAA0B,CAAC,SAAS,CAAC;IACpF,4CAA4C,EAAE,yBAAyB,CAAC,SAAS,CAAC;IAClF,mCAAmC,EAAE,gBAAgB,CAAC,SAAS,CAAC;IAChE,+BAA+B,EAAE,aAAa,CAAC,SAAS,CAAC;IACzD,8BAA8B,EAAE,YAAY,CAAC,SAAS,CAAC;IACvD,6BAA6B,EAAE,WAAW,CAAC,SAAS,CAAC;IACrD,yCAAyC,EAAE,qBAAqB,CAAC,SAAS,CAAC;IAC3E,qCAAqC,EAAE,kBAAkB,CAAC,SAAS,CAAC;IACpE,4CAA4C,EAAE,uBAAuB,CAAC,SAAS,CAAC;IAChF,yCAAyC,EAAE,qBAAqB,CAAC,SAAS,CAAC;IAC3E,2CAA2C,EAAE,uBAAuB,CAAC,SAAS,CAAC;IAC/E,qCAAqC,EAAE,kBAAkB,CAAC,SAAS,CAAC;IACpE,yCAAyC,EAAE,sBAAsB,CAAC,SAAS,CAAC;IAC5E,oDAAoD,EAAE,gCAAgC,CAAC,SAAS,CAAC;IACjG,kDAAkD,EAAE,6BAA6B,CAAC,SAAS,CAAC;CAC7F,CAAC,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,yCAAyC,EAAE,sBAAsB,CAAC,OAAO,CAAC;CAC3E,CAAC,CAAC"}

package/dist/rule-types.mjs

@@ -1,2 +1,6 @@
-import 'ts-data-forge';
-//# sourceMappingURL=rule-types.mjs.map
+
+
+
+
+
+//# sourceMappingURL=rule-types.mjs.map

package/dist/rule-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rule-types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"rule-types.mjs","sourceRoot":"","sources":["../src/rule-types.mts"],"names":[],"mappings":"AAAA,oBAAoB;AAOpB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAyT3C,8EAA8E;AAC9E,8DAA8D;AAC9D,UAAU,CAGR,GAAG,CAAC,CAAC"}

package/dist/rules/ast-utils.mjs

@@ -1,54 +1,111 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-
-const isIntegerLiteral = (node) => node.type === AST_NODE_TYPES.Literal && typeof node.value === "number" && Number.isInteger(node.value);
-const isIntegerLiteralOrConstant = (node, sourceCode) => {
-  if (isIntegerLiteral(node)) return true;
-  if (node.type !== AST_NODE_TYPES.Identifier) return false;
-  const scope = sourceCode.getScope(node);
-  const variable = findVariable(scope, node.name);
-  if (variable === void 0) return false;
-  if (variable.defs.length !== 1) return false;
-  const def = variable.defs[0];
-  if (def === void 0) return false;
-  if (!isVariableDefinition(def)) return false;
-  if (def.parent.kind !== "const") return false;
-  if (def.node.init == null) return false;
-  if (def.node.id.typeAnnotation !== void 0) return false;
-  return isIntegerLiteral(def.node.init);
-};
-const isLengthAccess = (node) => node.type === AST_NODE_TYPES.MemberExpression && node.property.type === AST_NODE_TYPES.Identifier && node.property.name === "length";
-const parseLengthComparison = (node, sourceCode) => {
-  if (node.type !== AST_NODE_TYPES.BinaryExpression || node.operator !== ">=" && node.operator !== "<=") {
-    return void 0;
-  }
-  const { left, right, operator } = node;
-  const lengthOnLeft = isLengthAccess(left);
-  const lengthSide = lengthOnLeft ? left : right;
-  const boundSide = lengthOnLeft ? right : left;
-  if (!isLengthAccess(lengthSide)) return void 0;
-  if (!isIntegerLiteralOrConstant(boundSide, sourceCode)) return void 0;
-  const kind = (lengthOnLeft ? operator === ">=" : operator === "<=") ? "min" : "max";
-  return { array: lengthSide.object, bound: boundSide, kind };
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+const isIntegerLiteral = (node) => node.type === AST_NODE_TYPES.Literal &&
+    typeof node.value === 'number' &&
+    Number.isInteger(node.value);
+export const isIntegerLiteralOrConstant = (node, 
+
+sourceCode) => {
+
+    if (isIntegerLiteral(node))
+        return true;
+
+    if (node.type !== AST_NODE_TYPES.Identifier)
+        return false;
+
+    const scope = sourceCode.getScope(node);
+    const variable = findVariable(scope, node.name);
+    if (variable === undefined)
+        return false;
+
+    if (variable.defs.length !== 1)
+        return false;
+    const def = variable.defs[0];
+    if (def === undefined)
+        return false;
+    if (!isVariableDefinition(def))
+        return false;
+    if (def.parent.kind !== 'const')
+        return false;
+    if (def.node.init == null)
+        return false;
+
+
+    if (def.node.id.typeAnnotation !== undefined)
+        return false;
+    return isIntegerLiteral(def.node.init);
 };
-const isPartOfBoundedLengthCheck = (node, sourceCode) => {
-  const { parent } = node;
-  if (parent.type !== AST_NODE_TYPES.LogicalExpression || parent.operator !== "&&") {
-    return false;
-  }
-  const self = parseLengthComparison(node, sourceCode);
-  if (self === void 0) return false;
-  const sibling = parent.left === node ? parent.right : parent.left;
-  const other = parseLengthComparison(sibling, sourceCode);
-  if (other === void 0) return false;
-  return self.kind !== other.kind && sourceCode.getText(self.array) === sourceCode.getText(other.array);
+export const isLengthAccess = (node) => node.type === AST_NODE_TYPES.MemberExpression &&
+    node.property.type === AST_NODE_TYPES.Identifier &&
+    node.property.name === 'length';
+
+
+
+
+
+
+
+
+
+export const parseLengthComparison = (
+
+node, 
+
+sourceCode) => {
+    if (node.type !== AST_NODE_TYPES.BinaryExpression ||
+        (node.operator !== '>=' && node.operator !== '<=')) {
+        return undefined;
+    }
+    const { left, right, operator } = node;
+    const lengthOnLeft = isLengthAccess(left);
+    const lengthSide = lengthOnLeft ? left : right;
+    const boundSide = lengthOnLeft ? right : left;
+    if (!isLengthAccess(lengthSide))
+        return undefined;
+    if (!isIntegerLiteralOrConstant(boundSide, sourceCode))
+        return undefined;
+    const kind = (lengthOnLeft ? operator === '>=' : operator === '<=')
+        ? 'min'
+        : 'max';
+    return { array: lengthSide.object, bound: boundSide, kind };
 };
-const isVariableDefinition = (def) => def.type === "Variable";
-const findVariable = (scope, name) => {
-  const variable = scope.set.get(name);
-  if (variable !== void 0) return variable;
-  if (scope.upper === null) return void 0;
-  return findVariable(scope.upper, name);
+
+
+
+
+
+
+
+export const isPartOfBoundedLengthCheck = (
+
+node, 
+
+sourceCode) => {
+    const { parent } = node;
+    if (parent.type !== AST_NODE_TYPES.LogicalExpression ||
+        parent.operator !== '&&') {
+        return false;
+    }
+    const self = parseLengthComparison(node, sourceCode);
+    if (self === undefined)
+        return false;
+    const sibling = parent.left === node ? parent.right : parent.left;
+    const other = parseLengthComparison(sibling, sourceCode);
+    if (other === undefined)
+        return false;
+    return (self.kind !== other.kind &&
+        sourceCode.getText(self.array) === sourceCode.getText(other.array));
 };
+const isVariableDefinition = (
+
+def) => def.type === 'Variable';
+const findVariable = (
 
-export { isIntegerLiteralOrConstant, isLengthAccess, isPartOfBoundedLengthCheck, parseLengthComparison };
-//# sourceMappingURL=ast-utils.mjs.map
+scope, name) => {
+    const variable = scope.set.get(name);
+    if (variable !== undefined)
+        return variable;
+    if (scope.upper === null)
+        return undefined;
+    return findVariable(scope.upper, name);
+};
+//# sourceMappingURL=ast-utils.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"ast-utils.mjs","sources":["../../src/rules/ast-utils.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { type DeepReadonly } from 'ts-type-forge';\n\nconst isIntegerLiteral = (node: DeepReadonly<TSESTree.Expression>): boolean =>\n  node.type === AST_NODE_TYPES.Literal &&\n  typeof node.value === 'number' &&\n  Number.isInteger(node.value);\n\nexport const isIntegerLiteralOrConstant = (\n  node: DeepReadonly<TSESTree.Expression>,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  sourceCode: TSESLint.SourceCode,\n): boolean => {\n  // Direct integer literal (e.g., 3)\n  if (isIntegerLiteral(node)) return true;\n\n  // Identifier referencing a const variable initialized with an integer literal\n  if (node.type !== AST_NODE_TYPES.Identifier) return false;\n\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  const scope = sourceCode.getScope(node as TSESTree.Node);\n\n  const variable = findVariable(scope, node.name);\n\n  if (variable === undefined) return false;\n\n  // Must have exactly one definition (const)\n  if (variable.defs.length !== 1) return false;\n\n  const def = variable.defs[0];\n\n  if (def === undefined) return false;\n\n  if (!isVariableDefinition(def)) return false;\n\n  if (def.parent.kind !== 'const') return false;\n\n  if (def.node.init == null) return false;\n\n  // Reject if there is an explicit type annotation (e.g., `const n: number = 3`)\n  // because the literal type is widened and type guard cannot narrow it.\n  if (def.node.id.typeAnnotation !== undefined) return false;\n\n  return isIntegerLiteral(def.node.init);\n};\n\nexport const isLengthAccess = (\n  node: DeepReadonly<TSESTree.Expression>,\n): node is TSESTree.MemberExpression =>\n  node.type === AST_NODE_TYPES.MemberExpression &&\n  node.property.type === AST_NODE_TYPES.Identifier &&\n  node.property.name === 'length';\n\ntype LengthComparison = Readonly<{\n  array: TSESTree.Expression;\n  bound: TSESTree.Expression;\n  kind: 'max' | 'min';\n}>;\n\n/**\n * Parses a `<array>.length <op> <bound>` comparison (in either operand order)\n * into its array expression, integer-literal/`const` `bound`, and whether it is\n * a lower (`min`) or upper (`max`) length bound. Returns `undefined` for\n * anything else.\n *\n * - `xs.length >= n` / `n <= xs.length` → `min`\n * - `xs.length <= n` / `n >= xs.length` → `max`\n */\nexport const parseLengthComparison = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  node: TSESTree.Expression,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  sourceCode: TSESLint.SourceCode,\n): LengthComparison | undefined => {\n  if (\n    node.type !== AST_NODE_TYPES.BinaryExpression ||\n    (node.operator !== '>=' && node.operator !== '<=')\n  ) {\n    return undefined;\n  }\n\n  const { left, right, operator } = node;\n\n  const lengthOnLeft = isLengthAccess(left);\n\n  const lengthSide = lengthOnLeft ? left : right;\n\n  const boundSide = lengthOnLeft ? right : left;\n\n  if (!isLengthAccess(lengthSide)) return undefined;\n\n  if (!isIntegerLiteralOrConstant(boundSide, sourceCode)) return undefined;\n\n  const kind: LengthComparison['kind'] = (\n    lengthOnLeft ? operator === '>=' : operator === '<='\n  )\n    ? 'min'\n    : 'max';\n\n  return { array: lengthSide.object, bound: boundSide, kind };\n};\n\n/**\n * `true` when `node` is one operand of an `a && b` whose other operand is the\n * complementary length bound (`min` vs `max`) on the same array — i.e. the two\n * together form the `Arr.isBoundedLengthArray` pattern handled by\n * `prefer-arr-is-bounded-length-array`. The single-bound rules skip such\n * operands so the bounded rule rewrites the whole `&&` instead of the parts.\n */\nexport const isPartOfBoundedLengthCheck = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  node: TSESTree.BinaryExpression,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  sourceCode: TSESLint.SourceCode,\n): boolean => {\n  const { parent } = node;\n\n  if (\n    parent.type !== AST_NODE_TYPES.LogicalExpression ||\n    parent.operator !== '&&'\n  ) {\n    return false;\n  }\n\n  const self = parseLengthComparison(node, sourceCode);\n\n  if (self === undefined) return false;\n\n  const sibling = parent.left === node ? parent.right : parent.left;\n\n  const other = parseLengthComparison(sibling, sourceCode);\n\n  if (other === undefined) return false;\n\n  return (\n    self.kind !== other.kind &&\n    sourceCode.getText(self.array) === sourceCode.getText(other.array)\n  );\n};\n\ntype VariableDefinition = Readonly<{\n  type: string;\n  parent: TSESTree.VariableDeclaration;\n  node: TSESTree.VariableDeclarator;\n}>;\n\nconst isVariableDefinition = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  def: TSESLint.Scope.Definition,\n): def is TSESLint.Scope.Definition & VariableDefinition =>\n  (def.type as string) === 'Variable';\n\nconst findVariable = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  scope: TSESLint.Scope.Scope,\n  name: string,\n): TSESLint.Scope.Variable | undefined => {\n  const variable = scope.set.get(name);\n\n  if (variable !== undefined) return variable;\n\n  if (scope.upper === null) return undefined;\n\n  return findVariable(scope.upper, name);\n};\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"ast-utils.mjs","sourceRoot":"","sources":["../../src/rules/ast-utils.mts"],"names":[],"mappings":"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"}

package/dist/rules/branded-number-types.mjs

@@ -1,40 +1,44 @@
+
+
+
 const brandedNumberTypes = [
-  "FiniteNumber",
-  "Int",
-  "Int16",
-  "Int32",
-  "Int8",
-  "NegativeFiniteNumber",
-  "NegativeInt",
-  "NegativeSafeInt",
-  "NonNegativeFiniteNumber",
-  "NonNegativeInt16",
-  "NonNegativeInt32",
-  "NonPositiveFiniteNumber",
-  "NonPositiveInt",
-  "NonPositiveSafeInt",
-  "NonZeroFiniteNumber",
-  "NonZeroInt",
-  "NonZeroInt16",
-  "NonZeroInt32",
-  "NonZeroSafeInt",
-  "NonZeroUint16",
-  "NonZeroUint32",
-  "PositiveFiniteNumber",
-  "PositiveInt",
-  "PositiveInt16",
-  "PositiveInt32",
-  "PositiveSafeInt",
-  "PositiveUint16",
-  "PositiveUint32",
-  "SafeInt",
-  "SafeUint",
-  "Uint",
-  "Uint16",
-  "Uint32",
-  "Uint8"
+    'FiniteNumber',
+    'Int',
+    'Int16',
+    'Int32',
+    'Int8',
+    'NegativeFiniteNumber',
+    'NegativeInt',
+    'NegativeSafeInt',
+    'NonNegativeFiniteNumber',
+    'NonNegativeInt16',
+    'NonNegativeInt32',
+    'NonPositiveFiniteNumber',
+    'NonPositiveInt',
+    'NonPositiveSafeInt',
+    'NonZeroFiniteNumber',
+    'NonZeroInt',
+    'NonZeroInt16',
+    'NonZeroInt32',
+    'NonZeroSafeInt',
+    'NonZeroUint16',
+    'NonZeroUint32',
+    'PositiveFiniteNumber',
+    'PositiveInt',
+    'PositiveInt16',
+    'PositiveInt32',
+    'PositiveSafeInt',
+    'PositiveUint16',
+    'PositiveUint32',
+    'SafeInt',
+    'SafeUint',
+    'Uint',
+    'Uint16',
+    'Uint32',
+    'Uint8',
 ];
-const brandedNumberTypeNameToFunctionName = new Map(brandedNumberTypes.map((t) => [t, `as${t}`]));
 
-export { brandedNumberTypeNameToFunctionName };
-//# sourceMappingURL=branded-number-types.mjs.map
+
+
+export const brandedNumberTypeNameToFunctionName = new Map(brandedNumberTypes.map((t) => [t, `as${t}`]));
+//# sourceMappingURL=branded-number-types.mjs.map

package/dist/rules/branded-number-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"branded-number-types.mjs","sources":["../../src/rules/branded-number-types.mts"],"sourcesContent":["// Keep this list in sync with the `as<Type>` cast functions exported by\n// ts-data-forge. `pnpm run check:branded-number-types` (also run during the\n// build) fails if a branded number type is missing here or no longer exists.\nconst brandedNumberTypes = [\n  'FiniteNumber',\n  'Int',\n  'Int16',\n  'Int32',\n  'Int8',\n  'NegativeFiniteNumber',\n  'NegativeInt',\n  'NegativeSafeInt',\n  'NonNegativeFiniteNumber',\n  'NonNegativeInt16',\n  'NonNegativeInt32',\n  'NonPositiveFiniteNumber',\n  'NonPositiveInt',\n  'NonPositiveSafeInt',\n  'NonZeroFiniteNumber',\n  'NonZeroInt',\n  'NonZeroInt16',\n  'NonZeroInt32',\n  'NonZeroSafeInt',\n  'NonZeroUint16',\n  'NonZeroUint32',\n  'PositiveFiniteNumber',\n  'PositiveInt',\n  'PositiveInt16',\n  'PositiveInt32',\n  'PositiveSafeInt',\n  'PositiveUint16',\n  'PositiveUint32',\n  'SafeInt',\n  'SafeUint',\n  'Uint',\n  'Uint16',\n  'Uint32',\n  'Uint8',\n] as const;\n\n/**\n * Branded number types from ts-data-forge and their corresponding as* functions\n */\nexport const brandedNumberTypeNameToFunctionName: ReadonlyMap<\n  string,\n  `as${string}`\n> = new Map(brandedNumberTypes.map((t) => [t, `as${t}`]));\n"],"names":[],"mappings":"AAGA,MAAM,kBAAA,GAAqB;AAAA,EACzB,cAAA;AAAA,EACA,KAAA;AAAA,EACA,OAAA;AAAA,EACA,OAAA;AAAA,EACA,MAAA;AAAA,EACA,sBAAA;AAAA,EACA,aAAA;AAAA,EACA,iBAAA;AAAA,EACA,yBAAA;AAAA,EACA,kBAAA;AAAA,EACA,kBAAA;AAAA,EACA,yBAAA;AAAA,EACA,gBAAA;AAAA,EACA,oBAAA;AAAA,EACA,qBAAA;AAAA,EACA,YAAA;AAAA,EACA,cAAA;AAAA,EACA,cAAA;AAAA,EACA,gBAAA;AAAA,EACA,eAAA;AAAA,EACA,eAAA;AAAA,EACA,sBAAA;AAAA,EACA,aAAA;AAAA,EACA,eAAA;AAAA,EACA,eAAA;AAAA,EACA,iBAAA;AAAA,EACA,gBAAA;AAAA,EACA,gBAAA;AAAA,EACA,SAAA;AAAA,EACA,UAAA;AAAA,EACA,MAAA;AAAA,EACA,QAAA;AAAA,EACA,QAAA;AAAA,EACA;AACF,CAAA;AAKO,MAAM,mCAAA,GAGT,IAAI,GAAA,CAAI,kBAAA,CAAmB,GAAA,CAAI,CAAC,CAAA,KAAM,CAAC,CAAA,EAAG,CAAA,EAAA,EAAK,CAAC,CAAA,CAAE,CAAC,CAAC;;"}
+{"version":3,"file":"branded-number-types.mjs","sourceRoot":"","sources":["../../src/rules/branded-number-types.mts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,4EAA4E;AAC5E,6EAA6E;AAC7E,MAAM,kBAAkB,GAAG;IACzB,cAAc;IACd,KAAK;IACL,OAAO;IACP,OAAO;IACP,MAAM;IACN,sBAAsB;IACtB,aAAa;IACb,iBAAiB;IACjB,yBAAyB;IACzB,kBAAkB;IAClB,kBAAkB;IAClB,yBAAyB;IACzB,gBAAgB;IAChB,oBAAoB;IACpB,qBAAqB;IACrB,YAAY;IACZ,cAAc;IACd,cAAc;IACd,gBAAgB;IAChB,eAAe;IACf,eAAe;IACf,sBAAsB;IACtB,aAAa;IACb,eAAe;IACf,eAAe;IACf,iBAAiB;IACjB,gBAAgB;IAChB,gBAAgB;IAChB,SAAS;IACT,UAAU;IACV,MAAM;IACN,QAAQ;IACR,QAAQ;IACR,OAAO;CACC,CAAC;AAEX;;GAEG;AACH,MAAM,CAAC,MAAM,mCAAmC,GAG5C,IAAI,GAAG,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC"}

package/dist/rules/constants.mjs

@@ -1,4 +1,2 @@
-const TS_DATA_FORGE_MODULE = "ts-data-forge";
-
-export { TS_DATA_FORGE_MODULE };
-//# sourceMappingURL=constants.mjs.map
+export const TS_DATA_FORGE_MODULE = 'ts-data-forge';
+//# 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_DATA_FORGE_MODULE = 'ts-data-forge';\n"],"names":[],"mappings":"AAAO,MAAM,oBAAA,GAAuB;;"}
+{"version":3,"file":"constants.mjs","sourceRoot":"","sources":["../../src/rules/constants.mts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,oBAAoB,GAAG,eAAe,CAAC"}