eslint-plugin-complete 1.0.0

package/dist/rules/prefer-readonly-parameter-types.js

@@ -0,0 +1,140 @@
+// cspell:ignore readonlyness
+import { isTypeReadonly, readonlynessOptionsDefaults, readonlynessOptionsSchema, } from "@typescript-eslint/type-utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { getParserServices } from "@typescript-eslint/utils/eslint-utils";
+import { getTypeName, unionTypeParts } from "../typeUtils.js";
+import { createRule } from "../utils.js";
+export const preferReadonlyParameterTypes = createRule({
+    name: "prefer-readonly-parameter-types",
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs",
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        schema: [
+            {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    allow: readonlynessOptionsSchema.properties.allow,
+                    checkParameterProperties: {
+                        type: "boolean",
+                    },
+                    ignoreInferredTypes: {
+                        type: "boolean",
+                    },
+                    treatMethodsAsReadonly: readonlynessOptionsSchema.properties.treatMethodsAsReadonly,
+                    onlyRecordsArraysMapsSet: {
+                        type: "boolean",
+                    },
+                },
+            },
+        ],
+        messages: {
+            shouldBeReadonly: "Parameter should be a read only type.",
+        },
+    },
+    defaultOptions: [
+        {
+            allow: readonlynessOptionsDefaults.allow,
+            checkParameterProperties: true,
+            ignoreInferredTypes: false,
+            treatMethodsAsReadonly: readonlynessOptionsDefaults.treatMethodsAsReadonly,
+            onlyRecordsArraysMapsSet: true,
+        },
+    ],
+    create(context, [{ allow, checkParameterProperties, ignoreInferredTypes, treatMethodsAsReadonly, onlyRecordsArraysMapsSet, },]) {
+        const services = getParserServices(context);
+        if (allow === undefined) {
+            allow = [];
+        }
+        allow.push("ReadonlyMap", "ReadonlySet");
+        return {
+            [[
+                AST_NODE_TYPES.ArrowFunctionExpression,
+                AST_NODE_TYPES.FunctionDeclaration,
+                AST_NODE_TYPES.FunctionExpression,
+                AST_NODE_TYPES.TSCallSignatureDeclaration,
+                AST_NODE_TYPES.TSConstructSignatureDeclaration,
+                AST_NODE_TYPES.TSDeclareFunction,
+                AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
+                AST_NODE_TYPES.TSFunctionType,
+                AST_NODE_TYPES.TSMethodSignature,
+            ].join(", ")](node) {
+                for (const param of node.params) {
+                    if (checkParameterProperties === false &&
+                        param.type === AST_NODE_TYPES.TSParameterProperty) {
+                        continue;
+                    }
+                    const actualParam = param.type === AST_NODE_TYPES.TSParameterProperty
+                        ? param.parameter
+                        : param;
+                    if (ignoreInferredTypes === true &&
+                        actualParam.typeAnnotation === undefined) {
+                        continue;
+                    }
+                    const type = services.getTypeAtLocation(actualParam);
+                    if (onlyRecordsArraysMapsSet === true) {
+                        const parts = unionTypeParts(type);
+                        const hasAllBasicDataStructures = parts.every((t) => {
+                            const typeName = getTypeName(t);
+                            return (typeName === "Array" ||
+                                typeName === "Map" ||
+                                typeName === "Set" ||
+                                typeName === "Record");
+                        });
+                        if (!hasAllBasicDataStructures) {
+                            return;
+                        }
+                        // Handle the case of only checking records, arrays, maps, and sets.
+                        for (const t of parts) {
+                            const typeName = getTypeName(t);
+                            switch (typeName) {
+                                case "Array":
+                                case "Map":
+                                case "Set": {
+                                    context.report({
+                                        node: actualParam,
+                                        messageId: "shouldBeReadonly",
+                                    });
+                                    break;
+                                }
+                                case "Record": {
+                                    const isReadOnly = isTypeReadonly(services.program, type, {
+                                        treatMethodsAsReadonly,
+                                        allow,
+                                    });
+                                    if (!isReadOnly) {
+                                        context.report({
+                                            node: actualParam,
+                                            messageId: "shouldBeReadonly",
+                                        });
+                                    }
+                                    break;
+                                }
+                                default: {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // Handle the standard case.
+                        const isReadOnly = isTypeReadonly(services.program, type, {
+                            treatMethodsAsReadonly,
+                            allow,
+                        });
+                        if (!isReadOnly) {
+                            context.report({
+                                node: actualParam,
+                                messageId: "shouldBeReadonly",
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/require-break.d.ts

@@ -0,0 +1,5 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+export type Options = [];
+export type MessageIds = "noBreak";
+export declare const requireBreak: TSESLint.RuleModule<"noBreak", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, TSESLint.RuleListener>;
+//# sourceMappingURL=require-break.d.ts.map

package/dist/rules/require-break.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-break.d.ts","sourceRoot":"","sources":["../../src/rules/require-break.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,SAAS,CAAC;AAEnC,eAAO,MAAM,YAAY,iHAqEvB,CAAC"}

package/dist/rules/require-break.js

@@ -0,0 +1,76 @@
+// This rule is mostly copied from the `no-fallthrough` ESLint core rule:
+// https://github.com/eslint/eslint/blob/main/lib/rules/no-fallthrough.js
+import { createRule } from "../utils.js";
+export const requireBreak = createRule({
+    name: "require-break",
+    meta: {
+        type: "layout",
+        docs: {
+            description: "Requires that each case of a switch statement has a `break` statement",
+            recommended: true,
+            requiresTypeChecking: false,
+        },
+        schema: [],
+        messages: {
+            noBreak: "Expected a 'break' statement.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const codePathSegments = [];
+        let currentCodePathSegments = new Set();
+        return {
+            onCodePathStart() {
+                codePathSegments.push(currentCodePathSegments);
+                currentCodePathSegments = new Set();
+            },
+            onCodePathEnd() {
+                const codePathSegmentsSet = codePathSegments.pop();
+                if (codePathSegmentsSet !== undefined) {
+                    currentCodePathSegments = codePathSegmentsSet;
+                }
+            },
+            onUnreachableCodePathSegmentStart(segment) {
+                currentCodePathSegments.add(segment);
+            },
+            onUnreachableCodePathSegmentEnd(segment) {
+                currentCodePathSegments.delete(segment);
+            },
+            onCodePathSegmentStart(segment) {
+                currentCodePathSegments.add(segment);
+            },
+            onCodePathSegmentEnd(segment) {
+                currentCodePathSegments.delete(segment);
+            },
+            "SwitchCase:exit"(node) {
+                /*
+                 * `reachable` means fallthrough because statements preceded by
+                 * `break`, `return`, or `throw` are unreachable.
+                 * And allows empty cases and the last case.
+                 */
+                const thisNodeIsReachable = isAnySegmentReachable(currentCodePathSegments);
+                const thisNodeIsFinalCase = node === node.parent.cases.at(-1);
+                if (thisNodeIsReachable && thisNodeIsFinalCase) {
+                    context.report({
+                        messageId: "noBreak",
+                        node,
+                    });
+                }
+            },
+        };
+    },
+});
+/**
+ * Checks all segments in a set and returns true if any are reachable.
+ *
+ * @param segments The segments to check.
+ * @returns True if any segment is reachable; false otherwise.
+ */
+function isAnySegmentReachable(segments) {
+    for (const segment of segments) {
+        if (segment.reachable) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/rules/require-capital-const-assertions.d.ts

@@ -0,0 +1,4 @@
+export type Options = [];
+export type MessageIds = "noConstAssertion";
+export declare const requireCapitalConstAssertions: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noConstAssertion", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+//# sourceMappingURL=require-capital-const-assertions.d.ts.map

package/dist/rules/require-capital-const-assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-capital-const-assertions.d.ts","sourceRoot":"","sources":["../../src/rules/require-capital-const-assertions.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC;AAkB5C,eAAO,MAAM,6BAA6B,kMA0ExC,CAAC"}

package/dist/rules/require-capital-const-assertions.js

@@ -0,0 +1,112 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { isFirstLetterCapitalized } from "../completeCommon.js";
+import { createRule } from "../utils.js";
+const ARRAY_OR_OBJECT_EXPRESSION_TYPES = new Set([
+    AST_NODE_TYPES.ObjectExpression,
+    AST_NODE_TYPES.ArrayExpression,
+    AST_NODE_TYPES.TSSatisfiesExpression,
+]);
+const AUTO_FIX_TYPE_BLACKLIST = new Set([
+    // If the variable is already being casted to something with "as", then don't apply any fix to
+    // avoid stomping on the existing code.
+    AST_NODE_TYPES.TSAsExpression,
+    // The `satisfies` keyword will mess up the auto-fixer, because "as const" will be placed after
+    // the satisfies part.
+    AST_NODE_TYPES.TSSatisfiesExpression,
+]);
+export const requireCapitalConstAssertions = createRule({
+    name: "require-capital-const-assertions",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Requires a capital letter for named objects and arrays that have a const assertion",
+            recommended: true,
+            requiresTypeChecking: false,
+        },
+        schema: [],
+        messages: {
+            noConstAssertion: "Variables with capital letters that assign an object or array must use const assertions.",
+        },
+        fixable: "code",
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            VariableDeclaration(node) {
+                if (node.kind !== "const") {
+                    return;
+                }
+                for (const declaration of node.declarations) {
+                    const { id } = declaration;
+                    if (id.type !== AST_NODE_TYPES.Identifier) {
+                        continue;
+                    }
+                    if (!isFirstLetterCapitalized(id.name)) {
+                        continue;
+                    }
+                    const { init } = declaration;
+                    if (init === null) {
+                        continue;
+                    }
+                    // Do nothing if this is not an object or array expression.
+                    if (!ARRAY_OR_OBJECT_EXPRESSION_TYPES.has(init.type)) {
+                        continue;
+                    }
+                    if (hasConstAssertion(init)) {
+                        continue;
+                    }
+                    context.report({
+                        loc: node.loc,
+                        messageId: "noConstAssertion",
+                        fix: (fixer) => {
+                            // If this variable isn't being assigned to anything, then there is nothing we can
+                            // fix.
+                            if (declaration.init === null) {
+                                return null;
+                            }
+                            if (declaration.init.type === AST_NODE_TYPES.TSAsExpression) {
+                                return null;
+                            }
+                            if (AUTO_FIX_TYPE_BLACKLIST.has(declaration.init.type)) {
+                                return null;
+                            }
+                            return fixer.insertTextAfter(declaration.init, " as const");
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+function hasConstAssertion(init) {
+    switch (init.type) {
+        case AST_NODE_TYPES.TSAsExpression: {
+            return hasConstAssertionWithoutSatisfies(init);
+        }
+        case AST_NODE_TYPES.TSSatisfiesExpression: {
+            return hasConstAssertionWithSatisfies(init);
+        }
+        default: {
+            return false;
+        }
+    }
+}
+function hasConstAssertionWithoutSatisfies(init) {
+    const { typeAnnotation } = init;
+    if (typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference) {
+        return false;
+    }
+    const { typeName } = typeAnnotation;
+    if (typeName.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return typeName.name === "const";
+}
+/** The "as const" part is nested within the `TSSatisfiesExpression` node as another expression. */
+function hasConstAssertionWithSatisfies(init) {
+    const { expression } = init;
+    if (expression.type !== AST_NODE_TYPES.TSAsExpression) {
+        return false;
+    }
+    return hasConstAssertionWithoutSatisfies(expression);
+}

package/dist/rules/require-capital-read-only.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export type Options = [];
+export type MessageIds = "readOnlyMap" | "readOnlySet" | "readOnlyArray" | "readOnlyObject";
+export declare const requireCapitalReadOnly: ESLintUtils.RuleModule<MessageIds, [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, ESLintUtils.RuleListener>;
+//# sourceMappingURL=require-capital-read-only.d.ts.map

package/dist/rules/require-capital-read-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-capital-read-only.d.ts","sourceRoot":"","sources":["../../src/rules/require-capital-read-only.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAMvE,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,MAAM,MAAM,UAAU,GAClB,aAAa,GACb,aAAa,GACb,eAAe,GACf,gBAAgB,CAAC;AAErB,eAAO,MAAM,sBAAsB,wHA4DjC,CAAC"}

package/dist/rules/require-capital-read-only.js

@@ -0,0 +1,111 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+import { isFirstLetterCapitalized } from "../completeCommon.js";
+import { getTypeName } from "../typeUtils.js";
+import { createRule } from "../utils.js";
+export const requireCapitalReadOnly = createRule({
+    name: "require-capital-read-only",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Requires maps/sets/arrays with a capital letter to be read-only",
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        schema: [],
+        messages: {
+            readOnlyMap: 'Maps with a capital letter must be explicitly annotated as "ReadOnlyMap".',
+            readOnlySet: 'Sets with a capital letter must be explicitly annotated as "ReadOnlySet".',
+            readOnlyArray: 'Arrays with a capital letter must be explicitly annotated as "readonly" or "ReadonlyArray".',
+            readOnlyObject: 'Objects with a capital letter must be read-only. Try using a type annotation with the "Readonly" helper type.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        return {
+            VariableDeclaration(node) {
+                if (node.kind !== "const") {
+                    return;
+                }
+                for (const declaration of node.declarations) {
+                    const { id } = declaration;
+                    if (id.type !== AST_NODE_TYPES.Identifier) {
+                        continue;
+                    }
+                    const variableName = id.name;
+                    if (!isFirstLetterCapitalized(variableName)) {
+                        continue;
+                    }
+                    const tsNode = parserServices.esTreeNodeToTSNodeMap.get(declaration);
+                    const type = checker.getTypeAtLocation(tsNode);
+                    const messageId = getErrorMessageId(type);
+                    if (messageId === undefined) {
+                        return;
+                    }
+                    context.report({
+                        loc: node.loc,
+                        messageId,
+                    });
+                }
+            },
+        };
+    },
+});
+function getErrorMessageId(type) {
+    const typeName = getTypeName(type);
+    if (typeName === undefined) {
+        return undefined;
+    }
+    if (typeName === "__object" && !isReadOnlyObject(type)) {
+        return "readOnlyObject";
+    }
+    // This would be "ReadonlyMap" if it was the read-only version.
+    if (typeName === "Map") {
+        return "readOnlyMap";
+    }
+    // This would be "ReadonlySet" if it was the read-only version.
+    if (typeName === "Set") {
+        return "readOnlySet";
+    }
+    // This would be "ReadonlyArray" if it was the read-only version.
+    if (typeName === "Array") {
+        return "readOnlyArray";
+    }
+    return undefined;
+}
+function isReadOnlyObject(type) {
+    const symbols = type.getProperties();
+    return symbols.every((symbol) => isReadonlySymbol(symbol));
+}
+/* eslint-disable */
+/**
+ * This is copied from TypeScript internally; it is not exported or exposed:
+ * https://github.com/microsoft/TypeScript/issues/31296
+ */
+function isReadonlySymbol(symbol) {
+    // The following symbols are considered read-only:
+    // - Properties with a 'readonly' modifier
+    // - Variables declared with 'const'
+    // - Get accessors without matching set accessors
+    // - Enum members
+    // - Object.defineProperty assignments with writable false or no setter
+    // - Unions and intersections of the above (unions and intersections eagerly set isReadonly on
+    //   creation)
+    return !!(
+    // prettier-ignore
+    // @ts-expect-error Using internal functions.
+    (ts.getCheckFlags(symbol) & ts.CheckFlags.Readonly ||
+        (symbol.flags & ts.SymbolFlags.Property &&
+            // @ts-expect-error Using internal functions.
+            ts.getDeclarationModifierFlagsFromSymbol(symbol) &
+                ts.ModifierFlags.Readonly) ||
+        (symbol.flags & ts.SymbolFlags.Variable &&
+            // @ts-expect-error Using internal functions.
+            ts.getDeclarationNodeFlagsFromSymbol(symbol) & ts.NodeFlags.Const) ||
+        (symbol.flags & ts.SymbolFlags.Accessor &&
+            !(symbol.flags & ts.SymbolFlags.SetAccessor)) ||
+        symbol.flags & ts.SymbolFlags.EnumMember));
+}
+/* eslint-enable */

package/dist/rules/require-unannotated-const-assertions.d.ts

@@ -0,0 +1,2 @@
+export declare const requireUnannotatedConstAssertions: import("@typescript-eslint/utils/ts-eslint").RuleModule<"annotatedConstAssertion", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+//# sourceMappingURL=require-unannotated-const-assertions.d.ts.map

package/dist/rules/require-unannotated-const-assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-unannotated-const-assertions.d.ts","sourceRoot":"","sources":["../../src/rules/require-unannotated-const-assertions.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iCAAiC,yMA4B5C,CAAC"}

package/dist/rules/require-unannotated-const-assertions.js

@@ -0,0 +1,27 @@
+import { createRule } from "../utils.js";
+export const requireUnannotatedConstAssertions = createRule({
+    name: "require-unannotated-const-assertions",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallows explicit type annotations for variables that have a const assertion",
+            recommended: true,
+            requiresTypeChecking: false,
+        },
+        schema: [],
+        messages: {
+            annotatedConstAssertion: "Don't use `as const` with a type annotated variable, since it widens the type.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            'VariableDeclarator[id.typeAnnotation] > :matches(TSTypeAssertion, TSAsExpression) > TSTypeReference.typeAnnotation > Identifier[name="const"]': (node) => {
+                context.report({
+                    node,
+                    messageId: "annotatedConstAssertion",
+                });
+            },
+        };
+    },
+});

package/dist/rules/require-variadic-function-argument.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export type Options = [];
+export type MessageIds = "noArgument";
+export declare const requireVariadicFunctionArgument: ESLintUtils.RuleModule<"noArgument", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, ESLintUtils.RuleListener>;
+//# sourceMappingURL=require-variadic-function-argument.d.ts.map

package/dist/rules/require-variadic-function-argument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-variadic-function-argument.d.ts","sourceRoot":"","sources":["../../src/rules/require-variadic-function-argument.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIvE,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC;AAItC,eAAO,MAAM,+BAA+B,0HA8D1C,CAAC"}

package/dist/rules/require-variadic-function-argument.js

@@ -0,0 +1,86 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+import { createRule } from "../utils.js";
+const JSDOC_EXCEPTION_TAG = "allowEmptyVariadic";
+export const requireVariadicFunctionArgument = createRule({
+    name: "require-variadic-function-argument",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Requires that variadic functions must be supplied with at least one argument",
+            recommended: true,
+            requiresTypeChecking: true,
+        },
+        schema: [],
+        messages: {
+            noArgument: "You must pass at least one argument to a variadic function.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        return {
+            CallExpression(node) {
+                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                const signature = checker.getResolvedSignature(tsNode);
+                if (signature === undefined) {
+                    return;
+                }
+                const declaration = signature.getDeclaration();
+                // The `getDeclaration` method actually returns `ts.SignatureDeclaration | undefined`, not
+                // `ts.SignatureDeclaration`.
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (declaration === undefined) {
+                    return;
+                }
+                if (isHardCodedException(node) ||
+                    hasJSDocExceptionTag(checker, declaration)) {
+                    return;
+                }
+                for (let i = 0; i < declaration.parameters.length; i++) {
+                    const parameter = declaration.parameters[i];
+                    if (parameter === undefined) {
+                        continue;
+                    }
+                    if (ts.isRestParameter(parameter) &&
+                        node.arguments[i] === undefined) {
+                        context.report({
+                            loc: node.loc,
+                            messageId: "noArgument",
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+function isHardCodedException(node) {
+    const { callee } = node;
+    return isConsoleOrWindowFunction(callee) || isTimeoutFunction(callee);
+}
+function isConsoleOrWindowFunction(callee) {
+    if (callee.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const { object } = callee;
+    if (object.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return object.name === "console" || object.name === "window";
+}
+function isTimeoutFunction(callee) {
+    if (callee.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return callee.name === "setTimeout" || callee.name === "setInterval";
+}
+function hasJSDocExceptionTag(checker, declaration) {
+    const type = checker.getTypeAtLocation(declaration);
+    const symbol = type.getSymbol();
+    if (symbol === undefined) {
+        return false;
+    }
+    const jsDocTagInfoArray = symbol.getJsDocTags(checker);
+    return jsDocTagInfoArray.some((tagInfo) => tagInfo.name === JSDOC_EXCEPTION_TAG);
+}

package/dist/rules/strict-array-methods.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const strictArrayMethods: ESLintUtils.RuleModule<"conditionError", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, ESLintUtils.RuleListener>;
+//# sourceMappingURL=strict-array-methods.d.ts.map

package/dist/rules/strict-array-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict-array-methods.d.ts","sourceRoot":"","sources":["../../src/rules/strict-array-methods.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAcvE,eAAO,MAAM,kBAAkB,8HAyF7B,CAAC"}