eslint-plugin-typefest 1.0.1

package/dist/rules/prefer-ts-extras-assert-present.js

@@ -0,0 +1,266 @@
+import { collectDirectNamedValueImportsFromSource, createSafeValueNodeTextReplacementFix, getFunctionCallArgumentText, } 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, reportWithTypefestPolicy, } from "../_internal/rule-reporting.js";
+import { getThrowStatementFromConsequent, isThrowOnlyConsequent, } from "../_internal/throw-consequent.js";
+import { getSingleGlobalTypeErrorArgument } from "../_internal/throw-type-error.js";
+import { createTypedRule, isGlobalUndefinedIdentifier, } from "../_internal/typed-rule.js";
+/**
+ * Determine whether an expression is the `null` literal.
+ *
+ * @param node - Expression to inspect.
+ *
+ * @returns `true` when the expression is `null`.
+ */
+const isNullExpression = (node) => node.type === "Literal" && node.value === null;
+/**
+ * Determine whether an expression references the global `undefined` value.
+ *
+ * @param context - Active rule context for scope resolution.
+ * @param node - Expression to inspect.
+ *
+ * @returns `true` when the expression is an unshadowed `undefined` identifier.
+ */
+const isUndefinedExpression = ({ context, node, }) => {
+    if (node.type !== "Identifier" || node.name !== "undefined") {
+        return false;
+    }
+    return isGlobalUndefinedIdentifier(context, node);
+};
+/**
+ * Check whether a throw branch matches the canonical `assertPresent`-equivalent
+ * TypeError template shape.
+ */
+const isCanonicalAssertPresentThrow = ({ context, guardExpression, throwStatement, }) => {
+    const firstArgument = getSingleGlobalTypeErrorArgument({
+        context,
+        throwStatement,
+    });
+    if (firstArgument?.type !== "TemplateLiteral") {
+        return false;
+    }
+    const [prefixQuasi, suffixQuasi] = firstArgument.quasis;
+    if (!prefixQuasi ||
+        !suffixQuasi ||
+        firstArgument.expressions.length !== 1) {
+        return false;
+    }
+    const [templateExpression] = firstArgument.expressions;
+    /* v8 ignore next -- parser guarantees an element at index 0 when expressions.length is exactly 1. */
+    if (!templateExpression) {
+        return false;
+    }
+    return ((prefixQuasi.value.cooked === "Expected a present value, got `" ||
+        prefixQuasi.value.cooked === "Expected a present value, got ") &&
+        (suffixQuasi.value.cooked === "`" || suffixQuasi.value.cooked === "") &&
+        areEquivalentExpressions(templateExpression, guardExpression));
+};
+/**
+ * Extract the guarded expression from `x == null` / `null == x` checks.
+ *
+ * @param test - Test expression to inspect.
+ *
+ * @returns Guarded expression when the check is supported; otherwise `null`.
+ */
+const extractEqNullGuardExpression = (test) => {
+    if (test.type !== "BinaryExpression" || test.operator !== "==") {
+        return null;
+    }
+    if (isNullExpression(test.left)) {
+        return test.right;
+    }
+    if (isNullExpression(test.right)) {
+        return test.left;
+    }
+    return null;
+};
+/**
+ * Extract one nullish-equality comparison part from a binary expression.
+ *
+ * @param expression - Candidate comparison expression.
+ * @param context - Active rule context for global-binding checks.
+ *
+ * @returns Matched comparison metadata; otherwise `null`.
+ */
+const extractNullishEqualityPart = (expression, context) => {
+    if (expression.type !== "BinaryExpression" ||
+        (expression.operator !== "==" && expression.operator !== "===")) {
+        return null;
+    }
+    if (isNullExpression(expression.left)) {
+        return {
+            expression: expression.right,
+            kind: "null",
+        };
+    }
+    if (isNullExpression(expression.right)) {
+        return {
+            expression: expression.left,
+            kind: "null",
+        };
+    }
+    if (isUndefinedExpression({
+        context,
+        node: expression.left,
+    })) {
+        return {
+            expression: expression.right,
+            kind: "undefined",
+        };
+    }
+    if (isUndefinedExpression({
+        context,
+        node: expression.right,
+    })) {
+        return {
+            expression: expression.left,
+            kind: "undefined",
+        };
+    }
+    return null;
+};
+/**
+ * ESLint rule definition for `prefer-ts-extras-assert-present`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTsExtrasAssertPresentRule = createTypedRule({
+    create(context) {
+        const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+        /**
+         * Extracts the guarded expression from supported nullish-present
+         * checks used before throwing.
+         *
+         * @param test - If-statement test expression.
+         *
+         * @returns Guarded expression when the test matches `x == null` or
+         *   split null/undefined disjunction patterns; otherwise `null`.
+         */
+        const extractPresentGuardExpression = (test) => {
+            const eqNullExpression = extractEqNullGuardExpression(test);
+            if (eqNullExpression !== null) {
+                return eqNullExpression;
+            }
+            if (test.type !== "LogicalExpression" ||
+                test.operator !== "||") {
+                return null;
+            }
+            const leftPart = extractNullishEqualityPart(test.left, context);
+            const rightPart = extractNullishEqualityPart(test.right, context);
+            if (leftPart === null ||
+                rightPart === null ||
+                leftPart.kind === rightPart.kind) {
+                return null;
+            }
+            return areEquivalentExpressions(leftPart.expression, rightPart.expression)
+                ? leftPart.expression
+                : null;
+        };
+        return {
+            IfStatement(node) {
+                if (node.alternate !== null ||
+                    !isThrowOnlyConsequent(node.consequent)) {
+                    return;
+                }
+                const guardExpression = extractPresentGuardExpression(node.test);
+                if (guardExpression === null) {
+                    return;
+                }
+                const throwStatement = getThrowStatementFromConsequent(node.consequent);
+                const canAutofix = throwStatement !== null &&
+                    isCanonicalAssertPresentThrow({
+                        context,
+                        guardExpression,
+                        throwStatement,
+                    });
+                const guardExpressionArgumentText = getFunctionCallArgumentText({
+                    argumentNode: guardExpression,
+                    sourceCode: context.sourceCode,
+                });
+                if (guardExpressionArgumentText === null) {
+                    reportWithOptionalFix({
+                        context,
+                        fix: null,
+                        messageId: "preferTsExtrasAssertPresent",
+                        node,
+                    });
+                    return;
+                }
+                const replacementFix = createSafeValueNodeTextReplacementFix({
+                    context,
+                    importedName: "assertPresent",
+                    imports: tsExtrasImports,
+                    replacementTextFactory: (replacementName) => `${replacementName}(${guardExpressionArgumentText});`,
+                    reportFixIntent: canAutofix
+                        ? "autofix"
+                        : "suggestion",
+                    sourceModuleName: TS_EXTRAS_MODULE_SOURCE,
+                    targetNode: node,
+                });
+                if (replacementFix === null) {
+                    reportWithOptionalFix({
+                        context,
+                        fix: null,
+                        messageId: "preferTsExtrasAssertPresent",
+                        node,
+                    });
+                    return;
+                }
+                if (canAutofix) {
+                    reportWithOptionalFix({
+                        context,
+                        fix: replacementFix,
+                        messageId: "preferTsExtrasAssertPresent",
+                        node,
+                    });
+                    return;
+                }
+                reportWithTypefestPolicy({
+                    context,
+                    descriptor: {
+                        messageId: "preferTsExtrasAssertPresent",
+                        node,
+                        suggest: [
+                            {
+                                fix: replacementFix,
+                                messageId: "suggestTsExtrasAssertPresent",
+                            },
+                        ],
+                    },
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require ts-extras assertPresent over manual nullish-guard throw blocks.",
+            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-assert-present",
+        },
+        fixable: "code",
+        hasSuggestions: true,
+        messages: {
+            preferTsExtrasAssertPresent: "Prefer `assertPresent` from `ts-extras` over manual nullish guard throw blocks.",
+            suggestTsExtrasAssertPresent: "Replace this manual guard with `assertPresent(...)` from `ts-extras`.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-ts-extras-assert-present",
+});
+/**
+ * Default export for the `prefer-ts-extras-assert-present` rule module.
+ */
+export default preferTsExtrasAssertPresentRule;
+//# sourceMappingURL=prefer-ts-extras-assert-present.js.map

package/dist/rules/prefer-ts-extras-assert-present.js.map

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

package/dist/rules/prefer-ts-extras-is-defined-filter.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-defined-filter.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-defined-filter.ts"],"names":[],"mappings":"AAcA,OAAO,EACH,eAAe,EAElB,MAAM,4BAA4B,CAAC;AAiCpC;;;;;GAKG;AACH,QAAA,MAAM,iCAAiC,EAAE,UAAU,CAAC,OAAO,eAAe,CAwEpE,CAAC;AAEP;;GAEG;AACH,eAAe,iCAAiC,CAAC"}

package/dist/rules/prefer-ts-extras-is-defined-filter.js

@@ -0,0 +1,90 @@
+import { getSingleParameterExpressionArrowFilterCallback } from "../_internal/filter-callback.js";
+import { collectDirectNamedValueImportsFromSource, createSafeValueReferenceReplacementFix, } from "../_internal/imported-value-symbols.js";
+import { TS_EXTRAS_MODULE_SOURCE } from "../_internal/module-source.js";
+import { getNullishComparison } from "../_internal/nullish-comparison.js";
+import { reportWithOptionalFix } from "../_internal/rule-reporting.js";
+import { createTypedRule, isGlobalUndefinedIdentifier, } from "../_internal/typed-rule.js";
+/**
+ * Check whether a callback body is a supported undefined guard expression.
+ *
+ * @param context - Active rule context for global-binding checks.
+ * @param body - Callback body expression to inspect.
+ * @param parameterName - Callback parameter name.
+ *
+ * @returns `true` when the body can be replaced with `isDefined`.
+ */
+const isUndefinedFilterGuardBody = (context, body, parameterName) => {
+    const comparison = getNullishComparison({
+        allowedOperators: ["!=", "!=="],
+        allowTypeofComparedIdentifierForUndefined: true,
+        comparedIdentifierName: parameterName,
+        expression: body,
+        isGlobalUndefinedIdentifier: (candidateExpression) => isGlobalUndefinedIdentifier(context, candidateExpression),
+    });
+    return comparison?.kind === "undefined";
+};
+/**
+ * ESLint rule definition for `prefer-ts-extras-is-defined-filter`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTsExtrasIsDefinedFilterRule = createTypedRule({
+    create(context) {
+        const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+        return {
+            'CallExpression[callee.type="MemberExpression"][callee.property.type="Identifier"][callee.property.name="filter"]'(node) {
+                const callbackMatch = getSingleParameterExpressionArrowFilterCallback(node);
+                if (!callbackMatch) {
+                    return;
+                }
+                const { callback, parameter } = callbackMatch;
+                if (!isUndefinedFilterGuardBody(context, callback.body, parameter.name)) {
+                    return;
+                }
+                reportWithOptionalFix({
+                    context,
+                    fix: createSafeValueReferenceReplacementFix({
+                        context,
+                        importedName: "isDefined",
+                        imports: tsExtrasImports,
+                        sourceModuleName: TS_EXTRAS_MODULE_SOURCE,
+                        targetNode: callback,
+                    }),
+                    messageId: "preferTsExtrasIsDefinedFilter",
+                    node: callback,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require ts-extras isDefined in Array.filter callbacks instead of inline undefined checks.",
+            frozen: false,
+            recommended: true,
+            requiresTypeChecking: false,
+            typefestConfigs: [
+                "typefest.configs.minimal",
+                "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-defined-filter",
+        },
+        fixable: "code",
+        messages: {
+            preferTsExtrasIsDefinedFilter: "Prefer `isDefined` from `ts-extras` in `filter(...)` callbacks over inline undefined comparisons.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-ts-extras-is-defined-filter",
+});
+/**
+ * Default export for the `prefer-ts-extras-is-defined-filter` rule module.
+ */
+export default preferTsExtrasIsDefinedFilterRule;
+//# sourceMappingURL=prefer-ts-extras-is-defined-filter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-defined-filter.js","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-defined-filter.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,+CAA+C,EAAE,MAAM,iCAAiC,CAAC;AAClG,OAAO,EACH,wCAAwC,EACxC,sCAAsC,GACzC,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EACH,eAAe,EACf,2BAA2B,GAC9B,MAAM,4BAA4B,CAAC;AAOpC;;;;;;;;GAQG;AACH,MAAM,0BAA0B,GAAG,CAC/B,OAAoB,EACpB,IAAmC,EACnC,aAAqB,EACd,EAAE;IACT,MAAM,UAAU,GAAG,oBAAoB,CAAC;QACpC,gBAAgB,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC;QAC/B,yCAAyC,EAAE,IAAI;QAC/C,sBAAsB,EAAE,aAAa;QACrC,UAAU,EAAE,IAAI;QAChB,2BAA2B,EAAE,CAAC,mBAAmB,EAAE,EAAE,CACjD,2BAA2B,CAAC,OAAO,EAAE,mBAAmB,CAAC;KAChE,CAAC,CAAC;IAEH,OAAO,UAAU,EAAE,IAAI,KAAK,WAAW,CAAC;AAC5C,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,iCAAiC,GACnC,eAAe,CAAC;IACZ,MAAM,CAAC,OAAO;QACV,MAAM,eAAe,GAAG,wCAAwC,CAC5D,OAAO,CAAC,UAAU,EAClB,uBAAuB,CAC1B,CAAC;QAEF,OAAO;YACH,kHAAkH,CAC9G,IAAI;gBAEJ,MAAM,aAAa,GACf,+CAA+C,CAAC,IAAI,CAAC,CAAC;gBAC1D,IAAI,CAAC,aAAa,EAAE,CAAC;oBACjB,OAAO;gBACX,CAAC;gBAED,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,aAAa,CAAC;gBAE9C,IACI,CAAC,0BAA0B,CACvB,OAAO,EACP,QAAQ,CAAC,IAAI,EACb,SAAS,CAAC,IAAI,CACjB,EACH,CAAC;oBACC,OAAO;gBACX,CAAC;gBAED,qBAAqB,CAAC;oBAClB,OAAO;oBACP,GAAG,EAAE,sCAAsC,CAAC;wBACxC,OAAO;wBACP,YAAY,EAAE,WAAW;wBACzB,OAAO,EAAE,eAAe;wBACxB,gBAAgB,EAAE,uBAAuB;wBACzC,UAAU,EAAE,QAAQ;qBACvB,CAAC;oBACF,SAAS,EAAE,+BAA+B;oBAC1C,IAAI,EAAE,QAAQ;iBACjB,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,2FAA2F;YAC/F,MAAM,EAAE,KAAK;YACb,WAAW,EAAE,IAAI;YACjB,oBAAoB,EAAE,KAAK;YAC3B,eAAe,EAAE;gBACb,0BAA0B;gBAC1B,8BAA8B;gBAC9B,yBAAyB;gBACzB,sBAAsB;gBACtB,wCAAwC;aAC3C;YACD,GAAG,EAAE,mGAAmG;SAC3G;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACN,6BAA6B,EACzB,mGAAmG;SAC1G;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACrB;IACD,IAAI,EAAE,oCAAoC;CAC7C,CAAC,CAAC;AAEP;;GAEG;AACH,eAAe,iCAAiC,CAAC"}

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

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

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

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

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

@@ -0,0 +1,179 @@
+import { isWithinFilterCallback } from "../_internal/filter-callback.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 { safeTypeOperation } from "../_internal/safe-type-operation.js";
+import { getVariableInScopeChain } from "../_internal/scope-variable.js";
+import { isTypePredicateExpressionAutofixSafe } from "../_internal/type-predicate-autofix-safety.js";
+import { createTypedRule, getTypedRuleServicesOrUndefined, isGlobalUndefinedIdentifier, } from "../_internal/typed-rule.js";
+import { createTypeScriptEslintNodeExpressionSkipChecker } from "../_internal/typescript-eslint-node-autofix.js";
+/**
+ * Narrow an expression to an Identifier with an expected name.
+ */
+const isIdentifierWithName = (expression, name) => expression.type === "Identifier" && expression.name === name;
+/**
+ * Narrow an expression to a `typeof ...` unary expression.
+ */
+const isTypeofExpression = (expression) => expression.type === "UnaryExpression" && expression.operator === "typeof";
+/**
+ * Check whether an identifier expression resolves to a bound symbol in scope.
+ *
+ * @remarks
+ * This prevents rewriting `typeof` checks where the identifier would be treated
+ * as an unbound global reference.
+ */
+const isBoundIdentifierReference = (context, expression) => {
+    if (expression.type !== "Identifier") {
+        return true;
+    }
+    const result = safeTypeOperation({
+        operation: () => {
+            const initialScope = context.sourceCode.getScope(expression);
+            const variable = getVariableInScopeChain(initialScope, expression.name);
+            return variable !== null && variable.defs.length > 0;
+        },
+        reason: "is-defined-scope-resolution-failed",
+    });
+    if (!result.ok) {
+        return false;
+    }
+    return result.value;
+};
+/**
+ * Narrow an expression to the string literal `"undefined"`.
+ */
+const isUndefinedStringLiteral = (expression) => expression.type === "Literal" && expression.value === "undefined";
+/**
+ * Determine whether an expression references the global `undefined` binding.
+ *
+ * @param context - Active rule context for scope resolution.
+ * @param expression - Expression node to inspect.
+ *
+ * @returns `true` when the expression is an unshadowed `undefined` identifier.
+ */
+const isUndefinedIdentifier = (context, expression) => isIdentifierWithName(expression, "undefined") &&
+    isGlobalUndefinedIdentifier(context, expression);
+/**
+ * Match supported undefined-comparison patterns used by this rule.
+ *
+ * @param context - Active rule context for global-binding checks.
+ * @param node - Binary expression to inspect.
+ *
+ * @returns Comparison metadata when the expression is supported; otherwise
+ *   `null`.
+ */
+const getUndefinedComparisonMatch = (context, node) => {
+    const isPositiveComparison = node.operator === "!==";
+    const isNegativeComparison = node.operator === "===";
+    if (!isPositiveComparison && !isNegativeComparison) {
+        return null;
+    }
+    const prefersNegatedHelper = isNegativeComparison;
+    if (isUndefinedIdentifier(context, node.right)) {
+        return {
+            comparedExpression: node.left,
+            prefersNegatedHelper,
+        };
+    }
+    if (isUndefinedIdentifier(context, node.left)) {
+        return {
+            comparedExpression: node.right,
+            prefersNegatedHelper,
+        };
+    }
+    if (isTypeofExpression(node.left) && isUndefinedStringLiteral(node.right)) {
+        if (!isBoundIdentifierReference(context, node.left.argument)) {
+            return null;
+        }
+        return {
+            comparedExpression: node.left.argument,
+            prefersNegatedHelper,
+        };
+    }
+    if (isTypeofExpression(node.right) && isUndefinedStringLiteral(node.left)) {
+        if (!isBoundIdentifierReference(context, node.right.argument)) {
+            return null;
+        }
+        return {
+            comparedExpression: node.right.argument,
+            prefersNegatedHelper,
+        };
+    }
+    return null;
+};
+/**
+ * ESLint rule definition for `prefer-ts-extras-is-defined`.
+ *
+ * @remarks
+ * Defines metadata, diagnostics, and suggestions/fixes for this rule.
+ */
+const preferTsExtrasIsDefinedRule = createTypedRule({
+    create(context) {
+        const tsExtrasImports = collectDirectNamedValueImportsFromSource(context.sourceCode, TS_EXTRAS_MODULE_SOURCE);
+        const typedServices = getTypedRuleServicesOrUndefined(context);
+        const shouldSkipComparedExpression = createTypeScriptEslintNodeExpressionSkipChecker(context, typedServices);
+        return {
+            BinaryExpression(node) {
+                if (isWithinFilterCallback(node)) {
+                    return;
+                }
+                const match = getUndefinedComparisonMatch(context, node);
+                if (!match) {
+                    return;
+                }
+                if (shouldSkipComparedExpression(match.comparedExpression)) {
+                    return;
+                }
+                const canAutofix = isTypePredicateExpressionAutofixSafe(node);
+                reportWithOptionalFix({
+                    context,
+                    fix: canAutofix
+                        ? createSafeValueArgumentFunctionCallFix({
+                            argumentNode: match.comparedExpression,
+                            context,
+                            importedName: "isDefined",
+                            imports: tsExtrasImports,
+                            negated: match.prefersNegatedHelper,
+                            sourceModuleName: TS_EXTRAS_MODULE_SOURCE,
+                            targetNode: node,
+                        })
+                        : null,
+                    messageId: match.prefersNegatedHelper
+                        ? "preferTsExtrasIsDefinedNegated"
+                        : "preferTsExtrasIsDefined",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        deprecated: false,
+        docs: {
+            description: "require ts-extras isDefined over inline undefined comparisons outside filter callbacks.",
+            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-defined",
+        },
+        fixable: "code",
+        messages: {
+            preferTsExtrasIsDefined: "Prefer `isDefined(value)` from `ts-extras` over inline undefined comparisons.",
+            preferTsExtrasIsDefinedNegated: "Prefer `!isDefined(value)` from `ts-extras` over inline undefined comparisons.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-ts-extras-is-defined",
+});
+/**
+ * Default export for the `prefer-ts-extras-is-defined` rule module.
+ */
+export default preferTsExtrasIsDefinedRule;
+//# sourceMappingURL=prefer-ts-extras-is-defined.js.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-ts-extras-is-empty.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-ts-extras-is-empty.ts"],"names":[],"mappings":"AAaA,OAAO,EACH,eAAe,EAElB,MAAM,4BAA4B,CAAC;AA+BpC;;;;;GAKG;AACH,QAAA,MAAM,yBAAyB,EAAE,UAAU,CAAC,OAAO,eAAe,CAgG5D,CAAC;AAEP;;GAEG;AACH,eAAe,yBAAyB,CAAC"}