eslint-plugin-typefest 1.0.4 → 1.0.6

package/dist/rules/prefer-type-fest-union-to-tuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-union-to-tuple.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-union-to-tuple.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAO7D;;;;;GAKG;AACH,QAAA,MAAM,8BAA8B,EAAE,UAAU,CAAC,OAAO,eAAe,CAyEjE,CAAC;AAEP;;GAEG;AACH,eAAe,8BAA8B,CAAC"}

package/dist/rules/prefer-type-fest-union-to-tuple.js

@@ -0,0 +1,75 @@
+/**
+ * @packageDocumentation
+ * ESLint rule implementation for `prefer-type-fest-union-to-tuple`.
+ */
+import { collectDirectNamedImportsFromSource, collectImportedTypeAliasMatches, createSafeTypeReferenceReplacementFix, } from "../_internal/imported-type-aliases.js";
+import { TYPE_FEST_MODULE_SOURCE } from "../_internal/module-source.js";
+import { reportWithOptionalFix } from "../_internal/rule-reporting.js";
+import { createTypedRule } from "../_internal/typed-rule.js";
+const unionToTupleAliasReplacements = {
+    TupleFromUnion: "UnionToTuple",
+    TuplifyUnion: "UnionToTuple",
+};
+/**
+ * ESLint rule definition for `prefer-type-fest-union-to-tuple`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTypeFestUnionToTupleRule = createTypedRule({
+    create(context) {
+        const importedAliasMatches = collectImportedTypeAliasMatches(context.sourceCode, unionToTupleAliasReplacements);
+        const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+        return {
+            'TSTypeReference[typeName.type="Identifier"]'(node) {
+                if (node.typeName.type !== "Identifier") {
+                    return;
+                }
+                const importedAliasMatch = importedAliasMatches.get(node.typeName.name);
+                if (!importedAliasMatch) {
+                    return;
+                }
+                const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, importedAliasMatch.replacementName, typeFestDirectImports);
+                reportWithOptionalFix({
+                    context,
+                    data: {
+                        alias: importedAliasMatch.importedName,
+                        replacement: importedAliasMatch.replacementName,
+                    },
+                    fix: aliasReplacementFix,
+                    messageId: "preferUnionToTuple",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require TypeFest UnionToTuple over imported aliases such as TuplifyUnion.",
+            frozen: false,
+            recommended: true,
+            requiresTypeChecking: false,
+            typefestConfigs: [
+                "typefest.configs.recommended",
+                "typefest.configs.strict",
+                "typefest.configs.all",
+                "typefest.configs.type-fest/types",
+            ],
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-union-to-tuple",
+        },
+        fixable: "code",
+        messages: {
+            preferUnionToTuple: "Prefer `{{replacement}}` from type-fest to convert unions into tuple forms instead of legacy alias `{{alias}}`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-type-fest-union-to-tuple",
+});
+/**
+ * Default export for the `prefer-type-fest-union-to-tuple` rule module.
+ */
+export default preferTypeFestUnionToTupleRule;
+//# sourceMappingURL=prefer-type-fest-union-to-tuple.js.map

package/dist/rules/prefer-type-fest-union-to-tuple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-type-fest-union-to-tuple.js","sourceRoot":"","sources":["../../src/rules/prefer-type-fest-union-to-tuple.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,OAAO,EACH,mCAAmC,EACnC,+BAA+B,EAC/B,qCAAqC,GACxC,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,MAAM,6BAA6B,GAAG;IAClC,cAAc,EAAE,cAAc;IAC9B,YAAY,EAAE,cAAc;CACtB,CAAC;AAEX;;;;;GAKG;AACH,MAAM,8BAA8B,GAChC,eAAe,CAAC;IACZ,MAAM,CAAC,OAAO;QACV,MAAM,oBAAoB,GAAG,+BAA+B,CACxD,OAAO,CAAC,UAAU,EAClB,6BAA6B,CAChC,CAAC;QACF,MAAM,qBAAqB,GAAG,mCAAmC,CAC7D,OAAO,CAAC,UAAU,EAClB,uBAAuB,CAC1B,CAAC;QAEF,OAAO;YACH,6CAA6C,CACzC,IAA8B;gBAE9B,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;oBACtC,OAAO;gBACX,CAAC;gBAED,MAAM,kBAAkB,GAAG,oBAAoB,CAAC,GAAG,CAC/C,IAAI,CAAC,QAAQ,CAAC,IAAI,CACrB,CAAC;gBACF,IAAI,CAAC,kBAAkB,EAAE,CAAC;oBACtB,OAAO;gBACX,CAAC;gBAED,MAAM,mBAAmB,GACrB,qCAAqC,CACjC,IAAI,EACJ,kBAAkB,CAAC,eAAe,EAClC,qBAAqB,CACxB,CAAC;gBAEN,qBAAqB,CAAC;oBAClB,OAAO;oBACP,IAAI,EAAE;wBACF,KAAK,EAAE,kBAAkB,CAAC,YAAY;wBACtC,WAAW,EAAE,kBAAkB,CAAC,eAAe;qBAClD;oBACD,GAAG,EAAE,mBAAmB;oBACxB,SAAS,EAAE,oBAAoB;oBAC/B,IAAI;iBACP,CAAC,CAAC;YACP,CAAC;SACJ,CAAC;IACN,CAAC;IACD,cAAc,EAAE,EAAE;IAClB,IAAI,EAAE;QACF,UAAU,EAAE,KAAK;QACjB,IAAI,EAAE;YACF,WAAW,EACP,2EAA2E;YAC/E,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,IAAI;YACjB,oBAAoB,EAAE,KAAK;YAC3B,eAAe,EAAE;gBACb,8BAA8B;gBAC9B,yBAAyB;gBACzB,sBAAsB;gBACtB,kCAAkC;aACrC;YACD,GAAG,EAAE,gGAAgG;SACxG;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACN,kBAAkB,EACd,iHAAiH;SACxH;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACrB;IACD,IAAI,EAAE,iCAAiC;CAC1C,CAAC,CAAC;AAEP;;GAEG;AACH,eAAe,8BAA8B,CAAC"}

package/docs/rules/prefer-type-fest-and-all.md

@@ -0,0 +1,111 @@
+# prefer-type-fest-and-all
+
+Require TypeFest [`AndAll<TTuple>`](https://github.com/sindresorhus/type-fest/blob/main/source/and-all.d.ts) over `AllExtend<TTuple, true>` boolean-tuple checks.
+
+## Targeted pattern scope
+
+This rule targets direct and namespace-qualified references to `AllExtend<TTuple, true>` imported from `type-fest`.
+
+## What this rule reports
+
+- `AllExtend<TTuple, true>` when it is being used as a boolean-tuple conjunction check.
+
+## Why this rule exists
+
+`AndAll` is the dedicated TypeFest helper for checking whether all boolean tuple members are `true`. It is shorter, more intention-revealing, and matches the new canonical TypeFest naming.
+
+## ❌ Incorrect
+
+```ts
+import type { AllExtend } from "type-fest";
+
+type AllFlagsTrue = AllExtend<[true, true, false], true>;
+```
+
+## ✅ Correct
+
+```ts
+import type { AndAll } from "type-fest";
+
+type AllFlagsTrue = AndAll<[true, true, false]>;
+```
+
+## Behavior and migration notes
+
+- This rule only targets `AllExtend<TTuple, true>`.
+- It does not report `AllExtend<TTuple, SomeOtherType>` usages.
+- Namespace-qualified `type-fest` references are reported too.
+
+## Additional examples
+
+### ❌ Incorrect — Additional example
+
+```ts
+import type * as TypeFest from "type-fest";
+
+type Ready = TypeFest.AllExtend<[true, true, true], true>;
+```
+
+### ✅ Correct — Additional example
+
+```ts
+import type { AndAll } from "type-fest";
+
+type Ready = AndAll<[true, true, true]>;
+```
+
+### ✅ Correct — Non-targeted usage
+
+```ts
+import type { AllExtend } from "type-fest";
+
+type AllNumbers = AllExtend<[1, 2, 3], number>;
+```
+
+## ESLint flat config example
+
+```ts
+import typefest from "eslint-plugin-typefest";
+
+export default [
+    {
+        plugins: { typefest },
+        rules: {
+            "typefest/prefer-type-fest-and-all": "error",
+        },
+    },
+];
+```
+
+## When not to use it
+
+Disable this rule if your codebase intentionally prefers the more general `AllExtend<TTuple, true>` spelling for boolean tuple checks.
+
+## Package documentation
+
+TypeFest package documentation:
+
+Source file: [`source/and-all.d.ts`](https://github.com/sindresorhus/type-fest/blob/main/source/and-all.d.ts)
+
+```ts
+/**
+Returns a boolean for whether all of the given elements are `true`.
+
+Use-cases:
+- Check if all conditions in a list of booleans are met.
+*/
+export type AndAll<T extends readonly boolean[]> = AllExtend<T, true>;
+```
+
+> **Rule catalog ID:** R077
+
+## Further reading
+
+- [`type-fest` README](https://github.com/sindresorhus/type-fest)
+- [`type-fest` npm documentation](https://www.npmjs.com/package/type-fest)
+- [TypeScript Handbook: Conditional Types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html)
+
+## Adoption resources
+
+- [Rule adoption checklist](./guides/adoption-checklist.md)
+- [Rollout and fix safety](./guides/rollout-and-fix-safety.md)

package/docs/rules/prefer-type-fest-array-length.md

@@ -0,0 +1,109 @@
+# prefer-type-fest-array-length
+
+Require TypeFest [`ArrayLength<T>`](https://github.com/sindresorhus/type-fest/blob/main/source/array-length.d.ts) over array and tuple `T["length"]` type queries.
+
+## Targeted pattern scope
+
+This is a type-aware rule. It targets indexed-access type queries whose object type resolves to an array or tuple.
+
+## What this rule reports
+
+- `T["length"]` when `T` is an array or tuple type.
+
+## Why this rule exists
+
+`ArrayLength<T>` is the dedicated TypeFest helper for array and tuple length extraction. Using it makes intent explicit and aligns with the canonical TypeFest helper name.
+
+## ❌ Incorrect
+
+```ts
+type StepCount = EventSteps["length"];
+```
+
+## ✅ Correct
+
+```ts
+import type { ArrayLength } from "type-fest";
+
+type StepCount = ArrayLength<EventSteps>;
+```
+
+## Behavior and migration notes
+
+- This rule requires type information.
+- It only reports `T["length"]` when `T` resolves to an array-like type.
+- It does not report non-array property lookups like `User["length"]`.
+
+## Additional examples
+
+### ❌ Incorrect — Additional example
+
+```ts
+type TupleLength = readonly [1, 2, 3]["length"];
+```
+
+### ✅ Correct — Additional example
+
+```ts
+import type { ArrayLength } from "type-fest";
+
+type TupleLength = ArrayLength<readonly [1, 2, 3]>;
+```
+
+### ✅ Correct — Non-targeted usage
+
+```ts
+interface User {
+    readonly length: number;
+    readonly name: string;
+}
+
+type UserLength = User["length"];
+```
+
+## ESLint flat config example
+
+```ts
+import typefest from "eslint-plugin-typefest";
+
+export default [
+    {
+        plugins: { typefest },
+        rules: {
+            "typefest/prefer-type-fest-array-length": "error",
+        },
+    },
+];
+```
+
+## When not to use it
+
+Disable this rule if you prefer native indexed-access syntax for array length queries or if your project does not use type-aware linting.
+
+## Package documentation
+
+TypeFest package documentation:
+
+Source file: [`source/array-length.d.ts`](https://github.com/sindresorhus/type-fest/blob/main/source/array-length.d.ts)
+
+```ts
+/**
+Return the length of an array. Equivalent to `T['length']` where `T` extends any array.
+
+Tuples resolve to numeric literals, while non-tuples resolve to the `number` type.
+*/
+export type ArrayLength<T extends readonly unknown[]> = T['length'];
+```
+
+> **Rule catalog ID:** R078
+
+## Further reading
+
+- [`type-fest` README](https://github.com/sindresorhus/type-fest)
+- [`type-fest` npm documentation](https://www.npmjs.com/package/type-fest)
+- [TypeScript Handbook: Indexed Access Types](https://www.typescriptlang.org/docs/handbook/2/indexed-access-types.html)
+
+## Adoption resources
+
+- [Rule adoption checklist](./guides/adoption-checklist.md)
+- [Rollout and fix safety](./guides/rollout-and-fix-safety.md)

package/docs/rules/prefer-type-fest-conditional-pick-deep.md

@@ -0,0 +1,112 @@
+# prefer-type-fest-conditional-pick-deep
+
+Require TypeFest [`ConditionalPickDeep<T, Condition, Options?>`](https://github.com/sindresorhus/type-fest/blob/main/source/conditional-pick-deep.d.ts) instead of legacy deep conditional-pick aliases.
+
+## Targeted pattern scope
+
+This rule targets imported aliases that mirror deep conditional property filtering semantics (for example, `PickDeepByTypes` and `PickDeepByType`).
+
+## What this rule reports
+
+- Type references that resolve to imported deep conditional-pick aliases.
+
+## Why this rule exists
+
+`ConditionalPickDeep` is the canonical TypeFest helper for recursively filtering object properties by value condition. Standardizing on this utility improves consistency and readability.
+
+## ❌ Incorrect
+
+```ts
+import type { PickDeepByTypes } from "type-aliases";
+
+type StringProps = PickDeepByTypes<User, string>;
+```
+
+## ✅ Correct
+
+```ts
+import type { ConditionalPickDeep } from "type-fest";
+
+type StringProps = ConditionalPickDeep<User, string>;
+```
+
+## Behavior and migration notes
+
+- `ConditionalPickDeep<T, Condition, Options?>` recursively selects keys whose values match `Condition`.
+- This rule only targets known alias names that represent the same intent.
+- Keep custom aliases only when they intentionally add behavior beyond deep conditional filtering.
+
+## Additional examples
+
+### ❌ Incorrect — Additional example
+
+```ts
+import type { PickDeepByType } from "type-aliases";
+
+type NumericProps = PickDeepByType<User, number>;
+```
+
+### ✅ Correct — Additional example
+
+```ts
+import type { ConditionalPickDeep } from "type-fest";
+
+type NumericProps = ConditionalPickDeep<User, number>;
+```
+
+### ✅ Correct — Repository-wide usage
+
+```ts
+type DateProps = ConditionalPickDeep<User, Date>;
+```
+
+## ESLint flat config example
+
+```ts
+import typefest from "eslint-plugin-typefest";
+
+export default [
+    {
+        plugins: { typefest },
+        rules: {
+            "typefest/prefer-type-fest-conditional-pick-deep": "error",
+        },
+    },
+];
+```
+
+## When not to use it
+
+Disable this rule if external API contracts require specific alias names.
+
+## Package documentation
+
+TypeFest package documentation:
+
+Source file: [`source/conditional-pick-deep.d.ts`](https://github.com/sindresorhus/type-fest/blob/main/source/conditional-pick-deep.d.ts)
+
+```ts
+/**
+Pick keys recursively from the shape that matches the given condition.
+
+@category Object
+*/
+export type ConditionalPickDeep<
+    Type,
+    Condition,
+    Options extends ConditionalPickDeepOptions = {},
+> = ...
+```
+
+> **Rule catalog ID:** R082
+
+## Further reading
+
+- [`type-fest` README](https://github.com/sindresorhus/type-fest)
+- [`type-fest` npm documentation](https://www.npmjs.com/package/type-fest)
+- [TypeScript Handbook: Conditional Types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html)
+
+## Adoption resources
+
+- [Rule adoption checklist](./guides/adoption-checklist.md)
+- [Rollout and fix safety](./guides/rollout-and-fix-safety.md)

package/docs/rules/prefer-type-fest-less-than-or-equal.md

@@ -0,0 +1,111 @@
+# prefer-type-fest-less-than-or-equal
+
+Require TypeFest [`LessThanOrEqual<A, B>`](https://github.com/sindresorhus/type-fest/blob/main/source/less-than-or-equal.d.ts) over boolean wrappers built from `GreaterThan<A, B>`.
+
+## Targeted pattern scope
+
+This rule targets equivalent conditional wrappers such as `GreaterThan<A, B> extends true ? false : true` and infer-wrapped variants.
+
+## What this rule reports
+
+- Conditional types equivalent to `LessThanOrEqual<A, B>` that are composed from `GreaterThan<A, B>`.
+
+## Why this rule exists
+
+`LessThanOrEqual` is the canonical TypeFest numeric comparison helper for `<=` checks. Using it directly improves readability and avoids repeated wrapper patterns.
+
+## ❌ Incorrect
+
+```ts
+import type { GreaterThan } from "type-fest";
+
+type IsLessOrEqual = GreaterThan<1, 2> extends true ? false : true;
+```
+
+## ✅ Correct
+
+```ts
+import type { LessThanOrEqual } from "type-fest";
+
+type IsLessOrEqual = LessThanOrEqual<1, 2>;
+```
+
+## Behavior and migration notes
+
+- This rule targets wrappers equivalent to `LessThanOrEqual<A, B>`.
+- It handles direct and infer-wrapped conditional forms.
+- It does not report wrappers whose boolean branches do not match `<=` semantics.
+
+## Additional examples
+
+### ❌ Incorrect — Additional example
+
+```ts
+import type { GreaterThan } from "type-fest";
+
+type IsLessOrEqual =
+    GreaterThan<4, 9> extends infer Result
+        ? Result extends true
+            ? false
+            : true
+        : never;
+```
+
+### ✅ Correct — Additional example
+
+```ts
+import type { LessThanOrEqual } from "type-fest";
+
+type IsLessOrEqual = LessThanOrEqual<4, 9>;
+```
+
+### ✅ Correct — Repository-wide usage
+
+```ts
+type IsNonPositive<N extends number> = LessThanOrEqual<N, 0>;
+```
+
+## ESLint flat config example
+
+```ts
+import typefest from "eslint-plugin-typefest";
+
+export default [
+    {
+        plugins: { typefest },
+        rules: {
+            "typefest/prefer-type-fest-less-than-or-equal": "error",
+        },
+    },
+];
+```
+
+## When not to use it
+
+Disable this rule if your codebase intentionally standardizes on custom numeric wrapper types.
+
+## Package documentation
+
+TypeFest package documentation:
+
+Source file: [`source/less-than-or-equal.d.ts`](https://github.com/sindresorhus/type-fest/blob/main/source/less-than-or-equal.d.ts)
+
+```ts
+/**
+Returns a boolean for whether a given number is less than or equal to another number.
+*/
+export type LessThanOrEqual<A extends number, B extends number> = ...
+```
+
+> **Rule catalog ID:** R085
+
+## Further reading
+
+- [`type-fest` README](https://github.com/sindresorhus/type-fest)
+- [`type-fest` npm documentation](https://www.npmjs.com/package/type-fest)
+- [TypeScript Handbook: Conditional Types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html)
+
+## Adoption resources
+
+- [Rule adoption checklist](./guides/adoption-checklist.md)
+- [Rollout and fix safety](./guides/rollout-and-fix-safety.md)

package/docs/rules/prefer-type-fest-less-than.md

@@ -0,0 +1,111 @@
+# prefer-type-fest-less-than
+
+Require TypeFest [`LessThan<A, B>`](https://github.com/sindresorhus/type-fest/blob/main/source/less-than.d.ts) over boolean wrappers built from `GreaterThanOrEqual<A, B>`.
+
+## Targeted pattern scope
+
+This rule targets equivalent conditional wrappers such as `GreaterThanOrEqual<A, B> extends true ? false : true` and infer-wrapped variants.
+
+## What this rule reports
+
+- Conditional types equivalent to `LessThan<A, B>` that are composed from `GreaterThanOrEqual<A, B>`.
+
+## Why this rule exists
+
+`LessThan` is the canonical TypeFest numeric comparison helper for strict `<` checks. Using it directly is shorter, clearer, and avoids repetitive wrapper patterns.
+
+## ❌ Incorrect
+
+```ts
+import type { GreaterThanOrEqual } from "type-fest";
+
+type IsLess = GreaterThanOrEqual<1, 2> extends true ? false : true;
+```
+
+## ✅ Correct
+
+```ts
+import type { LessThan } from "type-fest";
+
+type IsLess = LessThan<1, 2>;
+```
+
+## Behavior and migration notes
+
+- This rule targets wrappers equivalent to `LessThan<A, B>`.
+- It handles direct and infer-wrapped conditional forms.
+- It does not report wrappers whose boolean branches do not match strict `<` semantics.
+
+## Additional examples
+
+### ❌ Incorrect — Additional example
+
+```ts
+import type { GreaterThanOrEqual } from "type-fest";
+
+type IsLess =
+    GreaterThanOrEqual<4, 9> extends infer Result
+        ? Result extends true
+            ? false
+            : true
+        : never;
+```
+
+### ✅ Correct — Additional example
+
+```ts
+import type { LessThan } from "type-fest";
+
+type IsLess = LessThan<4, 9>;
+```
+
+### ✅ Correct — Repository-wide usage
+
+```ts
+type IsNegative<N extends number> = LessThan<N, 0>;
+```
+
+## ESLint flat config example
+
+```ts
+import typefest from "eslint-plugin-typefest";
+
+export default [
+    {
+        plugins: { typefest },
+        rules: {
+            "typefest/prefer-type-fest-less-than": "error",
+        },
+    },
+];
+```
+
+## When not to use it
+
+Disable this rule if your codebase intentionally standardizes on custom numeric wrapper types.
+
+## Package documentation
+
+TypeFest package documentation:
+
+Source file: [`source/less-than.d.ts`](https://github.com/sindresorhus/type-fest/blob/main/source/less-than.d.ts)
+
+```ts
+/**
+Returns a boolean for whether a given number is less than another number.
+*/
+export type LessThan<A extends number, B extends number> = ...
+```
+
+> **Rule catalog ID:** R084
+
+## Further reading
+
+- [`type-fest` README](https://github.com/sindresorhus/type-fest)
+- [`type-fest` npm documentation](https://www.npmjs.com/package/type-fest)
+- [TypeScript Handbook: Conditional Types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html)
+
+## Adoption resources
+
+- [Rule adoption checklist](./guides/adoption-checklist.md)
+- [Rollout and fix safety](./guides/rollout-and-fix-safety.md)