eslint-plugin-typefest 1.0.1

package/dist/rules/prefer-ts-extras-is-empty.js

@@ -0,0 +1,116 @@
+import { createIsArrayLikeExpressionChecker } from "../_internal/array-like-expression.js";
+import { collectDirectNamedValueImportsFromSource, createSafeValueArgumentFunctionCallFix, } from "../_internal/imported-value-symbols.js";
+import { TS_EXTRAS_MODULE_SOURCE } from "../_internal/module-source.js";
+import { reportWithOptionalFix } from "../_internal/rule-reporting.js";
+import { createTypedRule, getTypedRuleServices, } from "../_internal/typed-rule.js";
+import { createTypeScriptEslintNodeExpressionSkipChecker } from "../_internal/typescript-eslint-node-autofix.js";
+/**
+ * Checks whether an expression is the numeric literal `0`.
+ *
+ * @param node - Expression node to inspect.
+ *
+ * @returns `true` when the node is a `Literal` whose value is `0`.
+ */
+const isZeroLiteral = (node) => node.type === "Literal" && node.value === 0;
+/**
+ * Narrows expressions to direct `.length` member access.
+ *
+ * @param node - Expression node to inspect.
+ *
+ * @returns `true` when the node is a non-computed member expression whose
+ *   property identifier is `length`.
+ */
+const isLengthMemberExpression = (node) => node.type === "MemberExpression" &&
+    !node.computed &&
+    node.property.type === "Identifier" &&
+    node.property.name === "length";
+/**
+ * ESLint rule definition for `prefer-ts-extras-is-empty`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTsExtrasIsEmptyRule = createTypedRule({
+    create(context) {
+        const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+        const { checker, parserServices } = getTypedRuleServices(context);
+        const isArrayLikeExpression = createIsArrayLikeExpressionChecker({
+            checker,
+            parserServices,
+            telemetryFilePath: context.physicalFilename,
+            unionMatchMode: "every",
+        });
+        const shouldSkipComparedExpression = createTypeScriptEslintNodeExpressionSkipChecker(context, {
+            checker,
+            parserServices,
+        });
+        return {
+            BinaryExpression(node) {
+                if (node.operator !== "==" && node.operator !== "===") {
+                    return;
+                }
+                const isLeftLengthCheck = isLengthMemberExpression(node.left) &&
+                    isZeroLiteral(node.right);
+                const isRightLengthCheck = isLengthMemberExpression(node.right) &&
+                    isZeroLiteral(node.left);
+                if (!isLeftLengthCheck && !isRightLengthCheck) {
+                    return;
+                }
+                const lengthNode = isLeftLengthCheck
+                    ? node.left
+                    : node.right;
+                if (!isLengthMemberExpression(lengthNode)) {
+                    return;
+                }
+                if (!isArrayLikeExpression(lengthNode.object)) {
+                    return;
+                }
+                if (shouldSkipComparedExpression(lengthNode.object)) {
+                    return;
+                }
+                reportWithOptionalFix({
+                    context,
+                    fix: createSafeValueArgumentFunctionCallFix({
+                        argumentNode: lengthNode.object,
+                        context,
+                        importedName: "isEmpty",
+                        imports: tsExtrasImports,
+                        sourceModuleName: TS_EXTRAS_MODULE_SOURCE,
+                        targetNode: node,
+                    }),
+                    messageId: "preferTsExtrasIsEmpty",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require ts-extras isEmpty over direct array.length === 0 checks for consistent emptiness guards.",
+            frozen: false,
+            recommended: false,
+            requiresTypeChecking: true,
+            typefestConfigs: [
+                "typefest.configs.recommended-type-checked",
+                "typefest.configs.strict",
+                "typefest.configs.all",
+                "typefest.configs.ts-extras/type-guards",
+            ],
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-ts-extras-is-empty",
+        },
+        fixable: "code",
+        messages: {
+            preferTsExtrasIsEmpty: "Prefer `isEmpty` from `ts-extras` over direct `array.length === 0` checks.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-ts-extras-is-empty",
+});
+/**
+ * Default export for the `prefer-ts-extras-is-empty` rule module.
+ */
+export default preferTsExtrasIsEmptyRule;
+//# sourceMappingURL=prefer-ts-extras-is-empty.js.map

package/dist/rules/prefer-ts-extras-is-empty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-empty.js","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-empty.ts"],"names":[],"mappings":"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"}

package/dist/rules/prefer-ts-extras-is-equal-type.d.ts

@@ -0,0 +1,13 @@
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * ESLint rule definition for `prefer-ts-extras-is-equal-type`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+declare const preferTsExtrasIsEqualTypeRule: ReturnType<typeof createTypedRule>;
+/**
+ * Default export for the `prefer-ts-extras-is-equal-type` rule module.
+ */
+export default preferTsExtrasIsEqualTypeRule;
+//# sourceMappingURL=prefer-ts-extras-is-equal-type.d.ts.map

package/dist/rules/prefer-ts-extras-is-equal-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-equal-type.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-equal-type.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAK7D;;;;;GAKG;AACH,QAAA,MAAM,6BAA6B,EAAE,UAAU,CAAC,OAAO,eAAe,CAuKhE,CAAC;AAEP;;GAEG;AACH,eAAe,6BAA6B,CAAC"}

package/dist/rules/prefer-ts-extras-is-equal-type.js

@@ -0,0 +1,138 @@
+import { isDefined } from "ts-extras";
+import { collectNamedImportLocalNamesFromSource, collectNamespaceImportLocalNamesFromSource, } from "../_internal/imported-type-aliases.js";
+import { collectDirectNamedValueImportsFromSource, createSafeValueNodeTextReplacementFix, } from "../_internal/imported-value-symbols.js";
+import { TS_EXTRAS_MODULE_SOURCE, TYPE_FEST_MODULE_SOURCE, } from "../_internal/module-source.js";
+import { reportWithOptionalFix, reportWithTypefestPolicy, } from "../_internal/rule-reporting.js";
+import { setContainsValue } from "../_internal/set-membership.js";
+import { createTypedRule } from "../_internal/typed-rule.js";
+const IS_EQUAL_TYPE_NAME = "IsEqual";
+const IS_EQUAL_TYPE_FUNCTION_NAME = "isEqualType";
+/**
+ * ESLint rule definition for `prefer-ts-extras-is-equal-type`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTsExtrasIsEqualTypeRule = createTypedRule({
+    create(context) {
+        const isEqualLocalNames = collectNamedImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE, IS_EQUAL_TYPE_NAME);
+        const typeFestNamespaceImportNames = collectNamespaceImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+        const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+        /**
+         * Resolve `IsEqual<...>` type references from direct or namespace
+         * imports.
+         */
+        const getIsEqualTypeReference = (node) => {
+            if (node.type !== "TSTypeReference") {
+                return null;
+            }
+            if (node.typeName.type === "Identifier") {
+                return setContainsValue(isEqualLocalNames, node.typeName.name)
+                    ? node
+                    : null;
+            }
+            if (node.typeName.type !== "TSQualifiedName") {
+                return null;
+            }
+            if (node.typeName.left.type === "Identifier" &&
+                setContainsValue(typeFestNamespaceImportNames, node.typeName.left.name) &&
+                node.typeName.right.type === "Identifier" &&
+                node.typeName.right.name === IS_EQUAL_TYPE_NAME) {
+                return node;
+            }
+            return null;
+        };
+        return {
+            VariableDeclarator(node) {
+                if (node.id.type !== "Identifier" ||
+                    !isDefined(node.id.typeAnnotation?.typeAnnotation) ||
+                    node.init?.type !== "Literal" ||
+                    typeof node.init.value !== "boolean") {
+                    return;
+                }
+                const isEqualTypeReference = getIsEqualTypeReference(node.id.typeAnnotation.typeAnnotation);
+                if (!isEqualTypeReference) {
+                    return;
+                }
+                const typeArguments = isEqualTypeReference.typeArguments?.params ?? [];
+                const identifierName = node.id.name;
+                const initializerValue = node.init.value;
+                const [leftType, rightType] = typeArguments;
+                if (leftType === undefined || rightType === undefined) {
+                    reportWithOptionalFix({
+                        context,
+                        fix: null,
+                        messageId: "preferTsExtrasIsEqualType",
+                        node,
+                    });
+                    return;
+                }
+                const leftTypeText = context.sourceCode.getText(leftType);
+                const rightTypeText = context.sourceCode.getText(rightType);
+                const isEqualTypeSuggestionFix = createSafeValueNodeTextReplacementFix({
+                    context,
+                    importedName: IS_EQUAL_TYPE_FUNCTION_NAME,
+                    imports: tsExtrasImports,
+                    replacementTextFactory: (replacementName) => {
+                        const callText = `${replacementName}<${leftTypeText}, ${rightTypeText}>()`;
+                        const runtimePreservingExpression = initializerValue
+                            ? `${callText} || true`
+                            : `${callText} && false`;
+                        return `${identifierName} = ${runtimePreservingExpression}`;
+                    },
+                    reportFixIntent: "suggestion",
+                    sourceModuleName: TS_EXTRAS_MODULE_SOURCE,
+                    targetNode: node,
+                });
+                if (typeArguments.length !== 2 ||
+                    isEqualTypeSuggestionFix === null) {
+                    reportWithOptionalFix({
+                        context,
+                        fix: null,
+                        messageId: "preferTsExtrasIsEqualType",
+                        node,
+                    });
+                    return;
+                }
+                reportWithTypefestPolicy({
+                    context,
+                    descriptor: {
+                        messageId: "preferTsExtrasIsEqualType",
+                        node,
+                        suggest: [
+                            {
+                                fix: isEqualTypeSuggestionFix,
+                                messageId: "suggestTsExtrasIsEqualType",
+                            },
+                        ],
+                    },
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require ts-extras isEqualType over IsEqual<T, U> boolean assertion variables.",
+            frozen: false,
+            recommended: false,
+            requiresTypeChecking: false,
+            typefestConfigs: "typefest.configs.all",
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-ts-extras-is-equal-type",
+        },
+        hasSuggestions: true,
+        messages: {
+            preferTsExtrasIsEqualType: "Prefer `isEqualType<T, U>()` from `ts-extras` over `IsEqual<T, U>` boolean assertion variables.",
+            suggestTsExtrasIsEqualType: "Replace this boolean `IsEqual<...>` assertion variable with `isEqualType<...>()`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-ts-extras-is-equal-type",
+});
+/**
+ * Default export for the `prefer-ts-extras-is-equal-type` rule module.
+ */
+export default preferTsExtrasIsEqualTypeRule;
+//# sourceMappingURL=prefer-ts-extras-is-equal-type.js.map

package/dist/rules/prefer-ts-extras-is-equal-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-equal-type.js","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-equal-type.ts"],"names":[],"mappings":"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"}

package/dist/rules/prefer-ts-extras-is-finite.d.ts

@@ -0,0 +1,13 @@
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * ESLint rule definition for `prefer-ts-extras-is-finite`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+declare const preferTsExtrasIsFiniteRule: ReturnType<typeof createTypedRule>;
+/**
+ * Default export for the `prefer-ts-extras-is-finite` rule module.
+ */
+export default preferTsExtrasIsFiniteRule;
+//# sourceMappingURL=prefer-ts-extras-is-finite.d.ts.map

package/dist/rules/prefer-ts-extras-is-finite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-finite.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-finite.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;;;;GAKG;AACH,QAAA,MAAM,0BAA0B,EAAE,UAAU,CAAC,OAAO,eAAe,CAkD7D,CAAC;AAEP;;GAEG;AACH,eAAe,0BAA0B,CAAC"}

package/dist/rules/prefer-ts-extras-is-finite.js

@@ -0,0 +1,61 @@
+/**
+ * @packageDocumentation
+ * ESLint rule implementation for `prefer-ts-extras-is-finite`.
+ */
+import { reportTsExtrasGlobalMemberCall } from "../_internal/global-member-call-rule.js";
+import { collectDirectNamedValueImportsFromSource } from "../_internal/imported-value-symbols.js";
+import { TS_EXTRAS_MODULE_SOURCE } from "../_internal/module-source.js";
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * ESLint rule definition for `prefer-ts-extras-is-finite`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTsExtrasIsFiniteRule = createTypedRule({
+    create(context) {
+        const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+        return {
+            'CallExpression[callee.type="MemberExpression"][callee.object.type="Identifier"][callee.object.name="Number"][callee.property.type="Identifier"][callee.property.name="isFinite"]'(node) {
+                reportTsExtrasGlobalMemberCall({
+                    context,
+                    importedName: "isFinite",
+                    imports: tsExtrasImports,
+                    memberName: "isFinite",
+                    messageId: "preferTsExtrasIsFinite",
+                    node,
+                    objectName: "Number",
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require ts-extras isFinite over Number.isFinite for consistent predicate helper usage.",
+            frozen: false,
+            recommended: true,
+            requiresTypeChecking: false,
+            typefestConfigs: [
+                "typefest.configs.recommended",
+                "typefest.configs.strict",
+                "typefest.configs.all",
+                "typefest.configs.ts-extras/type-guards",
+            ],
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-ts-extras-is-finite",
+        },
+        fixable: "code",
+        messages: {
+            preferTsExtrasIsFinite: "Prefer `isFinite` from `ts-extras` over `Number.isFinite(...)`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-ts-extras-is-finite",
+});
+/**
+ * Default export for the `prefer-ts-extras-is-finite` rule module.
+ */
+export default preferTsExtrasIsFiniteRule;
+//# sourceMappingURL=prefer-ts-extras-is-finite.js.map

package/dist/rules/prefer-ts-extras-is-finite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-finite.js","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-finite.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,8BAA8B,EAAE,MAAM,yCAAyC,CAAC;AACzF,OAAO,EAAE,wCAAwC,EAAE,MAAM,wCAAwC,CAAC;AAClG,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,0BAA0B,GAC5B,eAAe,CAAC;IACZ,MAAM,CAAC,OAAO;QACV,MAAM,eAAe,GAAG,wCAAwC,CAC5D,OAAO,CAAC,UAAU,EAClB,uBAAuB,CAC1B,CAAC;QAEF,OAAO;YACH,kLAAkL,CAC9K,IAAI;gBAEJ,8BAA8B,CAAC;oBAC3B,OAAO;oBACP,YAAY,EAAE,UAAU;oBACxB,OAAO,EAAE,eAAe;oBACxB,UAAU,EAAE,UAAU;oBACtB,SAAS,EAAE,wBAAwB;oBACnC,IAAI;oBACJ,UAAU,EAAE,QAAQ;iBACvB,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,wFAAwF;YAC5F,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,IAAI;YACjB,oBAAoB,EAAE,KAAK;YAC3B,eAAe,EAAE;gBACb,8BAA8B;gBAC9B,yBAAyB;gBACzB,sBAAsB;gBACtB,wCAAwC;aAC3C;YACD,GAAG,EAAE,2FAA2F;SACnG;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACN,sBAAsB,EAClB,iEAAiE;SACxE;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACrB;IACD,IAAI,EAAE,4BAA4B;CACrC,CAAC,CAAC;AAEP;;GAEG;AACH,eAAe,0BAA0B,CAAC"}

package/dist/rules/prefer-ts-extras-is-infinite.d.ts

@@ -0,0 +1,8 @@
+import { createTypedRule } from "../_internal/typed-rule.js";
+/** Rule module definition for `prefer-ts-extras-is-infinite`. */
+declare const preferTsExtrasIsInfiniteRule: ReturnType<typeof createTypedRule>;
+/**
+ * Default export for the `prefer-ts-extras-is-infinite` rule module.
+ */
+export default preferTsExtrasIsInfiniteRule;
+//# sourceMappingURL=prefer-ts-extras-is-infinite.d.ts.map

package/dist/rules/prefer-ts-extras-is-infinite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-infinite.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-infinite.ts"],"names":[],"mappings":"AAaA,OAAO,EACH,eAAe,EAGlB,MAAM,4BAA4B,CAAC;AAmJpC,iEAAiE;AACjE,QAAA,MAAM,4BAA4B,EAAE,UAAU,CAAC,OAAO,eAAe,CAgG/D,CAAC;AAEP;;GAEG;AACH,eAAe,4BAA4B,CAAC"}

package/dist/rules/prefer-ts-extras-is-infinite.js

@@ -0,0 +1,178 @@
+import { collectDirectNamedValueImportsFromSource, createSafeValueArgumentFunctionCallFix, } from "../_internal/imported-value-symbols.js";
+import { TS_EXTRAS_MODULE_SOURCE } from "../_internal/module-source.js";
+import { areEquivalentExpressions } from "../_internal/normalize-expression-text.js";
+import { reportWithOptionalFix } from "../_internal/rule-reporting.js";
+import { createTypedRule, getTypedRuleServicesOrUndefined, isGlobalIdentifierNamed, } from "../_internal/typed-rule.js";
+import { createTypeScriptEslintNodeExpressionSkipChecker } from "../_internal/typescript-eslint-node-autofix.js";
+/**
+ * Classifies an expression as positive or negative infinity.
+ *
+ * @param context - Rule context used to validate global `Infinity`/`Number`
+ *   bindings.
+ * @param node - Expression to inspect.
+ *
+ * @returns The infinity kind when the expression is a supported infinity
+ *   reference; otherwise `null`.
+ */
+const extractInfinityKind = (context, node) => {
+    if (isGlobalIdentifierNamed(context, node, "Infinity")) {
+        return "positive";
+    }
+    if (node.type !== "MemberExpression" ||
+        node.computed ||
+        node.object.type !== "Identifier" ||
+        node.object.name !== "Number" ||
+        !isGlobalIdentifierNamed(context, node.object, "Number") ||
+        node.property.type !== "Identifier") {
+        return null;
+    }
+    if (node.property.name === "POSITIVE_INFINITY") {
+        return "positive";
+    }
+    if (node.property.name === "NEGATIVE_INFINITY") {
+        return "negative";
+    }
+    return null;
+};
+/**
+ * Extracts a comparison where exactly one side references infinity.
+ *
+ * @param context - Rule context used to resolve global identifiers.
+ * @param expression - Expression candidate.
+ *
+ * @returns Normalized comparison data when the expression matches value ===
+ *   Infinity style checks; otherwise null.
+ */
+const extractInfinityComparison = (context, expression) => {
+    if (expression.type !== "BinaryExpression" ||
+        (expression.operator !== "==" && expression.operator !== "===")) {
+        return null;
+    }
+    const leftKind = extractInfinityKind(context, expression.left);
+    const rightKind = extractInfinityKind(context, expression.right);
+    if (leftKind && !rightKind) {
+        return {
+            comparedExpression: expression.right,
+            kind: leftKind,
+            operator: expression.operator,
+        };
+    }
+    if (!leftKind && rightKind) {
+        return {
+            comparedExpression: expression.left,
+            kind: rightKind,
+            operator: expression.operator,
+        };
+    }
+    return null;
+};
+/**
+ * Extracts the shared target from strict disjunction checks against both
+ * positive and negative infinity.
+ *
+ * @param context - Rule context used during infinity comparison extraction.
+ * @param node - Logical expression candidate.
+ *
+ * @returns The compared expression from value === Infinity || value ===
+ *   Number.NEGATIVE_INFINITY style patterns; otherwise null.
+ */
+const extractSafeInfinityDisjunctionTarget = (context, node) => {
+    if (node.operator !== "||") {
+        return null;
+    }
+    const left = extractInfinityComparison(context, node.left);
+    const right = extractInfinityComparison(context, node.right);
+    if (!left || !right) {
+        return null;
+    }
+    if (left.operator !== "===" || right.operator !== "===") {
+        return null;
+    }
+    if (left.kind === right.kind) {
+        return null;
+    }
+    return areEquivalentExpressions(left.comparedExpression, right.comparedExpression)
+        ? left.comparedExpression
+        : null;
+};
+/** Rule module definition for `prefer-ts-extras-is-infinite`. */
+const preferTsExtrasIsInfiniteRule = createTypedRule({
+    create(context) {
+        const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+        const typedServices = getTypedRuleServicesOrUndefined(context);
+        const shouldSkipComparedExpression = createTypeScriptEslintNodeExpressionSkipChecker(context, typedServices);
+        return {
+            BinaryExpression(node) {
+                const parent = node.parent;
+                if (parent?.type === "LogicalExpression" &&
+                    extractSafeInfinityDisjunctionTarget(context, parent)) {
+                    return;
+                }
+                if (node.operator !== "==" && node.operator !== "===") {
+                    return;
+                }
+                if (extractInfinityKind(context, node.left) === null &&
+                    extractInfinityKind(context, node.right) === null) {
+                    return;
+                }
+                reportWithOptionalFix({
+                    context,
+                    fix: null,
+                    messageId: "preferTsExtrasIsInfinite",
+                    node,
+                });
+            },
+            LogicalExpression(node) {
+                const comparedExpression = extractSafeInfinityDisjunctionTarget(context, node);
+                if (!comparedExpression) {
+                    return;
+                }
+                if (shouldSkipComparedExpression(comparedExpression)) {
+                    return;
+                }
+                reportWithOptionalFix({
+                    context,
+                    fix: createSafeValueArgumentFunctionCallFix({
+                        argumentNode: comparedExpression,
+                        context,
+                        importedName: "isInfinite",
+                        imports: tsExtrasImports,
+                        sourceModuleName: TS_EXTRAS_MODULE_SOURCE,
+                        targetNode: node,
+                    }),
+                    messageId: "preferTsExtrasIsInfinite",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require ts-extras isInfinite over direct Infinity equality checks for consistent predicate helper usage.",
+            frozen: false,
+            recommended: true,
+            requiresTypeChecking: false,
+            typefestConfigs: [
+                "typefest.configs.recommended",
+                "typefest.configs.strict",
+                "typefest.configs.all",
+                "typefest.configs.ts-extras/type-guards",
+            ],
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-ts-extras-is-infinite",
+        },
+        fixable: "code",
+        messages: {
+            preferTsExtrasIsInfinite: "Prefer `isInfinite` from `ts-extras` over direct Infinity equality checks.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-ts-extras-is-infinite",
+});
+/**
+ * Default export for the `prefer-ts-extras-is-infinite` rule module.
+ */
+export default preferTsExtrasIsInfiniteRule;
+//# sourceMappingURL=prefer-ts-extras-is-infinite.js.map

package/dist/rules/prefer-ts-extras-is-infinite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-infinite.js","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-infinite.ts"],"names":[],"mappings":"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"}

package/dist/rules/prefer-ts-extras-is-integer.d.ts

@@ -0,0 +1,13 @@
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * ESLint rule definition for `prefer-ts-extras-is-integer`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+declare const preferTsExtrasIsIntegerRule: ReturnType<typeof createTypedRule>;
+/**
+ * Default export for the `prefer-ts-extras-is-integer` rule module.
+ */
+export default preferTsExtrasIsIntegerRule;
+//# sourceMappingURL=prefer-ts-extras-is-integer.d.ts.map

package/dist/rules/prefer-ts-extras-is-integer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-integer.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-integer.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;;;;GAKG;AACH,QAAA,MAAM,2BAA2B,EAAE,UAAU,CAAC,OAAO,eAAe,CAkD9D,CAAC;AAEP;;GAEG;AACH,eAAe,2BAA2B,CAAC"}

package/dist/rules/prefer-ts-extras-is-integer.js

@@ -0,0 +1,61 @@
+/**
+ * @packageDocumentation
+ * ESLint rule implementation for `prefer-ts-extras-is-integer`.
+ */
+import { reportTsExtrasGlobalMemberCall } from "../_internal/global-member-call-rule.js";
+import { collectDirectNamedValueImportsFromSource } from "../_internal/imported-value-symbols.js";
+import { TS_EXTRAS_MODULE_SOURCE } from "../_internal/module-source.js";
+import { createTypedRule } from "../_internal/typed-rule.js";
+/**
+ * ESLint rule definition for `prefer-ts-extras-is-integer`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTsExtrasIsIntegerRule = createTypedRule({
+    create(context) {
+        const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+        return {
+            'CallExpression[callee.type="MemberExpression"][callee.object.type="Identifier"][callee.object.name="Number"][callee.property.type="Identifier"][callee.property.name="isInteger"]'(node) {
+                reportTsExtrasGlobalMemberCall({
+                    context,
+                    importedName: "isInteger",
+                    imports: tsExtrasImports,
+                    memberName: "isInteger",
+                    messageId: "preferTsExtrasIsInteger",
+                    node,
+                    objectName: "Number",
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require ts-extras isInteger over Number.isInteger for consistent predicate helper usage.",
+            frozen: false,
+            recommended: true,
+            requiresTypeChecking: false,
+            typefestConfigs: [
+                "typefest.configs.recommended",
+                "typefest.configs.strict",
+                "typefest.configs.all",
+                "typefest.configs.ts-extras/type-guards",
+            ],
+            url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-ts-extras-is-integer",
+        },
+        fixable: "code",
+        messages: {
+            preferTsExtrasIsInteger: "Prefer `isInteger` from `ts-extras` over `Number.isInteger(...)`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-ts-extras-is-integer",
+});
+/**
+ * Default export for the `prefer-ts-extras-is-integer` rule module.
+ */
+export default preferTsExtrasIsIntegerRule;
+//# sourceMappingURL=prefer-ts-extras-is-integer.js.map