eslint-plugin-ore-ui 1.0.0

package/dist/rules/no-bugged.d.cts

@@ -0,0 +1,9 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+declare const _default: ESLintUtils.RuleModule<"bugged" | "buggedWithReason" | "buggedReasonOverride", {
+    allow: never[];
+    ignoreBuiltInBuggedMessages: boolean;
+    additionalBuggedMessages: never[];
+}[], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export = _default;

package/dist/rules/no-critically-bugged.cjs

@@ -0,0 +1,623 @@
+/**
+ * This is based on the `no-deprecated` rule from `@typescript-eslint/eslint-plugin`.
+ *
+ * Original File Source: https://github.com/typescript-eslint/typescript-eslint/blob/c4d5a56925e588d0e84e18f6f2d7756d0248d3be/packages/eslint-plugin/src/rules/no-deprecated.ts
+ *
+ * Copyright (c) 2019 typescript-eslint and other contributors
+ * Licensed under the MIT License.
+ *
+ * Modifications by 8Crafter (2026)
+ */
+"LICENSE";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = require("ts-api-utils");
+const typescript_1 = __importDefault(require("typescript"));
+const type_utils_1 = require("@typescript-eslint/type-utils");
+const eslint_utils_1 = require("@typescript-eslint/utils/eslint-utils");
+const createRule = utils_1.ESLintUtils.RuleCreator((name) => name /* `https://typescript-eslint.io/rules/${name}` */);
+const builtInCriticallyBuggedMessages = [
+    {
+        prefix: {
+            tagName: [
+                { regex: "^criticallyBugged$", flags: "i" },
+                { regex: "^criticalBug$", flags: "i" },
+                { regex: "^bugged2$", flags: "i" },
+                { regex: "^bug2$", flags: "i" },
+            ],
+            prefix: ["Critical Bug", "Bug (Critical)", "Bug!!", "!!Bug"],
+        },
+    },
+];
+function getReportedNodeName(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.Super) {
+        return "super";
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+        return `#${node.name}`;
+    }
+    return node.name;
+}
+module.exports = createRule({
+    name: "no-critically-bugged",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow critically bugged symbols",
+            // recommended: true,
+            // requiresTypeChecking: true,
+        },
+        messages: {
+            criticallyBugged: `\`{{name}}\` has a critical bug`,
+            criticallyBuggedWithReason: `\`{{name}}\` has a critical bug. {{reason}}`,
+            criticallyBuggedReasonOverride: `{{reason}}`,
+        },
+        schema: [
+            {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    allow: {
+                        ...type_utils_1.typeOrValueSpecifiersSchema,
+                        description: "Type specifiers that can be allowed.",
+                    },
+                    ignoreBuiltInCriticallyBuggedMessages: {
+                        type: "boolean",
+                        description: "Whether to ignore the built-in critically bugged messages.",
+                    },
+                    additionalCriticallyBuggedMessages: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                message: {
+                                    oneOf: [
+                                        { type: "string" },
+                                        { type: "object", required: ["regex"], properties: { regex: { type: "string" }, flags: { type: "string" } } },
+                                    ],
+                                    description: "The message to filter JSDoc comments by, only matching JSDoc comments will cause a violation. If not provided, any JSDoc tag of the specified name will cause a violation.",
+                                },
+                                prefix: {
+                                    type: "object",
+                                    oneOf: [
+                                        {
+                                            type: "object",
+                                            required: ["tagName"],
+                                        },
+                                        {
+                                            type: "object",
+                                            required: ["prefix"],
+                                        },
+                                        {
+                                            type: "object",
+                                            required: ["tagName", "prefix"],
+                                        },
+                                    ],
+                                    properties: {
+                                        tagName: {
+                                            oneOf: [
+                                                { type: "string" },
+                                                { type: "object", required: ["regex"], properties: { regex: { type: "string" }, flags: { type: "string" } } },
+                                                {
+                                                    type: "array",
+                                                    items: {
+                                                        oneOf: [
+                                                            { type: "string" },
+                                                            {
+                                                                type: "object",
+                                                                required: ["regex"],
+                                                                properties: { regex: { type: "string" }, flags: { type: "string" } },
+                                                            },
+                                                        ],
+                                                    },
+                                                },
+                                            ],
+                                            description: "The JSDoc tag name or a list of JSDoc tag names to filter by, should not be prefixed with '@'. ex. 'throws'",
+                                        },
+                                        prefix: {
+                                            oneOf: [
+                                                { type: "string" },
+                                                { type: "object", required: ["regex"], properties: { regex: { type: "string" }, flags: { type: "string" } } },
+                                                {
+                                                    type: "array",
+                                                    items: {
+                                                        oneOf: [
+                                                            { type: "string" },
+                                                            {
+                                                                type: "object",
+                                                                required: ["regex"],
+                                                                properties: { regex: { type: "string" }, flags: { type: "string" } },
+                                                            },
+                                                        ],
+                                                    },
+                                                },
+                                            ],
+                                            description: "The prefix to filter by, this is text that would be at the start of a line in the JSDoc, immediately followed by a colon, should not be suffixed with a colon. ex. 'Critical Bug' or 'Bug!!'",
+                                        },
+                                    },
+                                    description: "The prefix filtering options, these are used to find the start of the bug description, only matching JSDoc comments will cause a violation.",
+                                },
+                                reason: {
+                                    type: "string",
+                                    description: "The reason for the violation, this is what will be reported, if not specified, the message will be the bug description. ex. If the reason is 'This does not work at all in CoHTML (Ore UI).', the message will be '`{{name}}` has a critical bug. This does not work at all in CoHTML (Ore UI).'",
+                                },
+                                reasonOverride: {
+                                    type: "string",
+                                    description: "The error message to report. This will take precedence over `reason`. Unlike reason, this does not prepend '`{{name}}` has a critical bug.' to the reason. ex. If the reason override is 'This does not work at all in CoHTML (Ore UI).', the message will be 'This does not work at all in CoHTML (Ore UI).'",
+                                },
+                            },
+                            required: ["tagName"],
+                            additionalProperties: false,
+                            description: "An additional critically bugged message to check for.",
+                        },
+                        description: "Additional critically bugged messages to check for.",
+                    },
+                },
+            },
+        ],
+        defaultOptions: [
+            {
+                allow: [],
+                ignoreBuiltInCriticallyBuggedMessages: false,
+                additionalCriticallyBuggedMessages: [],
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allow: [],
+            ignoreBuiltInCriticallyBuggedMessages: false,
+            additionalCriticallyBuggedMessages: [],
+        },
+    ],
+    create(context) {
+        const { jsDocParsingMode } = context.parserOptions;
+        const allow = context.options[0]?.allow;
+        const criticallyBuggedMessages = (context.options[0]?.additionalCriticallyBuggedMessages ?? [])
+            .concat((context.options[0]?.ignoreBuiltInCriticallyBuggedMessages ?? false) ? [] : builtInCriticallyBuggedMessages)
+            .map((message) => ({
+            ...message,
+            message: message.message ?
+                typeof message.message === "string" ?
+                    message.message
+                    : new RegExp(message.message.regex, message.message.flags)
+                : undefined,
+            prefix: Object.fromEntries(Object.entries(message.prefix).map(([key, value]) => [
+                key,
+                typeof value === "string" ? value
+                    : value instanceof Array ?
+                        value.map((item) => typeof item === "string" ? item : new RegExp(item.regex, item.flags))
+                        : new RegExp(value.regex, value.flags),
+            ])),
+        }));
+        if (!criticallyBuggedMessages.length)
+            return {};
+        if (jsDocParsingMode === "none" || jsDocParsingMode === "type-info") {
+            throw new Error(`Cannot be used with jsDocParsingMode: '${jsDocParsingMode}'.`);
+        }
+        const services = (0, eslint_utils_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        // Deprecated jsdoc tags can be added on some symbol alias, e.g.
+        //
+        // export { /** @deprecated */ foo }
+        //
+        // When we import foo, its symbol is an alias of the exported foo (the one
+        // with the deprecated tag), which is itself an alias of the original foo.
+        // Therefore, we carefully go through the chain of aliases and check each
+        // immediate alias for deprecated tags
+        function searchForCriticallyBuggedInAliasesChain(symbol, checkDeprecationsOfAliasedSymbol) {
+            if (!symbol || !tsutils.isSymbolFlagSet(symbol, typescript_1.default.SymbolFlags.Alias)) {
+                return checkDeprecationsOfAliasedSymbol ? getJsDocCriticallyBugged(symbol) : undefined;
+            }
+            const targetSymbol = checker.getAliasedSymbol(symbol);
+            while (tsutils.isSymbolFlagSet(symbol, typescript_1.default.SymbolFlags.Alias)) {
+                const reason = getJsDocCriticallyBugged(symbol);
+                if (reason != null) {
+                    return reason;
+                }
+                const immediateAliasedSymbol = symbol.getDeclarations() && checker.getImmediateAliasedSymbol(symbol);
+                if (!immediateAliasedSymbol) {
+                    break;
+                }
+                symbol = immediateAliasedSymbol;
+                if (checkDeprecationsOfAliasedSymbol && symbol === targetSymbol) {
+                    return getJsDocCriticallyBugged(symbol);
+                }
+            }
+            return undefined;
+        }
+        function isDeclaration(node) {
+            const { parent } = node;
+            switch (parent.type) {
+                case utils_1.AST_NODE_TYPES.ArrayPattern:
+                    return parent.elements.includes(node);
+                case utils_1.AST_NODE_TYPES.ClassExpression:
+                case utils_1.AST_NODE_TYPES.ClassDeclaration:
+                case utils_1.AST_NODE_TYPES.VariableDeclarator:
+                case utils_1.AST_NODE_TYPES.TSEnumMember:
+                    return parent.id === node;
+                case utils_1.AST_NODE_TYPES.MethodDefinition:
+                case utils_1.AST_NODE_TYPES.PropertyDefinition:
+                case utils_1.AST_NODE_TYPES.AccessorProperty:
+                    return parent.key === node;
+                case utils_1.AST_NODE_TYPES.Property:
+                    // foo in "const { foo } = bar" will be processed twice, as parent.key
+                    // and parent.value. The second is treated as a declaration.
+                    if (parent.shorthand && parent.value === node) {
+                        return parent.parent.type === utils_1.AST_NODE_TYPES.ObjectPattern;
+                    }
+                    if (parent.value === node) {
+                        return false;
+                    }
+                    return parent.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression;
+                case utils_1.AST_NODE_TYPES.AssignmentPattern:
+                    // foo in "const { foo = "" } = bar" will be processed twice, as parent.parent.key
+                    // and parent.left. The second is treated as a declaration.
+                    return parent.left === node;
+                case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+                case utils_1.AST_NODE_TYPES.FunctionExpression:
+                case utils_1.AST_NODE_TYPES.TSDeclareFunction:
+                case utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression:
+                case utils_1.AST_NODE_TYPES.TSEnumDeclaration:
+                case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration:
+                case utils_1.AST_NODE_TYPES.TSMethodSignature:
+                case utils_1.AST_NODE_TYPES.TSModuleDeclaration:
+                case utils_1.AST_NODE_TYPES.TSParameterProperty:
+                case utils_1.AST_NODE_TYPES.TSPropertySignature:
+                case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration:
+                case utils_1.AST_NODE_TYPES.TSTypeParameter:
+                    return true;
+                // treat `export import Bar = Foo;` (and `import Foo = require('...')`) as declarations
+                case utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration:
+                    return parent.id === node;
+                default:
+                    return false;
+            }
+        }
+        function isInsideImport(node) {
+            let current = node;
+            while (true) {
+                switch (current.type) {
+                    case utils_1.AST_NODE_TYPES.ImportDeclaration:
+                        return true;
+                    case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                    case utils_1.AST_NODE_TYPES.ExportAllDeclaration:
+                    case utils_1.AST_NODE_TYPES.ExportNamedDeclaration:
+                    case utils_1.AST_NODE_TYPES.BlockStatement:
+                    case utils_1.AST_NODE_TYPES.ClassDeclaration:
+                    case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration:
+                    case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+                    case utils_1.AST_NODE_TYPES.FunctionExpression:
+                    case utils_1.AST_NODE_TYPES.Program:
+                    case utils_1.AST_NODE_TYPES.TSUnionType:
+                    case utils_1.AST_NODE_TYPES.VariableDeclarator:
+                        return false;
+                    default:
+                        current = current.parent;
+                }
+            }
+        }
+        function getJsDocCriticallyBugged(symbol) {
+            let jsDocTags;
+            try {
+                jsDocTags = symbol?.getJsDocTags(checker);
+            }
+            catch {
+                // workaround for https://github.com/microsoft/TypeScript/issues/60024
+                return undefined;
+            }
+            let tag;
+            let messageRule;
+            let messageString;
+            jsDocTagLoop: for (const jsDocTag of jsDocTags ?? []) {
+                let displayPartsString;
+                for (const currentRule of criticallyBuggedMessages) {
+                    if (!("tagName" in currentRule.prefix && currentRule.prefix.tagName))
+                        continue;
+                    if (!(currentRule.prefix.tagName instanceof Array ?
+                        currentRule.prefix.tagName.some((tagName) => typeof tagName === "string" ? tagName === jsDocTag.name : tagName.test(jsDocTag.name))
+                        : typeof currentRule.prefix.tagName === "string" ? currentRule.prefix.tagName === jsDocTag.name
+                            : currentRule.prefix.tagName.test(jsDocTag.name)))
+                        continue;
+                    if (!currentRule.message) {
+                        tag = jsDocTag;
+                        messageRule = currentRule;
+                        messageString = displayPartsString;
+                        break jsDocTagLoop;
+                    }
+                    if (typeof currentRule.message === "string") {
+                        if (!jsDocTag.text || currentRule.message !== (displayPartsString ?? (displayPartsString = typescript_1.default.displayPartsToString(jsDocTag.text))))
+                            continue;
+                        tag = jsDocTag;
+                        messageRule = currentRule;
+                        messageString = displayPartsString;
+                        break jsDocTagLoop;
+                    }
+                    if (currentRule.message && currentRule.message.test(displayPartsString ?? (displayPartsString = typescript_1.default.displayPartsToString(jsDocTag.text)))) {
+                        tag = jsDocTag;
+                        messageRule = currentRule;
+                        messageString = displayPartsString;
+                        break jsDocTagLoop;
+                    }
+                }
+            }
+            if (!tag || !messageRule) {
+                let documentationComments;
+                try {
+                    documentationComments = symbol?.getDocumentationComment(checker);
+                }
+                catch {
+                    // workaround for https://github.com/microsoft/TypeScript/issues/60024
+                    return undefined;
+                }
+                let comment;
+                let commentEntry;
+                let messageRule;
+                let message;
+                documentationCommentLoop: for (const documentationComment of documentationComments ?? []) {
+                    if (documentationComment.kind !== "text")
+                        continue;
+                    const documentationCommentEntries = documentationComment.text.split(/(?:\r?\n){2,}/g).map((v) => v.trim());
+                    for (const documentationCommentEntry of documentationCommentEntries) {
+                        if (!documentationCommentEntry)
+                            continue;
+                        for (const currentRule of criticallyBuggedMessages) {
+                            if (!("prefix" in currentRule.prefix && currentRule.prefix.prefix))
+                                continue;
+                            for (const prefix of currentRule.prefix.prefix instanceof Array ? currentRule.prefix.prefix : [currentRule.prefix.prefix]) {
+                                let documentationMessage;
+                                if (typeof prefix === "string") {
+                                    if (prefix && documentationCommentEntry.split(":")[0] !== prefix)
+                                        continue;
+                                    documentationMessage =
+                                        prefix ? documentationCommentEntry.split(":").slice(1).join(":").trimStart() : documentationCommentEntry;
+                                }
+                                else {
+                                    if (!prefix.test(documentationCommentEntry.split(":")[0]))
+                                        continue;
+                                    documentationMessage = documentationCommentEntry.split(":").slice(1).join(":").trimStart();
+                                }
+                                if (!currentRule.message) {
+                                    comment = documentationComment;
+                                    commentEntry = documentationCommentEntry;
+                                    messageRule = currentRule;
+                                    message = documentationMessage;
+                                    break documentationCommentLoop;
+                                }
+                                if (typeof currentRule.message === "string") {
+                                    if (!documentationCommentEntry || currentRule.message !== documentationMessage)
+                                        continue;
+                                    comment = documentationComment;
+                                    commentEntry = documentationCommentEntry;
+                                    messageRule = currentRule;
+                                    message = documentationMessage;
+                                    break documentationCommentLoop;
+                                }
+                                if (currentRule.message.test(documentationMessage)) {
+                                    comment = documentationComment;
+                                    commentEntry = documentationCommentEntry;
+                                    messageRule = currentRule;
+                                    message = documentationMessage;
+                                    break documentationCommentLoop;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (!comment || !commentEntry || !messageRule)
+                    return undefined;
+                if (messageRule.reasonOverride)
+                    return { override: messageRule.reasonOverride };
+                if (messageRule.reason)
+                    return messageRule.reason;
+                return message;
+            }
+            if (messageRule.reasonOverride)
+                return { override: messageRule.reasonOverride };
+            if (messageRule.reason)
+                return messageRule.reason;
+            return messageString;
+        }
+        function isNodeCalleeOfParent(node) {
+            switch (node.parent?.type) {
+                case utils_1.AST_NODE_TYPES.NewExpression:
+                case utils_1.AST_NODE_TYPES.CallExpression:
+                    return node.parent.callee === node;
+                case utils_1.AST_NODE_TYPES.TaggedTemplateExpression:
+                    return node.parent.tag === node;
+                case utils_1.AST_NODE_TYPES.JSXOpeningElement:
+                    return node.parent.name === node;
+                default:
+                    return false;
+            }
+        }
+        function getCallLikeNode(node) {
+            let callee = node;
+            while (callee.parent?.type === utils_1.AST_NODE_TYPES.MemberExpression && callee.parent.property === callee) {
+                callee = callee.parent;
+            }
+            return isNodeCalleeOfParent(callee) ? callee : undefined;
+        }
+        function getCallLikeCriticallyBugged(node) {
+            const tsNode = services.esTreeNodeToTSNodeMap.get(node.parent);
+            // If the node is a direct function call, we look for its signature.
+            const signature = (0, eslint_utils_1.nullThrows)(checker.getResolvedSignature(tsNode), "Expected call like node to have signature");
+            const symbol = services.getSymbolAtLocation(node);
+            const aliasedSymbol = symbol != null && tsutils.isSymbolFlagSet(symbol, typescript_1.default.SymbolFlags.Alias) ? checker.getAliasedSymbol(symbol) : symbol;
+            const symbolDeclarationKind = aliasedSymbol?.declarations?.[0]?.kind;
+            // Properties with function-like types have "deprecated" jsdoc
+            // on their symbols, not on their signatures:
+            //
+            // interface Props {
+            //   /** @deprecated */
+            //   property: () => 'foo'
+            //   ^symbol^  ^signature^
+            // }
+            if (symbolDeclarationKind !== typescript_1.default.SyntaxKind.MethodDeclaration &&
+                symbolDeclarationKind !== typescript_1.default.SyntaxKind.FunctionDeclaration &&
+                symbolDeclarationKind !== typescript_1.default.SyntaxKind.MethodSignature) {
+                return searchForCriticallyBuggedInAliasesChain(symbol, true) ?? getJsDocCriticallyBugged(signature) ?? getJsDocCriticallyBugged(aliasedSymbol);
+            }
+            return (searchForCriticallyBuggedInAliasesChain(symbol, 
+            // Here we're working with a function declaration or method.
+            // Both can have 1 or more overloads, each overload creates one
+            // ts.Declaration which is placed in symbol.declarations.
+            //
+            // Imagine the following code:
+            //
+            // function foo(): void
+            // /** @deprecated Some Reason */
+            // function foo(arg: string): void
+            // function foo(arg?: string): void {}
+            //
+            // foo()    // <- foo is our symbol
+            //
+            // If we call getJsDocDeprecation(checker.getAliasedSymbol(symbol)),
+            // we get 'Some Reason', but after all, we are calling foo with
+            // a signature that is not deprecated!
+            // It works this way because symbol.getJsDocTags returns tags from
+            // all symbol declarations combined into one array. And AFAIK there is
+            // no publicly exported TS function that can tell us if a particular
+            // declaration is deprecated or not.
+            //
+            // So, in case of function and method declarations, we don't check original
+            // aliased symbol, but rely on the getJsDocDeprecation(signature) call below.
+            false) ?? getJsDocCriticallyBugged(signature));
+        }
+        function getJSXAttributeCriticallyBugged(openingElement, propertyName) {
+            const tsNode = services.esTreeNodeToTSNodeMap.get(openingElement.name);
+            const contextualType = (0, eslint_utils_1.nullThrows)(checker.getContextualType(tsNode), "Expected JSX opening element name to have contextualType");
+            const symbol = contextualType.getProperty(propertyName);
+            return getJsDocCriticallyBugged(symbol);
+        }
+        function getCriticallyBuggedReason(node) {
+            const callLikeNode = getCallLikeNode(node);
+            if (callLikeNode) {
+                return getCallLikeCriticallyBugged(callLikeNode);
+            }
+            if (node.parent.type === utils_1.AST_NODE_TYPES.JSXAttribute && node.type !== utils_1.AST_NODE_TYPES.Super) {
+                return getJSXAttributeCriticallyBugged(node.parent.parent, node.name);
+            }
+            if (node.parent.type === utils_1.AST_NODE_TYPES.Property && node.type !== utils_1.AST_NODE_TYPES.Super) {
+                const property = services.getTypeAtLocation(node.parent.parent).getProperty(node.name);
+                const propertySymbol = services.getSymbolAtLocation(node);
+                const valueSymbol = checker.getShorthandAssignmentValueSymbol(propertySymbol?.valueDeclaration);
+                return (searchForCriticallyBuggedInAliasesChain(propertySymbol, true) ??
+                    getJsDocCriticallyBugged(property) ??
+                    getJsDocCriticallyBugged(propertySymbol) ??
+                    getJsDocCriticallyBugged(valueSymbol));
+            }
+            return searchForCriticallyBuggedInAliasesChain(services.getSymbolAtLocation(node), true);
+        }
+        function checkIdentifier(node) {
+            if (isDeclaration(node) || isInsideImport(node)) {
+                return;
+            }
+            const reason = getCriticallyBuggedReason(node);
+            if (reason == null) {
+                return;
+            }
+            const type = services.getTypeAtLocation(node);
+            if ((0, type_utils_1.typeMatchesSomeSpecifier)(type, allow, services.program) || (0, type_utils_1.valueMatchesSomeSpecifier)(node, allow, services.program, type)) {
+                return;
+            }
+            const name = getReportedNodeName(node);
+            context.report({
+                ...(reason ?
+                    typeof reason === "object" ?
+                        {
+                            messageId: "criticallyBuggedReasonOverride",
+                            data: { name, reason: reason.override },
+                        }
+                        : {
+                            messageId: "criticallyBuggedWithReason",
+                            data: { name, reason },
+                        }
+                    : {
+                        messageId: "criticallyBugged",
+                        data: { name },
+                    }),
+                node,
+            });
+        }
+        function checkMemberExpression(node) {
+            if (!node.computed) {
+                return;
+            }
+            const propertyType = services.getTypeAtLocation(node.property);
+            if (propertyType.isLiteral()) {
+                const objectType = services.getTypeAtLocation(node.object);
+                const propertyName = propertyType.isStringLiteral() ? propertyType.value : String(propertyType.value);
+                const property = objectType.getProperty(propertyName);
+                const reason = getJsDocCriticallyBugged(property);
+                if (reason == null) {
+                    return;
+                }
+                if ((0, type_utils_1.typeMatchesSomeSpecifier)(objectType, allow, services.program)) {
+                    return;
+                }
+                context.report({
+                    ...(reason ?
+                        typeof reason === "object" ?
+                            {
+                                messageId: "criticallyBuggedReasonOverride",
+                                data: { name: propertyName, reason: reason.override },
+                            }
+                            : {
+                                messageId: "criticallyBuggedWithReason",
+                                data: { name: propertyName, reason },
+                            }
+                        : {
+                            messageId: "criticallyBugged",
+                            data: { name: propertyName },
+                        }),
+                    node: node.property,
+                });
+            }
+        }
+        return {
+            Identifier(node) {
+                const { parent } = node;
+                if (parent.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration || parent.type === utils_1.AST_NODE_TYPES.ExportAllDeclaration) {
+                    return;
+                }
+                // Computed identifier expressions are handled by checkMemberExpression
+                if (parent.type === utils_1.AST_NODE_TYPES.MemberExpression && parent.computed && parent.property === node) {
+                    return;
+                }
+                if (parent.type === utils_1.AST_NODE_TYPES.ExportSpecifier) {
+                    // only deal with the alias (exported) side, not the local binding
+                    if (parent.exported !== node) {
+                        return;
+                    }
+                    const symbol = services.getSymbolAtLocation(node);
+                    const aliasDeprecation = getJsDocCriticallyBugged(symbol);
+                    if (aliasDeprecation != null) {
+                        return;
+                    }
+                }
+                // whether it's a plain identifier or the exported alias
+                checkIdentifier(node);
+            },
+            JSXIdentifier(node) {
+                if (node.parent.type !== utils_1.AST_NODE_TYPES.JSXClosingElement) {
+                    checkIdentifier(node);
+                }
+            },
+            MemberExpression(node) {
+                checkMemberExpression(node);
+            },
+            PrivateIdentifier(node) {
+                checkIdentifier(node);
+            },
+            Super(node) {
+                checkIdentifier(node);
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-critically-bugged.cjs.map