eslint-plugin-ts-data-forge 0.1.0 → 0.1.1

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+export { eslintPluginTsDataForge } from './plugin.mjs';
+export type { EslintTsDataForgeRules, EslintTsDataForgeRulesOption, } from './rule-types.mjs';
+export { tsDataForgeRules } from './rules/index.mjs';
+export { type ESLintPlugin } from './types.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AACvD,YAAY,EACV,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.mjs

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

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/plugin.d.mts

@@ -0,0 +1,3 @@
+import { type ESLintPlugin } from './types.mjs';
+export declare const eslintPluginTsDataForge: ESLintPlugin;
+//# sourceMappingURL=plugin.d.mts.map

package/dist/plugin.d.mts.map

@@ -0,0 +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,uBAAuB,EAAE,YAK5B,CAAC"}

package/dist/plugin.mjs

@@ -0,0 +1,11 @@
+import { tsDataForgeRules } from './rules/rules.mjs';
+
+const eslintPluginTsDataForge = {
+  meta: {
+    name: "eslint-plugin-ts-data-forge"
+  },
+  rules: tsDataForgeRules
+};
+
+export { eslintPluginTsDataForge };
+//# sourceMappingURL=plugin.mjs.map

package/dist/plugin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.mjs","sources":["../src/plugin.mts"],"sourcesContent":["import { tsDataForgeRules } from './rules/index.mjs';\nimport { type ESLintPlugin } from './types.mjs';\n\nexport const eslintPluginTsDataForge: ESLintPlugin = {\n  meta: {\n    name: 'eslint-plugin-ts-data-forge',\n  },\n  rules: tsDataForgeRules,\n} as const;\n"],"names":[],"mappings":";;AAGO,MAAM,uBAAA,GAAwC;AAAA,EACnD,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM;AAAA,GACR;AAAA,EACA,KAAA,EAAO;AACT;;;;"}

package/dist/rule-types.d.mts

@@ -0,0 +1,279 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+import { type Linter } from 'eslint';
+import { type tsDataForgeRules } from './rules/index.mjs';
+type SpreadOptionsIfIsArray<T extends readonly [Linter.StringSeverity, unknown]> = T[1] extends readonly unknown[] ? readonly [Linter.StringSeverity, ...T[1]] : T;
+/**
+ * Extracts the options tuple type of a rule from its TypeScript
+ * implementation, so that option types stay in sync with the rule source
+ * without converting `meta.schema` (JSON Schema) back into TypeScript types.
+ */
+type RuleOptionsOf<Name extends keyof typeof tsDataForgeRules> = (typeof tsDataForgeRules)[Name] extends TSESLint.RuleModule<infer _MessageIds extends string, infer Options extends readonly unknown[]> ? Options : never;
+/**
+ * @description Unify non-mutating array element addition/removal patterns (`slice` / `toSpliced` / `filter` / `concat` / spread) into the corresponding ts-data-forge functions: `Arr.tail`, `Arr.skip`, `Arr.take`, `Arr.butLast`, `Arr.skipLast`, `Arr.takeLast`, `Arr.toUnshifted`, `Arr.toPushed`.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferCanonicalArraySlicing {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `xs.length >= n` with `Arr.isMinLengthArray(xs, n)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferArrIsMinLengthArray {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `xs.length <= n` with `Arr.isMaxLengthArray(xs, n)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferArrIsMaxLengthArray {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `xs.length >= min && xs.length <= max` with `Arr.isBoundedLengthArray(xs, min, max)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferArrIsBoundedLengthArray {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `xs.length === n` with `Arr.isFixedLengthArray(xs, n)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferArrIsFixedLengthArray {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `Array.isArray` with `Arr.isArray` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferArrIsArray {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `xs.length > 0` with `Arr.isNonEmpty(xs)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferArrIsNonEmpty {
+    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.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferArrSum {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace branded number type assertions (e.g., `as Int`) with corresponding functions (e.g., `asInt()`) from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferAsInt {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `typeof u === "object" && u !== null` with `isNonNullObject(u)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferIsNonNullObject {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `for (let i = begin; i < end; ++i)` with `for (const i of range(begin, end))` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferRangeForLoop {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `Object.hasOwn(obj, key)` or `key in obj` with `isRecord(obj) && hasKey(obj, key)` from ts-data-forge
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferIsRecordAndHasKey {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `parseInt(x, 10)` with `Result.unwrapOkOr(Num.safeParseInt(x), Number.NaN)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferNumSafeParseInt {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Replace `parseFloat(x)`, `Number.parseFloat(x)`, or `Number(x)` (when x is a string) with `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` from ts-data-forge.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferNumSafeParseFloat {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * @description Detect ts-data-forge type guard calls that perform no narrowing (the argument type already satisfies, or can never satisfy, the guard).
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace NoUnnecessaryTypeGuard {
+    /**
+     * ### schema
+     *
+     * ```json
+     * [
+     *   {
+     *     "type": "object",
+     *     "properties": {
+     *       "ignore": {
+     *         "type": "array",
+     *         "items": {
+     *           "type": "string"
+     *         },
+     *         "description": "Names of ts-data-forge guard functions to skip checking."
+     *       }
+     *     },
+     *     "additionalProperties": false
+     *   }
+     * ]
+     * ```
+     */
+    type Options = NonNullable<RuleOptionsOf<'no-unnecessary-type-guard'>[0]>;
+    type RuleEntry = 'off' | Linter.Severity | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>;
+}
+/**
+ * @description Prefer a direct `=== null` / `!== undefined` comparison over calling `isNull`, `isNotNull`, `isUndefined`, or `isNotUndefined` with an explicit argument (those guards are intended for point-free use such as `xs.filter(isNotUndefined)`).
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferComparisonOverNullishGuard {
+    type RuleEntry = Linter.StringSeverity;
+}
+export type EslintTsDataForgeRules = Readonly<{
+    'ts-data-forge/prefer-canonical-array-slicing': PreferCanonicalArraySlicing.RuleEntry;
+    'ts-data-forge/prefer-arr-is-min-length-array': PreferArrIsMinLengthArray.RuleEntry;
+    'ts-data-forge/prefer-arr-is-max-length-array': PreferArrIsMaxLengthArray.RuleEntry;
+    'ts-data-forge/prefer-arr-is-bounded-length-array': PreferArrIsBoundedLengthArray.RuleEntry;
+    'ts-data-forge/prefer-arr-is-fixed-length-array': PreferArrIsFixedLengthArray.RuleEntry;
+    'ts-data-forge/prefer-arr-is-array': PreferArrIsArray.RuleEntry;
+    'ts-data-forge/prefer-arr-is-non-empty': PreferArrIsNonEmpty.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;
+    'ts-data-forge/prefer-range-for-loop': PreferRangeForLoop.RuleEntry;
+    'ts-data-forge/prefer-is-record-and-has-key': PreferIsRecordAndHasKey.RuleEntry;
+    'ts-data-forge/prefer-num-safe-parse-int': PreferNumSafeParseInt.RuleEntry;
+    'ts-data-forge/prefer-num-safe-parse-float': PreferNumSafeParseFloat.RuleEntry;
+    'ts-data-forge/no-unnecessary-type-guard': NoUnnecessaryTypeGuard.RuleEntry;
+    'ts-data-forge/prefer-comparison-over-nullish-guard': PreferComparisonOverNullishGuard.RuleEntry;
+}>;
+export type EslintTsDataForgeRulesOption = Readonly<{
+    'ts-data-forge/no-unnecessary-type-guard': NoUnnecessaryTypeGuard.Options;
+}>;
+export {};
+//# sourceMappingURL=rule-types.d.mts.map

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

@@ -0,0 +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;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,yBAAyB,CAAC;IAClC,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,6BAA6B,CAAC;IACtC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,2BAA2B,CAAC;IACpC,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,mBAAmB,CAAC;IAC5B,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,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,MAAM,MAAM,sBAAsB,GAAG,QAAQ,CAAC;IAC5C,8CAA8C,EAAE,2BAA2B,CAAC,SAAS,CAAC;IACtF,8CAA8C,EAAE,yBAAyB,CAAC,SAAS,CAAC;IACpF,8CAA8C,EAAE,yBAAyB,CAAC,SAAS,CAAC;IACpF,kDAAkD,EAAE,6BAA6B,CAAC,SAAS,CAAC;IAC5F,gDAAgD,EAAE,2BAA2B,CAAC,SAAS,CAAC;IACxF,mCAAmC,EAAE,gBAAgB,CAAC,SAAS,CAAC;IAChE,uCAAuC,EAAE,mBAAmB,CAAC,SAAS,CAAC;IACvE,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,yCAAyC,EAAE,sBAAsB,CAAC,SAAS,CAAC;IAC5E,oDAAoD,EAAE,gCAAgC,CAAC,SAAS,CAAC;CAClG,CAAC,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,yCAAyC,EAAE,sBAAsB,CAAC,OAAO,CAAC;CAC3E,CAAC,CAAC"}

package/dist/rule-types.mjs

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

package/dist/rule-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

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

@@ -0,0 +1,29 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import { type DeepReadonly } from 'ts-type-forge';
+export declare const isIntegerLiteralOrConstant: (node: DeepReadonly<TSESTree.Expression>, sourceCode: TSESLint.SourceCode) => boolean;
+export declare const isLengthAccess: (node: DeepReadonly<TSESTree.Expression>) => node is TSESTree.MemberExpression;
+type LengthComparison = Readonly<{
+    array: TSESTree.Expression;
+    bound: TSESTree.Expression;
+    kind: 'max' | 'min';
+}>;
+/**
+ * Parses a `<array>.length <op> <bound>` comparison (in either operand order)
+ * into its array expression, integer-literal/`const` `bound`, and whether it is
+ * a lower (`min`) or upper (`max`) length bound. Returns `undefined` for
+ * anything else.
+ *
+ * - `xs.length >= n` / `n <= xs.length` → `min`
+ * - `xs.length <= n` / `n >= xs.length` → `max`
+ */
+export declare const parseLengthComparison: (node: TSESTree.Expression, sourceCode: TSESLint.SourceCode) => LengthComparison | undefined;
+/**
+ * `true` when `node` is one operand of an `a && b` whose other operand is the
+ * complementary length bound (`min` vs `max`) on the same array — i.e. the two
+ * together form the `Arr.isBoundedLengthArray` pattern handled by
+ * `prefer-arr-is-bounded-length-array`. The single-bound rules skip such
+ * operands so the bounded rule rewrites the whole `&&` instead of the parts.
+ */
+export declare const isPartOfBoundedLengthCheck: (node: TSESTree.BinaryExpression, sourceCode: TSESLint.SourceCode) => boolean;
+export {};
+//# sourceMappingURL=ast-utils.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ast-utils.d.mts","sourceRoot":"","sources":["../../src/rules/ast-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAOlD,eAAO,MAAM,0BAA0B,SAC/B,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,cAE3B,QAAQ,CAAC,UAAU,KAC9B,OAgCF,CAAC;AAEF,eAAO,MAAM,cAAc,SACnB,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,KACtC,IAAI,IAAI,QAAQ,CAAC,gBAGa,CAAC;AAElC,KAAK,gBAAgB,GAAG,QAAQ,CAAC;IAC/B,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC;IAC3B,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC;IAC3B,IAAI,EAAE,KAAK,GAAG,KAAK,CAAC;CACrB,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,SAE1B,QAAQ,CAAC,UAAU,cAEb,QAAQ,CAAC,UAAU,KAC9B,gBAAgB,GAAG,SA2BrB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,SAE/B,QAAQ,CAAC,gBAAgB,cAEnB,QAAQ,CAAC,UAAU,KAC9B,OAwBF,CAAC"}

package/dist/rules/ast-utils.mjs

@@ -0,0 +1,54 @@
+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 };
+};
+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);
+};
+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 { isIntegerLiteralOrConstant, isLengthAccess, isPartOfBoundedLengthCheck, parseLengthComparison };
+//# sourceMappingURL=ast-utils.mjs.map

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

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

package/dist/rules/branded-number-types.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Branded number types from ts-data-forge and their corresponding as* functions
+ */
+export declare const brandedNumberTypeNameToFunctionName: ReadonlyMap<string, `as${string}`>;
+//# sourceMappingURL=branded-number-types.d.mts.map

package/dist/rules/branded-number-types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branded-number-types.d.mts","sourceRoot":"","sources":["../../src/rules/branded-number-types.mts"],"names":[],"mappings":"AAwCA;;GAEG;AACH,eAAO,MAAM,mCAAmC,EAAE,WAAW,CAC3D,MAAM,EACN,KAAK,MAAM,EAAE,CAC0C,CAAC"}

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

@@ -0,0 +1,40 @@
+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"
+];
+const brandedNumberTypeNameToFunctionName = new Map(brandedNumberTypes.map((t) => [t, `as${t}`]));
+
+export { brandedNumberTypeNameToFunctionName };
+//# sourceMappingURL=branded-number-types.mjs.map

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

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

package/dist/rules/constants.d.mts

@@ -0,0 +1,2 @@
+export declare const TS_DATA_FORGE_MODULE = "ts-data-forge";
+//# sourceMappingURL=constants.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.mts","sourceRoot":"","sources":["../../src/rules/constants.mts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,kBAAkB,CAAC"}

package/dist/rules/constants.mjs

@@ -0,0 +1,4 @@
+const TS_DATA_FORGE_MODULE = "ts-data-forge";
+
+export { TS_DATA_FORGE_MODULE };
+//# sourceMappingURL=constants.mjs.map

package/dist/rules/constants.mjs.map

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

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

@@ -0,0 +1,30 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import { type DeepReadonly } from 'ts-type-forge';
+export declare const getTsDataForgeImport: (program: TSESTree.Program) => TSESTree.ImportDeclaration | undefined;
+export declare const getNamedImports: (node: DeepReadonly<TSESTree.ImportDeclaration> | undefined) => readonly string[];
+/**
+ * Returns the in-scope local name a given canonical export is imported as
+ * (handling aliases such as `import { isX as y }` → `'y'`), or `undefined` when
+ * it is not imported. Used so autofixes reference the binding that actually
+ * exists rather than the canonical name.
+ */
+export declare const getImportedLocalName: (node: DeepReadonly<TSESTree.ImportDeclaration> | undefined, importedName: string) => string | undefined;
+type ResolvedCallee = Readonly<{
+    /** The canonical (imported) ts-data-forge name, regardless of local alias. */
+    canonicalName: string;
+    /** The identifier node to rewrite when replacing the callee name. */
+    propertyNode: TSESTree.Node;
+    /** Whether the call was made through a namespace import (`tf.isX(...)`). */
+    isNamespace: boolean;
+}>;
+/**
+ * Builds a resolver that maps a call expression's callee to the canonical
+ * ts-data-forge function it refers to. Handles named imports (including aliases
+ * such as `import { isX as y }`) and namespace imports (`import * as tf` →
+ * `tf.isX(...)`). Returns `undefined` for any callee that does not reference the
+ * given ts-data-forge import.
+ */
+export declare const buildCalleeResolver: (importDecl: TSESTree.ImportDeclaration | undefined) => ((callee: DeepReadonly<TSESTree.Expression>) => ResolvedCallee | undefined);
+export declare const buildImportFixes: (fixer: TSESLint.RuleFixer, program: TSESTree.Program, _tsDataForgeImport: TSESTree.ImportDeclaration | undefined, requiredNames: readonly string[]) => readonly TSESLint.RuleFix[];
+export {};
+//# sourceMappingURL=import-utils.d.mts.map

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

@@ -0,0 +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;AAClC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAKlD,eAAO,MAAM,oBAAoB,YACtB,QAAQ,CAAC,OAAO,KACxB,QAAQ,CAAC,iBAAiB,GAAG,SAK7B,CAAC;AAEJ,eAAO,MAAM,eAAe,SACpB,YAAY,CAAC,QAAQ,CAAC,iBAAiB,CAAC,GAAG,SAAS,KACzD,SAAS,MAAM,EAejB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,SACzB,YAAY,CAAC,QAAQ,CAAC,iBAAiB,CAAC,GAAG,SAAS,gBAC5C,MAAM,KACnB,MAAM,GAAG,SAOG,CAAC;AAEhB,KAAK,cAAc,GAAG,QAAQ,CAAC;IAC7B,8EAA8E;IAC9E,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC5B,4EAA4E;IAC5E,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,eAClB,QAAQ,CAAC,iBAAiB,GAAG,SAAS,KACjD,CAAC,CACF,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,KACtC,cAAc,GAAG,SAAS,CAsD9B,CAAC;AAEF,eAAO,MAAM,gBAAgB,UACpB,QAAQ,CAAC,SAAS,WAChB,QAAQ,CAAC,OAAO,sBACL,QAAQ,CAAC,iBAAiB,GAAG,SAAS,iBAC3C,SAAS,MAAM,EAAE,KAC/B,SAAS,QAAQ,CAAC,OAAO,EAa3B,CAAC"}

package/dist/rules/import-utils.mjs

@@ -0,0 +1,61 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+
+const getTsDataForgeImport = (program) => program.body.find(
+  (node) => node.type === AST_NODE_TYPES.ImportDeclaration && node.source.value === TS_DATA_FORGE_MODULE
+);
+const getNamedImports = (node) => {
+  if (node === void 0) return [];
+  return node.specifiers.flatMap(
+    (specifier) => specifier.type === AST_NODE_TYPES.ImportSpecifier ? (() => {
+      const importedName = specifier.imported.type === AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+      return typeof importedName === "string" ? [importedName] : [];
+    })() : []
+  );
+};
+const getImportedLocalName = (node, importedName) => node?.specifiers.find(
+  (specifier) => specifier.type === AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === importedName
+)?.local.name;
+const buildCalleeResolver = (importDecl) => {
+  const specifiers = importDecl?.specifiers ?? [];
+  const namespaceName = specifiers.find(
+    (specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier
+  )?.local.name;
+  const localToCanonical = new Map(
+    specifiers.flatMap((specifier) => {
+      if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) return [];
+      const importedName = specifier.imported.type === AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+      return typeof importedName === "string" ? [[specifier.local.name, importedName]] : [];
+    })
+  );
+  return (callee) => {
+    if (callee.type === AST_NODE_TYPES.Identifier) {
+      const canonicalName = localToCanonical.get(callee.name);
+      return canonicalName === void 0 ? void 0 : {
+        canonicalName,
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        propertyNode: callee,
+        isNamespace: false
+      };
+    }
+    if (callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES.Identifier && namespaceName !== void 0 && callee.object.name === namespaceName && callee.property.type === AST_NODE_TYPES.Identifier) {
+      return {
+        canonicalName: callee.property.name,
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        propertyNode: callee.property,
+        isNamespace: true
+      };
+    }
+    return void 0;
+  };
+};
+const buildImportFixes = (fixer, program, _tsDataForgeImport, requiredNames) => {
+  const specifierText = requiredNames.join(", ");
+  const importStatement = `import { ${specifierText} } from '${TS_DATA_FORGE_MODULE}';`;
+  const newLine = "\n";
+  const insertionText = `${importStatement}${newLine}`;
+  return [fixer.insertTextBefore(program, insertionText)];
+};
+
+export { buildCalleeResolver, buildImportFixes, getImportedLocalName, getNamedImports, getTsDataForgeImport };
+//# sourceMappingURL=import-utils.mjs.map

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

@@ -0,0 +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 { type DeepReadonly } from 'ts-type-forge';\nimport { TS_DATA_FORGE_MODULE } from './constants.mjs';\n\n/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */\n\nexport const getTsDataForgeImport = (\n  program: TSESTree.Program,\n): TSESTree.ImportDeclaration | undefined =>\n  program.body.find(\n    (node): node is TSESTree.ImportDeclaration =>\n      node.type === AST_NODE_TYPES.ImportDeclaration &&\n      node.source.value === TS_DATA_FORGE_MODULE,\n  );\n\nexport const getNamedImports = (\n  node: DeepReadonly<TSESTree.ImportDeclaration> | undefined,\n): readonly string[] => {\n  if (node === undefined) return [];\n\n  return node.specifiers.flatMap((specifier) =>\n    specifier.type === AST_NODE_TYPES.ImportSpecifier\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' ? [importedName] : [];\n        })()\n      : [],\n  );\n};\n\n/**\n * Returns the in-scope local name a given canonical export is imported as\n * (handling aliases such as `import { isX as y }` → `'y'`), or `undefined` when\n * it is not imported. Used so autofixes reference the binding that actually\n * exists rather than the canonical name.\n */\nexport const getImportedLocalName = (\n  node: DeepReadonly<TSESTree.ImportDeclaration> | undefined,\n  importedName: string,\n): string | undefined =>\n  node?.specifiers.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\ntype ResolvedCallee = Readonly<{\n  /** The canonical (imported) ts-data-forge 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 (`tf.isX(...)`). */\n  isNamespace: boolean;\n}>;\n\n/**\n * Builds a resolver that maps a call expression's callee to the canonical\n * ts-data-forge function it refers to. Handles named imports (including aliases\n * such as `import { isX as y }`) and namespace imports (`import * as tf` →\n * `tf.isX(...)`). Returns `undefined` for any callee that does not reference the\n * given ts-data-forge import.\n */\nexport const buildCalleeResolver = (\n  importDecl: TSESTree.ImportDeclaration | undefined,\n): ((\n  callee: DeepReadonly<TSESTree.Expression>,\n) => ResolvedCallee | undefined) => {\n  const specifiers = importDecl?.specifiers ?? [];\n\n  const namespaceName = specifiers.find(\n    (specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier,\n  )?.local.name;\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        : {\n            canonicalName,\n            // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n            propertyNode: callee as TSESTree.Node,\n            isNamespace: false,\n          };\n    }\n\n    if (\n      callee.type === AST_NODE_TYPES.MemberExpression &&\n      !callee.computed &&\n      callee.object.type === AST_NODE_TYPES.Identifier &&\n      namespaceName !== undefined &&\n      callee.object.name === namespaceName &&\n      callee.property.type === AST_NODE_TYPES.Identifier\n    ) {\n      return {\n        canonicalName: callee.property.name,\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        propertyNode: callee.property as TSESTree.Node,\n        isNamespace: true,\n      };\n    }\n\n    return undefined;\n  };\n};\n\nexport const buildImportFixes = (\n  fixer: TSESLint.RuleFixer,\n  program: TSESTree.Program,\n  _tsDataForgeImport: TSESTree.ImportDeclaration | undefined,\n  requiredNames: readonly string[],\n): readonly TSESLint.RuleFix[] => {\n  const specifierText = requiredNames.join(', ');\n\n  const importStatement =\n    `import { ${specifierText} } from '${TS_DATA_FORGE_MODULE}';` as const;\n\n  const newLine = '\\n';\n\n  const insertionText = `${importStatement}${newLine}` as const;\n\n  // Always insert at the beginning of the file\n  // (organize-imports will handle merging/deduplication)\n  return [fixer.insertTextBefore(program, insertionText)];\n};\n/* eslint-enable @typescript-eslint/prefer-readonly-parameter-types */\n"],"names":[],"mappings":"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"}

package/dist/rules/index.d.mts

@@ -0,0 +1,2 @@
+export * from './rules.mjs';
+//# sourceMappingURL=index.d.mts.map