@typescript-eslint/eslint-plugin 8.24.2-alpha.1 → 8.24.2-alpha.2

package/dist/rules/prefer-find.js

@@ -248,4 +248,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=prefer-find.js.map

package/dist/rules/prefer-for-of.d.ts

@@ -0,0 +1,4 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const _default: TSESLint.RuleModule<"preferForOf", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-for-of.d.ts.map

package/dist/rules/prefer-for-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-for-of.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-for-of.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;;AAMnE,wBAgKG"}

package/dist/rules/prefer-for-of.js

@@ -113,4 +113,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=prefer-for-of.js.map

package/dist/rules/prefer-function-type.d.ts

@@ -0,0 +1,8 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export declare const phrases: {
+    readonly TSInterfaceDeclaration: "Interface";
+    readonly TSTypeLiteral: "Type literal";
+};
+declare const _default: TSESLint.RuleModule<"functionTypeOverCallableType" | "unexpectedThisOnFunctionOnlyInterface", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-function-type.d.ts.map

package/dist/rules/prefer-function-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-function-type.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-function-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,eAAO,MAAM,OAAO;;;CAGV,CAAC;;AAEX,wBAsNG"}

package/dist/rules/prefer-function-type.js

@@ -184,4 +184,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=prefer-function-type.js.map

package/dist/rules/prefer-includes.d.ts

@@ -0,0 +1,4 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const _default: TSESLint.RuleModule<"preferIncludes" | "preferStringIncludes", [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-includes.d.ts.map

package/dist/rules/prefer-includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-includes.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-includes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;;AAcnE,wBAkQG"}

package/dist/rules/prefer-includes.js

@@ -240,4 +240,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=prefer-includes.js.map

package/dist/rules/prefer-literal-enum-member.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"notLiteral" | "notLiteralOrBitwiseExpression", [{
+    allowBitwiseExpressions: boolean;
+}], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-literal-enum-member.d.ts.map

package/dist/rules/prefer-literal-enum-member.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-literal-enum-member.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-literal-enum-member.ts"],"names":[],"mappings":";;;AAMA,wBAmJG"}

package/dist/rules/prefer-literal-enum-member.js

@@ -114,4 +114,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=prefer-literal-enum-member.js.map

package/dist/rules/prefer-namespace-keyword.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useNamespace", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-namespace-keyword.d.ts.map

package/dist/rules/prefer-namespace-keyword.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-namespace-keyword.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-namespace-keyword.ts"],"names":[],"mappings":";AAIA,wBA2CG"}

package/dist/rules/prefer-namespace-keyword.js

@@ -41,4 +41,3 @@ exports.default = (0, util_1.createRule)({
         };
     },
 });
-//# sourceMappingURL=prefer-namespace-keyword.js.map

package/dist/rules/prefer-nullish-coalescing.d.ts

@@ -0,0 +1,20 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type Options = [
+    {
+        allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
+        ignoreBooleanCoercion?: boolean;
+        ignoreConditionalTests?: boolean;
+        ignoreMixedLogicalExpressions?: boolean;
+        ignorePrimitives?: {
+            bigint?: boolean;
+            boolean?: boolean;
+            number?: boolean;
+            string?: boolean;
+        } | true;
+        ignoreTernaryTests?: boolean;
+    }
+];
+export type MessageIds = 'noStrictNullCheck' | 'preferNullishOverOr' | 'preferNullishOverTernary' | 'suggestNullish';
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-nullish-coalescing.d.ts.map

package/dist/rules/prefer-nullish-coalescing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-nullish-coalescing.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-nullish-coalescing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AA0BnE,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sDAAsD,CAAC,EAAE,OAAO,CAAC;QACjE,qBAAqB,CAAC,EAAE,OAAO,CAAC;QAChC,sBAAsB,CAAC,EAAE,OAAO,CAAC;QACjC,6BAA6B,CAAC,EAAE,OAAO,CAAC;QACxC,gBAAgB,CAAC,EACb;YACE,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,OAAO,CAAC,EAAE,OAAO,CAAC;YAClB,MAAM,CAAC,EAAE,OAAO,CAAC;YACjB,MAAM,CAAC,EAAE,OAAO,CAAC;SAClB,GACD,IAAI,CAAC;QACT,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,mBAAmB,GACnB,qBAAqB,GACrB,0BAA0B,GAC1B,gBAAgB,CAAC;;AAErB,wBA+dG"}

package/dist/rules/prefer-nullish-coalescing.js

@@ -483,4 +483,3 @@ function isMixedLogicalExpression(node) {
     }
     return false;
 }
-//# sourceMappingURL=prefer-nullish-coalescing.js.map

package/dist/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.d.ts

@@ -0,0 +1,12 @@
+export type PreferOptionalChainMessageIds = 'optionalChainSuggest' | 'preferOptionalChain';
+export interface PreferOptionalChainOptions {
+    allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing?: boolean;
+    checkAny?: boolean;
+    checkBigInt?: boolean;
+    checkBoolean?: boolean;
+    checkNumber?: boolean;
+    checkString?: boolean;
+    checkUnknown?: boolean;
+    requireNullish?: boolean;
+}
+//# sourceMappingURL=PreferOptionalChainOptions.d.ts.map

package/dist/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreferOptionalChainOptions.d.ts","sourceRoot":"","sources":["../../../src/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,6BAA6B,GACrC,sBAAsB,GACtB,qBAAqB,CAAC;AAE1B,MAAM,WAAW,0BAA0B;IACzC,kEAAkE,CAAC,EAAE,OAAO,CAAC;IAC7E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B"}

package/dist/rules/prefer-optional-chain-utils/PreferOptionalChainOptions.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=PreferOptionalChainOptions.js.map

package/dist/rules/prefer-optional-chain-utils/analyzeChain.d.ts

@@ -0,0 +1,8 @@
+import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
+import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';
+import type { ValidOperand } from './gatherLogicalOperands';
+import type { PreferOptionalChainMessageIds, PreferOptionalChainOptions } from './PreferOptionalChainOptions';
+export declare function analyzeChain(context: RuleContext<PreferOptionalChainMessageIds, [
+    PreferOptionalChainOptions
+]>, parserServices: ParserServicesWithTypeInformation, options: PreferOptionalChainOptions, node: TSESTree.Node, operator: TSESTree.LogicalExpression['operator'], chain: ValidOperand[]): void;
+//# sourceMappingURL=analyzeChain.d.ts.map

package/dist/rules/prefer-optional-chain-utils/analyzeChain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeChain.d.ts","sourceRoot":"","sources":["../../../src/rules/prefer-optional-chain-utils/analyzeChain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EACjC,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAGV,WAAW,EAEZ,MAAM,oCAAoC,CAAC;AAM5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EACV,6BAA6B,EAC7B,0BAA0B,EAC3B,MAAM,8BAA8B,CAAC;AA8etC,wBAAgB,YAAY,CAC1B,OAAO,EAAE,WAAW,CAClB,6BAA6B,EAC7B;IAAC,0BAA0B;CAAC,CAC7B,EACD,cAAc,EAAE,iCAAiC,EACjD,OAAO,EAAE,0BAA0B,EACnC,IAAI,EAAE,QAAQ,CAAC,IAAI,EACnB,QAAQ,EAAE,QAAQ,CAAC,iBAAiB,CAAC,UAAU,CAAC,EAChD,KAAK,EAAE,YAAY,EAAE,GACpB,IAAI,CA0GN"}

package/dist/rules/prefer-optional-chain-utils/analyzeChain.js

@@ -40,6 +40,7 @@ const ts = __importStar(require("typescript"));
 const util_1 = require("../../util");
 const checkNullishAndReport_1 = require("./checkNullishAndReport");
 const compareNodes_1 = require("./compareNodes");
+const gatherLogicalOperands_1 = require("./gatherLogicalOperands");
 function includesType(parserServices, node, typeFlagIn) {
     const typeFlag = typeFlagIn | ts.TypeFlags.Any | ts.TypeFlags.Unknown;
     const types = (0, ts_api_utils_1.unionTypeParts)(parserServices.getTypeAtLocation(node));
@@ -52,24 +53,24 @@ function includesType(parserServices, node, typeFlagIn) {
 }
 const analyzeAndChainOperand = (parserServices, operand, index, chain) => {
     switch (operand.comparisonType) {
-        case "Boolean" /* NullishComparisonType.Boolean */: {
+        case gatherLogicalOperands_1.NullishComparisonType.Boolean: {
             const nextOperand = chain.at(index + 1);
             if (nextOperand?.comparisonType ===
-                "NotStrictEqualNull" /* NullishComparisonType.NotStrictEqualNull */ &&
+                gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualNull &&
                 operand.comparedName.type === utils_1.AST_NODE_TYPES.Identifier) {
                 return null;
             }
             return [operand];
         }
-        case "NotEqualNullOrUndefined" /* NullishComparisonType.NotEqualNullOrUndefined */:
+        case gatherLogicalOperands_1.NullishComparisonType.NotEqualNullOrUndefined:
             return [operand];
-        case "NotStrictEqualNull" /* NullishComparisonType.NotStrictEqualNull */: {
+        case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualNull: {
             // handle `x !== null && x !== undefined`
             const nextOperand = chain.at(index + 1);
             if (nextOperand?.comparisonType ===
-                "NotStrictEqualUndefined" /* NullishComparisonType.NotStrictEqualUndefined */ &&
+                gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualUndefined &&
                 (0, compareNodes_1.compareNodes)(operand.comparedName, nextOperand.comparedName) ===
-                    "Equal" /* NodeComparisonResult.Equal */) {
+                    compareNodes_1.NodeComparisonResult.Equal) {
                 return [operand, nextOperand];
             }
             if (includesType(parserServices, operand.comparedName, ts.TypeFlags.Undefined)) {
@@ -80,13 +81,13 @@ const analyzeAndChainOperand = (parserServices, operand, index, chain) => {
             }
             return [operand];
         }
-        case "NotStrictEqualUndefined" /* NullishComparisonType.NotStrictEqualUndefined */: {
+        case gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualUndefined: {
             // handle `x !== undefined && x !== null`
             const nextOperand = chain.at(index + 1);
             if (nextOperand?.comparisonType ===
-                "NotStrictEqualNull" /* NullishComparisonType.NotStrictEqualNull */ &&
+                gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualNull &&
                 (0, compareNodes_1.compareNodes)(operand.comparedName, nextOperand.comparedName) ===
-                    "Equal" /* NodeComparisonResult.Equal */) {
+                    compareNodes_1.NodeComparisonResult.Equal) {
                 return [operand, nextOperand];
             }
             if (includesType(parserServices, operand.comparedName, ts.TypeFlags.Null)) {
@@ -103,16 +104,16 @@ const analyzeAndChainOperand = (parserServices, operand, index, chain) => {
 };
 const analyzeOrChainOperand = (parserServices, operand, index, chain) => {
     switch (operand.comparisonType) {
-        case "NotBoolean" /* NullishComparisonType.NotBoolean */:
-        case "EqualNullOrUndefined" /* NullishComparisonType.EqualNullOrUndefined */:
+        case gatherLogicalOperands_1.NullishComparisonType.NotBoolean:
+        case gatherLogicalOperands_1.NullishComparisonType.EqualNullOrUndefined:
             return [operand];
-        case "StrictEqualNull" /* NullishComparisonType.StrictEqualNull */: {
+        case gatherLogicalOperands_1.NullishComparisonType.StrictEqualNull: {
             // handle `x === null || x === undefined`
             const nextOperand = chain.at(index + 1);
             if (nextOperand?.comparisonType ===
-                "StrictEqualUndefined" /* NullishComparisonType.StrictEqualUndefined */ &&
+                gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined &&
                 (0, compareNodes_1.compareNodes)(operand.comparedName, nextOperand.comparedName) ===
-                    "Equal" /* NodeComparisonResult.Equal */) {
+                    compareNodes_1.NodeComparisonResult.Equal) {
                 return [operand, nextOperand];
             }
             if (includesType(parserServices, operand.comparedName, ts.TypeFlags.Undefined)) {
@@ -123,12 +124,12 @@ const analyzeOrChainOperand = (parserServices, operand, index, chain) => {
             }
             return [operand];
         }
-        case "StrictEqualUndefined" /* NullishComparisonType.StrictEqualUndefined */: {
+        case gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined: {
             // handle `x === undefined || x === null`
             const nextOperand = chain.at(index + 1);
-            if (nextOperand?.comparisonType === "StrictEqualNull" /* NullishComparisonType.StrictEqualNull */ &&
+            if (nextOperand?.comparisonType === gatherLogicalOperands_1.NullishComparisonType.StrictEqualNull &&
                 (0, compareNodes_1.compareNodes)(operand.comparedName, nextOperand.comparedName) ===
-                    "Equal" /* NodeComparisonResult.Equal */) {
+                    compareNodes_1.NodeComparisonResult.Equal) {
                 return [operand, nextOperand];
             }
             if (includesType(parserServices, operand.comparedName, ts.TypeFlags.Null)) {
@@ -183,14 +184,14 @@ function getReportDescriptor(sourceCode, parserServices, node, operator, options
     // so we need to make sure that there is at least one operand that includes
     // `undefined`, or else we're going to change the final type - which is
     // unsafe and might cause downstream type errors.
-    else if (lastOperand.comparisonType === "EqualNullOrUndefined" /* NullishComparisonType.EqualNullOrUndefined */ ||
+    else if (lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.EqualNullOrUndefined ||
         lastOperand.comparisonType ===
-            "NotEqualNullOrUndefined" /* NullishComparisonType.NotEqualNullOrUndefined */ ||
-        lastOperand.comparisonType === "StrictEqualUndefined" /* NullishComparisonType.StrictEqualUndefined */ ||
+            gatherLogicalOperands_1.NullishComparisonType.NotEqualNullOrUndefined ||
+        lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.StrictEqualUndefined ||
         lastOperand.comparisonType ===
-            "NotStrictEqualUndefined" /* NullishComparisonType.NotStrictEqualUndefined */ ||
+            gatherLogicalOperands_1.NullishComparisonType.NotStrictEqualUndefined ||
         (operator === '||' &&
-            lastOperand.comparisonType === "NotBoolean" /* NullishComparisonType.NotBoolean */)) {
+            lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.NotBoolean)) {
         // we know the last operand is an equality check - so the change in types
         // DOES NOT matter and will not change the runtime result or cause a type
         // check error
@@ -304,7 +305,7 @@ function getReportDescriptor(sourceCode, parserServices, node, operator, options
         })();
         newCode = `${left} ${operator} ${right}`;
     }
-    else if (lastOperand.comparisonType === "NotBoolean" /* NullishComparisonType.NotBoolean */) {
+    else if (lastOperand.comparisonType === gatherLogicalOperands_1.NullishComparisonType.NotBoolean) {
         newCode = `!${newCode}`;
     }
     const reportRange = getReportRange(chain, node.range, sourceCode);
@@ -444,11 +445,11 @@ function analyzeChain(context, parserServices, options, node, operator, chain) {
             // this also means we won't false-positive in cases like
             // foo !== null && foo !== undefined
             validatedOperands[validatedOperands.length - 1].comparedName);
-            if (comparisonResult === "Subset" /* NodeComparisonResult.Subset */) {
+            if (comparisonResult === compareNodes_1.NodeComparisonResult.Subset) {
                 // the operands are comparable, so we can continue searching
                 subChain.push(currentOperand);
             }
-            else if (comparisonResult === "Invalid" /* NodeComparisonResult.Invalid */) {
+            else if (comparisonResult === compareNodes_1.NodeComparisonResult.Invalid) {
                 maybeReportThenReset(validatedOperands);
             }
             else {
@@ -464,4 +465,3 @@ function analyzeChain(context, parserServices, options, node, operator, chain) {
     // check the leftovers
     maybeReportThenReset();
 }
-//# sourceMappingURL=analyzeChain.js.map

package/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.d.ts

@@ -0,0 +1,7 @@
+import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
+import type { ReportDescriptor, RuleContext } from '@typescript-eslint/utils/ts-eslint';
+import type { PreferOptionalChainMessageIds, PreferOptionalChainOptions } from './PreferOptionalChainOptions';
+export declare function checkNullishAndReport(context: RuleContext<PreferOptionalChainMessageIds, [
+    PreferOptionalChainOptions
+]>, parserServices: ParserServicesWithTypeInformation, { requireNullish }: PreferOptionalChainOptions, maybeNullishNodes: TSESTree.Expression[], descriptor: ReportDescriptor<PreferOptionalChainMessageIds>): void;
+//# sourceMappingURL=checkNullishAndReport.d.ts.map

package/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkNullishAndReport.d.ts","sourceRoot":"","sources":["../../../src/rules/prefer-optional-chain-utils/checkNullishAndReport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EACjC,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACZ,MAAM,oCAAoC,CAAC;AAM5C,OAAO,KAAK,EACV,6BAA6B,EAC7B,0BAA0B,EAC3B,MAAM,8BAA8B,CAAC;AAEtC,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,WAAW,CAClB,6BAA6B,EAC7B;IAAC,0BAA0B;CAAC,CAC7B,EACD,cAAc,EAAE,iCAAiC,EACjD,EAAE,cAAc,EAAE,EAAE,0BAA0B,EAC9C,iBAAiB,EAAE,QAAQ,CAAC,UAAU,EAAE,EACxC,UAAU,EAAE,gBAAgB,CAAC,6BAA6B,CAAC,GAC1D,IAAI,CAWN"}

package/dist/rules/prefer-optional-chain-utils/checkNullishAndReport.js

@@ -43,4 +43,3 @@ function checkNullishAndReport(context, parserServices, { requireNullish }, mayb
         context.report(descriptor);
     }
 }
-//# sourceMappingURL=checkNullishAndReport.js.map

package/dist/rules/prefer-optional-chain-utils/compareNodes.d.ts

@@ -0,0 +1,16 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export declare const enum NodeComparisonResult {
+    /** the two nodes are comparably the same */
+    Equal = "Equal",
+    /** the left node is a subset of the right node */
+    Subset = "Subset",
+    /** the left node is not the same or is a superset of the right node */
+    Invalid = "Invalid"
+}
+type CompareNodesArgument = TSESTree.Node | null | undefined;
+/**
+ * Compares two nodes' ASTs to determine if the A is equal to or a subset of B
+ */
+export declare function compareNodes(nodeA: CompareNodesArgument, nodeB: CompareNodesArgument): NodeComparisonResult;
+export {};
+//# sourceMappingURL=compareNodes.d.ts.map

package/dist/rules/prefer-optional-chain-utils/compareNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareNodes.d.ts","sourceRoot":"","sources":["../../../src/rules/prefer-optional-chain-utils/compareNodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAKzD,0BAAkB,oBAAoB;IACpC,4CAA4C;IAC5C,KAAK,UAAU;IACf,kDAAkD;IAClD,MAAM,WAAW;IACjB,uEAAuE;IACvE,OAAO,YAAY;CACpB;AA8GD,KAAK,oBAAoB,GAAG,QAAQ,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;AAuQ7D;;GAEG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,oBAAoB,EAC3B,KAAK,EAAE,oBAAoB,GAC1B,oBAAoB,CAqBtB"}

package/dist/rules/prefer-optional-chain-utils/compareNodes.js

@@ -1,23 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeComparisonResult = void 0;
 exports.compareNodes = compareNodes;
 const utils_1 = require("@typescript-eslint/utils");
 const visitor_keys_1 = require("@typescript-eslint/visitor-keys");
+var NodeComparisonResult;
+(function (NodeComparisonResult) {
+    /** the two nodes are comparably the same */
+    NodeComparisonResult["Equal"] = "Equal";
+    /** the left node is a subset of the right node */
+    NodeComparisonResult["Subset"] = "Subset";
+    /** the left node is not the same or is a superset of the right node */
+    NodeComparisonResult["Invalid"] = "Invalid";
+})(NodeComparisonResult || (exports.NodeComparisonResult = NodeComparisonResult = {}));
 function compareArrays(arrayA, arrayB) {
     if (arrayA.length !== arrayB.length) {
-        return "Invalid" /* NodeComparisonResult.Invalid */;
+        return NodeComparisonResult.Invalid;
     }
     const result = arrayA.every((elA, idx) => {
         const elB = arrayB[idx];
         if (elA == null || elB == null) {
             return elA === elB;
         }
-        return compareUnknownValues(elA, elB) === "Equal" /* NodeComparisonResult.Equal */;
+        return compareUnknownValues(elA, elB) === NodeComparisonResult.Equal;
     });
     if (result) {
-        return "Equal" /* NodeComparisonResult.Equal */;
+        return NodeComparisonResult.Equal;
     }
-    return "Invalid" /* NodeComparisonResult.Invalid */;
+    return NodeComparisonResult.Invalid;
 }
 function isValidNode(x) {
     return (typeof x === 'object' &&
@@ -36,13 +46,13 @@ function compareUnknownValues(valueA, valueB) {
     /* istanbul ignore if -- not possible for us to test this - it's just a sanity safeguard */
     if (valueA == null || valueB == null) {
         if (valueA !== valueB) {
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         }
-        return "Equal" /* NodeComparisonResult.Equal */;
+        return NodeComparisonResult.Equal;
     }
     /* istanbul ignore if -- not possible for us to test this - it's just a sanity safeguard */
     if (!isValidNode(valueA) || !isValidNode(valueB)) {
-        return "Invalid" /* NodeComparisonResult.Invalid */;
+        return NodeComparisonResult.Invalid;
     }
     return compareNodes(valueA, valueB);
 }
@@ -51,11 +61,11 @@ function compareByVisiting(nodeA, nodeB) {
     /* istanbul ignore if -- not possible for us to test this - it's just a sanity safeguard */
     if (currentVisitorKeys == null) {
         // we don't know how to visit this node, so assume it's invalid to avoid false-positives / broken fixers
-        return "Invalid" /* NodeComparisonResult.Invalid */;
+        return NodeComparisonResult.Invalid;
     }
     if (currentVisitorKeys.length === 0) {
         // assume nodes with no keys are constant things like keywords
-        return "Equal" /* NodeComparisonResult.Equal */;
+        return NodeComparisonResult.Equal;
     }
     for (const key of currentVisitorKeys) {
         // @ts-expect-error - dynamic access but it's safe
@@ -66,20 +76,20 @@ function compareByVisiting(nodeA, nodeB) {
             const arrayA = nodeAChildOrChildren;
             const arrayB = nodeBChildOrChildren;
             const result = compareArrays(arrayA, arrayB);
-            if (result !== "Equal" /* NodeComparisonResult.Equal */) {
-                return "Invalid" /* NodeComparisonResult.Invalid */;
+            if (result !== NodeComparisonResult.Equal) {
+                return NodeComparisonResult.Invalid;
             }
             // fallthrough to the next key as the key was "equal"
         }
         else {
             const result = compareUnknownValues(nodeAChildOrChildren, nodeBChildOrChildren);
-            if (result !== "Equal" /* NodeComparisonResult.Equal */) {
-                return "Invalid" /* NodeComparisonResult.Invalid */;
+            if (result !== NodeComparisonResult.Equal) {
+                return NodeComparisonResult.Invalid;
             }
             // fallthrough to the next key as the key was "equal"
         }
     }
-    return "Equal" /* NodeComparisonResult.Equal */;
+    return NodeComparisonResult.Equal;
 }
 function compareNodesUncached(nodeA, nodeB) {
     if (nodeA.type !== nodeB.type) {
@@ -133,22 +143,22 @@ function compareNodesUncached(nodeA, nodeB) {
                     if (nodeB.property.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
                         // Private identifiers in optional chaining is not currently allowed
                         // TODO - handle this once TS supports it (https://github.com/microsoft/TypeScript/issues/42734)
-                        return "Invalid" /* NodeComparisonResult.Invalid */;
+                        return NodeComparisonResult.Invalid;
                     }
-                    if (compareNodes(nodeA, nodeB.object) !== "Invalid" /* NodeComparisonResult.Invalid */) {
-                        return "Subset" /* NodeComparisonResult.Subset */;
+                    if (compareNodes(nodeA, nodeB.object) !== NodeComparisonResult.Invalid) {
+                        return NodeComparisonResult.Subset;
                     }
-                    return "Invalid" /* NodeComparisonResult.Invalid */;
+                    return NodeComparisonResult.Invalid;
                 case utils_1.AST_NODE_TYPES.CallExpression:
-                    if (compareNodes(nodeA, nodeB.callee) !== "Invalid" /* NodeComparisonResult.Invalid */) {
-                        return "Subset" /* NodeComparisonResult.Subset */;
+                    if (compareNodes(nodeA, nodeB.callee) !== NodeComparisonResult.Invalid) {
+                        return NodeComparisonResult.Subset;
                     }
-                    return "Invalid" /* NodeComparisonResult.Invalid */;
+                    return NodeComparisonResult.Invalid;
                 default:
-                    return "Invalid" /* NodeComparisonResult.Invalid */;
+                    return NodeComparisonResult.Invalid;
             }
         }
-        return "Invalid" /* NodeComparisonResult.Invalid */;
+        return NodeComparisonResult.Invalid;
     }
     switch (nodeA.type) {
         // these expressions create a new instance each time - so it makes no sense to compare the chain
@@ -160,10 +170,10 @@ function compareNodesUncached(nodeA, nodeB) {
         case utils_1.AST_NODE_TYPES.JSXFragment:
         case utils_1.AST_NODE_TYPES.NewExpression:
         case utils_1.AST_NODE_TYPES.ObjectExpression:
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         // chaining from assignments could change the value irrevocably - so it makes no sense to compare the chain
         case utils_1.AST_NODE_TYPES.AssignmentExpression:
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         case utils_1.AST_NODE_TYPES.CallExpression: {
             const nodeBCall = nodeB;
             // check for cases like
@@ -172,12 +182,12 @@ function compareNodesUncached(nodeA, nodeB) {
             //          ^^^^^^^^^^ nodeB
             // we don't want to check the arguments in this case
             const aSubsetOfB = compareNodes(nodeA, nodeBCall.callee);
-            if (aSubsetOfB !== "Invalid" /* NodeComparisonResult.Invalid */) {
-                return "Subset" /* NodeComparisonResult.Subset */;
+            if (aSubsetOfB !== NodeComparisonResult.Invalid) {
+                return NodeComparisonResult.Subset;
             }
             const calleeCompare = compareNodes(nodeA.callee, nodeBCall.callee);
-            if (calleeCompare !== "Equal" /* NodeComparisonResult.Equal */) {
-                return "Invalid" /* NodeComparisonResult.Invalid */;
+            if (calleeCompare !== NodeComparisonResult.Equal) {
+                return NodeComparisonResult.Invalid;
             }
             // NOTE - we purposely ignore optional flag because for our purposes
             // foo?.bar() && foo.bar?.()?.baz
@@ -185,14 +195,14 @@ function compareNodesUncached(nodeA, nodeB) {
             // foo.bar() && foo?.bar?.()?.baz
             // are going to be exactly the same
             const argumentCompare = compareArrays(nodeA.arguments, nodeBCall.arguments);
-            if (argumentCompare !== "Equal" /* NodeComparisonResult.Equal */) {
-                return "Invalid" /* NodeComparisonResult.Invalid */;
+            if (argumentCompare !== NodeComparisonResult.Equal) {
+                return NodeComparisonResult.Invalid;
             }
             const typeParamCompare = compareNodes(nodeA.typeArguments, nodeBCall.typeArguments);
-            if (typeParamCompare === "Equal" /* NodeComparisonResult.Equal */) {
-                return "Equal" /* NodeComparisonResult.Equal */;
+            if (typeParamCompare === NodeComparisonResult.Equal) {
+                return NodeComparisonResult.Equal;
             }
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         }
         case utils_1.AST_NODE_TYPES.ChainExpression:
             // special case handling for ChainExpression because it's allowed to be a subset
@@ -200,23 +210,23 @@ function compareNodesUncached(nodeA, nodeB) {
         case utils_1.AST_NODE_TYPES.Identifier:
         case utils_1.AST_NODE_TYPES.PrivateIdentifier:
             if (nodeA.name === nodeB.name) {
-                return "Equal" /* NodeComparisonResult.Equal */;
+                return NodeComparisonResult.Equal;
             }
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         case utils_1.AST_NODE_TYPES.Literal: {
             const nodeBLiteral = nodeB;
             if (nodeA.raw === nodeBLiteral.raw &&
                 nodeA.value === nodeBLiteral.value) {
-                return "Equal" /* NodeComparisonResult.Equal */;
+                return NodeComparisonResult.Equal;
             }
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         }
         case utils_1.AST_NODE_TYPES.MemberExpression: {
             const nodeBMember = nodeB;
             if (nodeBMember.property.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
                 // Private identifiers in optional chaining is not currently allowed
                 // TODO - handle this once TS supports it (https://github.com/microsoft/TypeScript/issues/42734)
-                return "Invalid" /* NodeComparisonResult.Invalid */;
+                return NodeComparisonResult.Invalid;
             }
             // check for cases like
             // foo.bar && foo.bar.baz
@@ -231,11 +241,11 @@ function compareNodesUncached(nodeA, nodeB) {
             //
             // we don't want to check the property in this case
             const aSubsetOfB = compareNodes(nodeA, nodeBMember.object);
-            if (aSubsetOfB !== "Invalid" /* NodeComparisonResult.Invalid */) {
-                return "Subset" /* NodeComparisonResult.Subset */;
+            if (aSubsetOfB !== NodeComparisonResult.Invalid) {
+                return NodeComparisonResult.Subset;
             }
             if (nodeA.computed !== nodeBMember.computed) {
-                return "Invalid" /* NodeComparisonResult.Invalid */;
+                return NodeComparisonResult.Invalid;
             }
             // NOTE - we purposely ignore optional flag because for our purposes
             // foo?.bar && foo.bar?.baz
@@ -243,8 +253,8 @@ function compareNodesUncached(nodeA, nodeB) {
             // foo.bar && foo?.bar?.baz
             // are going to be exactly the same
             const objectCompare = compareNodes(nodeA.object, nodeBMember.object);
-            if (objectCompare !== "Equal" /* NodeComparisonResult.Equal */) {
-                return "Invalid" /* NodeComparisonResult.Invalid */;
+            if (objectCompare !== NodeComparisonResult.Equal) {
+                return NodeComparisonResult.Invalid;
             }
             return compareNodes(nodeA.property, nodeBMember.property);
         }
@@ -257,29 +267,29 @@ function compareNodesUncached(nodeA, nodeB) {
                     return elA.value.cooked === elB.value.cooked;
                 });
             if (!areQuasisEqual) {
-                return "Invalid" /* NodeComparisonResult.Invalid */;
+                return NodeComparisonResult.Invalid;
             }
-            return "Equal" /* NodeComparisonResult.Equal */;
+            return NodeComparisonResult.Equal;
         }
         case utils_1.AST_NODE_TYPES.TemplateElement: {
             const nodeBElement = nodeB;
             if (nodeA.value.cooked === nodeBElement.value.cooked) {
-                return "Equal" /* NodeComparisonResult.Equal */;
+                return NodeComparisonResult.Equal;
             }
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         }
         // these aren't actually valid expressions.
         // https://github.com/typescript-eslint/typescript-eslint/blob/20d7caee35ab84ae6381fdf04338c9e2b9e2bc48/packages/ast-spec/src/unions/Expression.ts#L37-L43
         case utils_1.AST_NODE_TYPES.ArrayPattern:
         case utils_1.AST_NODE_TYPES.ObjectPattern:
             /* istanbul ignore next */
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         // update expression returns a number and also changes the value each time - so it makes no sense to compare the chain
         case utils_1.AST_NODE_TYPES.UpdateExpression:
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         // yield returns the value passed to the `next` function, so it may not be the same each time - so it makes no sense to compare the chain
         case utils_1.AST_NODE_TYPES.YieldExpression:
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         // general-case automatic handling of nodes to save us implementing every
         // single case by hand. This just iterates the visitor keys to recursively
         // check the children.
@@ -297,9 +307,9 @@ const COMPARE_NODES_CACHE = new WeakMap();
 function compareNodes(nodeA, nodeB) {
     if (nodeA == null || nodeB == null) {
         if (nodeA !== nodeB) {
-            return "Invalid" /* NodeComparisonResult.Invalid */;
+            return NodeComparisonResult.Invalid;
         }
-        return "Equal" /* NodeComparisonResult.Equal */;
+        return NodeComparisonResult.Equal;
     }
     const cached = COMPARE_NODES_CACHE.get(nodeA)?.get(nodeB);
     if (cached) {
@@ -314,4 +324,3 @@ function compareNodes(nodeA, nodeB) {
     mapA.set(nodeB, result);
     return result;
 }
-//# sourceMappingURL=compareNodes.js.map