@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/no-restricted-properties-fix.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noRestrictedPropertiesFix = void 0;
+const createRule_1 = require("../utils/createRule");
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * This rule is a wrapper around the core ESLint no-restricted-properties rule
+ * that adds special handling for Object.keys() and Object.values() results.
+ * It prevents false positives when accessing standard array properties/methods
+ * on the arrays returned by Object.keys() and Object.values().
+ */
+exports.noRestrictedPropertiesFix = (0, createRule_1.createRule)({
+    name: 'no-restricted-properties-fix',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow certain properties on certain objects, with special handling for Object.keys() and Object.values()',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        object: { type: 'string' },
+                        property: { type: 'string' },
+                        message: { type: 'string' },
+                        allowObjects: {
+                            type: 'array',
+                            items: { type: 'string' },
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+        ],
+        messages: {
+            restrictedProperty: 'Access to "{{objectName}}.{{propertyName}}" is restricted. {{restrictionReason}}Restricted properties often bypass safer APIs, hide side effects, or encourage patterns this codebase forbids. Use the allowed alternative from your rule configuration or remove this property access.',
+        },
+    },
+    defaultOptions: [[]],
+    create(context, [restrictedProperties]) {
+        if (!restrictedProperties || restrictedProperties.length === 0) {
+            return {};
+        }
+        const SAFE_ARRAY_PROPERTIES = new Set([
+            'length',
+            'sort',
+            'filter',
+            'map',
+            'reduce',
+            'forEach',
+            'join',
+            'slice',
+            'concat',
+        ]);
+        /**
+         * Keeps the templated message readable by only adding a trailing space
+         * when a restriction reason is provided.
+         */
+        function formatRestrictionReason(message) {
+            return message ? `${message} ` : '';
+        }
+        /**
+         * Checks if the given node is a result of Object.keys() or Object.values()
+         * @param node The node to check
+         * @returns True if the node is a result of Object.keys() or Object.values()
+         */
+        function isObjectKeysOrValuesResult(node) {
+            if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                return false;
+            }
+            const callee = node.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return false;
+            }
+            if (callee.object.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                callee.object.name !== 'Object') {
+                return false;
+            }
+            if (callee.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                (callee.property.name !== 'keys' && callee.property.name !== 'values')) {
+                return false;
+            }
+            return true;
+        }
+        return {
+            MemberExpression(node) {
+                // Skip if the object is a result of Object.keys() or Object.values()
+                if (isObjectKeysOrValuesResult(node.object)) {
+                    if (node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        SAFE_ARRAY_PROPERTIES.has(node.property.name)) {
+                        return;
+                    }
+                }
+                // Apply the original rule logic
+                for (const restrictedProp of restrictedProperties) {
+                    const objectMatches = restrictedProp.object &&
+                        node.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.object.name === restrictedProp.object;
+                    const propertyMatches = restrictedProp.property &&
+                        ((node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            node.property.name === restrictedProp.property) ||
+                            (node.property.type === utils_1.AST_NODE_TYPES.Literal &&
+                                node.property.value === restrictedProp.property));
+                    // If both object and property are restricted
+                    if (restrictedProp.object &&
+                        restrictedProp.property &&
+                        objectMatches &&
+                        propertyMatches) {
+                        context.report({
+                            node,
+                            messageId: 'restrictedProperty',
+                            data: {
+                                objectName: restrictedProp.object,
+                                propertyName: restrictedProp.property,
+                                restrictionReason: formatRestrictionReason(restrictedProp.message),
+                            },
+                            fix: () => null,
+                        });
+                    }
+                    // If only property is restricted (for any object)
+                    else if (!restrictedProp.object &&
+                        restrictedProp.property &&
+                        propertyMatches) {
+                        // Check if the object is in the allowObjects list
+                        if (restrictedProp.allowObjects &&
+                            node.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            restrictedProp.allowObjects.includes(node.object.name)) {
+                            continue;
+                        }
+                        const objectName = node.object.type === utils_1.AST_NODE_TYPES.Identifier
+                            ? node.object.name
+                            : 'unknown';
+                        context.report({
+                            node,
+                            messageId: 'restrictedProperty',
+                            data: {
+                                objectName,
+                                propertyName: restrictedProp.property,
+                                restrictionReason: formatRestrictionReason(restrictedProp.message),
+                            },
+                            fix: () => null,
+                        });
+                    }
+                    // If only object is restricted (any property)
+                    else if (restrictedProp.object &&
+                        !restrictedProp.property &&
+                        objectMatches) {
+                        const propertyName = node.property.type === utils_1.AST_NODE_TYPES.Identifier
+                            ? node.property.name
+                            : node.property.type === utils_1.AST_NODE_TYPES.Literal
+                                ? String(node.property.value)
+                                : 'unknown';
+                        context.report({
+                            node,
+                            messageId: 'restrictedProperty',
+                            data: {
+                                objectName: restrictedProp.object,
+                                propertyName,
+                                restrictionReason: formatRestrictionReason(restrictedProp.message),
+                            },
+                            fix: () => null,
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-restricted-properties-fix.js.map

package/lib/rules/no-separate-loading-state.d.ts

@@ -0,0 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
+type Options = [
+    {
+        patterns?: string[];
+    }?
+];
+export declare const noSeparateLoadingState: TSESLint.RuleModule<"separateLoadingState", Options, TSESLint.RuleListener>;
+export {};

package/lib/rules/no-separate-loading-state.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSeparateLoadingState = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const LOADING_PATTERNS = [
+    /^is.*Loading$/i,
+    /^isLoading.+/i, // isLoadingX pattern
+];
+exports.noSeparateLoadingState = (0, createRule_1.createRule)({
+    name: 'no-separate-loading-state',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow separate loading state variables that track the loading status of other state',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    patterns: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            separateLoadingState: 'Loading flag "{{stateName}}" splits the source of truth for data fetching. Boolean toggles drift from the actual data and add extra renders. Encode the loading phase inside the primary state instead (use a "loading" sentinel or discriminated union) so components read a single authoritative value.',
+        },
+    },
+    defaultOptions: [{}],
+    create(context, [options]) {
+        const effectivePatterns = options?.patterns?.map((p) => new RegExp(p, 'i')) ?? LOADING_PATTERNS;
+        const setterTrackers = [];
+        function isLoadingPattern(name) {
+            return effectivePatterns.some((pattern) => pattern.test(name));
+        }
+        function isUseStateCall(node) {
+            if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.name === 'useState') {
+                return true;
+            }
+            if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.property.name === 'useState') {
+                return true;
+            }
+            return false;
+        }
+        function isTruthyValue(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.Literal) {
+                return Boolean(node.value);
+            }
+            return false;
+        }
+        function isFalsyValue(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.Literal) {
+                return !node.value;
+            }
+            return false;
+        }
+        return {
+            VariableDeclarator(node) {
+                // Check for useState destructuring patterns
+                if (node.id.type === utils_1.AST_NODE_TYPES.ArrayPattern &&
+                    node.init?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    isUseStateCall(node.init)) {
+                    const arrayPattern = node.id;
+                    // Check if we have at least 2 elements (state and setter)
+                    if (arrayPattern.elements.length >= 2) {
+                        const stateElement = arrayPattern.elements[0];
+                        const setterElement = arrayPattern.elements[1];
+                        if (stateElement?.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            setterElement?.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            isLoadingPattern(stateElement.name)) {
+                            const declared = context.getDeclaredVariables(node);
+                            const setterVar = declared.find((v) => v.name === setterElement.name) ?? null;
+                            if (!setterVar)
+                                return;
+                            setterTrackers.push({
+                                declarator: node,
+                                setterVar,
+                                usage: { truthy: false, falsy: false },
+                                stateName: stateElement.name,
+                            });
+                        }
+                    }
+                }
+            },
+            CallExpression() {
+                // Setter usage is resolved via scope references in Program:exit
+                return;
+            },
+            'Program:exit'() {
+                // Analyze collected data to determine violations
+                for (const tracker of setterTrackers) {
+                    // Walk references of the exact setter variable to classify usages
+                    for (const ref of tracker.setterVar.references) {
+                        const parent = ref.identifier.parent;
+                        if (parent &&
+                            parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                            parent.callee === ref.identifier &&
+                            parent.arguments.length > 0) {
+                            const argument = parent.arguments[0];
+                            if (isTruthyValue(argument)) {
+                                tracker.usage.truthy = true;
+                            }
+                            else if (isFalsyValue(argument)) {
+                                tracker.usage.falsy = true;
+                            }
+                        }
+                    }
+                    const { declarator, usage, stateName } = tracker;
+                    // If we have both truthy and falsy setter calls, it's likely a loading state pattern
+                    if (usage.truthy && usage.falsy) {
+                        context.report({
+                            node: declarator,
+                            messageId: 'separateLoadingState',
+                            data: {
+                                stateName,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-separate-loading-state.js.map

package/lib/rules/no-stale-state-across-await.d.ts

@@ -0,0 +1 @@
+export declare const noStaleStateAcrossAwait: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"staleStateAcrossAwait", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-stale-state-across-await.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noStaleStateAcrossAwait = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noStaleStateAcrossAwait = (0, createRule_1.createRule)({
+    name: 'no-stale-state-across-await',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent stale intermediate state by disallowing useState setter calls both before and after async boundaries (await, .then(), yield) within the same function',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [],
+        messages: {
+            staleStateAcrossAwait: 'State setter "{{setterName}}" runs on both sides of {{boundaryType}}. Updates issued before the async boundary can resolve after later updates and overwrite fresher data, leaving the UI in a stale loading or placeholder state. Keep "{{setterName}}" updates on one side of the async boundary or consolidate into a single atomic update after the async work; if you intentionally use a sentinel value, document it with // eslint-disable-next-line @blumintinc/blumint/no-stale-state-across-await and a short comment explaining why.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            // Check functions for violations
+            'FunctionDeclaration, FunctionExpression, ArrowFunctionExpression'(node) {
+                const sourceCode = context.sourceCode;
+                const scopeManager = sourceCode.scopeManager;
+                if (!scopeManager)
+                    return;
+                const acquiredScope = scopeManager.acquire(node);
+                if (!acquiredScope)
+                    return;
+                const scope = acquiredScope;
+                // Build local set of setter identifiers declared via useState in this scope
+                const localSetterNames = new Set();
+                let scopeCursor = scope;
+                while (scopeCursor) {
+                    for (const variable of scopeCursor.variables) {
+                        for (const def of variable.defs) {
+                            if (def.type === 'Variable' &&
+                                def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                                def.node.id.type === utils_1.AST_NODE_TYPES.ArrayPattern &&
+                                def.node.init?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                                def.node.init.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                def.node.init.callee.name === 'useState') {
+                                const arrayPattern = def.node.id;
+                                if (arrayPattern.elements.length >= 2 &&
+                                    arrayPattern.elements[1]?.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    localSetterNames.add(arrayPattern.elements[1].name);
+                                }
+                            }
+                        }
+                    }
+                    scopeCursor = scopeCursor.upper;
+                }
+                function isLocalSetter(identifier) {
+                    return localSetterNames.has(identifier.name);
+                }
+                // Collect all setter calls and async boundaries in this function
+                const setterCalls = [];
+                const asyncBoundaries = [];
+                // Walk through the function body to find setter calls and async boundaries
+                function walkNode(n, skipNestedFunctions = true) {
+                    if (n.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                        // Check for setter calls
+                        if (n.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            isLocalSetter(n.callee)) {
+                            setterCalls.push({
+                                name: n.callee.name,
+                                position: n.range[0],
+                            });
+                        }
+                        // Check for .then()/.catch()/.finally() calls
+                        if (n.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                            n.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            (n.callee.property.name === 'then' ||
+                                n.callee.property.name === 'catch' ||
+                                n.callee.property.name === 'finally')) {
+                            const methodName = n.callee.property.name;
+                            if (methodName === 'then' || methodName === 'catch') {
+                                asyncBoundaries.push({
+                                    position: n.range[0],
+                                    label: `a .${methodName}() callback`,
+                                });
+                            }
+                            // Walk into callback arguments to find setter calls
+                            if (n.arguments && n.arguments.length > 0) {
+                                for (const arg of n.arguments) {
+                                    if (arg.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                                        arg.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                                        // Walk into the callback function body
+                                        walkNode(arg, false);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (n.type === utils_1.AST_NODE_TYPES.AwaitExpression) {
+                        asyncBoundaries.push({
+                            position: n.range[0],
+                            label: 'an await boundary',
+                        });
+                    }
+                    if (n.type === utils_1.AST_NODE_TYPES.YieldExpression) {
+                        asyncBoundaries.push({
+                            position: n.range[0],
+                            label: 'a yield boundary',
+                        });
+                    }
+                    if (n.type === utils_1.AST_NODE_TYPES.ForOfStatement &&
+                        n.await === true) {
+                        asyncBoundaries.push({
+                            position: n.range[0],
+                            label: 'a yield boundary',
+                        });
+                    }
+                    // Recursively walk child nodes
+                    for (const key in n) {
+                        if (key === 'parent')
+                            continue;
+                        const value = n[key];
+                        if (Array.isArray(value)) {
+                            for (const item of value) {
+                                if (item && typeof item === 'object' && item.type) {
+                                    // Skip nested functions unless we're explicitly walking into callbacks
+                                    if (skipNestedFunctions &&
+                                        (item.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                                            item.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                                            item.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
+                                        continue;
+                                    }
+                                    walkNode(item, skipNestedFunctions);
+                                }
+                            }
+                        }
+                        else if (value && typeof value === 'object' && value.type) {
+                            // Skip nested functions unless we're explicitly walking into callbacks
+                            if (skipNestedFunctions &&
+                                (value.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                                    value.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                                    value.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
+                                return;
+                            }
+                            walkNode(value, skipNestedFunctions);
+                        }
+                    }
+                }
+                // Walk the function body
+                if (node.body) {
+                    walkNode(node.body);
+                }
+                // Check for violations
+                const setterCallsByName = new Map();
+                for (const call of setterCalls) {
+                    if (!setterCallsByName.has(call.name)) {
+                        setterCallsByName.set(call.name, []);
+                    }
+                    setterCallsByName.get(call.name).push(call);
+                }
+                // Check each setter for violations
+                for (const [setterName, calls] of setterCallsByName) {
+                    if (calls.length < 2)
+                        continue; // Need at least 2 calls to have a violation
+                    // Check if there are calls both before and after any async boundary
+                    for (const boundary of asyncBoundaries) {
+                        const callsBefore = calls.filter((call) => call.position < boundary.position);
+                        const callsAfter = calls.filter((call) => call.position > boundary.position);
+                        if (callsBefore.length > 0 && callsAfter.length > 0) {
+                            // Report violation on the function node
+                            context.report({
+                                node,
+                                messageId: 'staleStateAcrossAwait',
+                                data: {
+                                    setterName,
+                                    boundaryType: boundary.label,
+                                },
+                            });
+                            break; // Only report once per setter
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-stale-state-across-await.js.map

package/lib/rules/no-static-constants-in-dynamic-files.d.ts

@@ -0,0 +1,3 @@
+export declare const RULE_NAME = "no-static-constants-in-dynamic-files";
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noStaticConstantInDynamicFile", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default _default;

package/lib/rules/no-static-constants-in-dynamic-files.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.RULE_NAME = 'no-static-constants-in-dynamic-files';
+const isDynamicFilename = (filename) => /\.dynamic\.tsx?$/.test(filename);
+const isScreamingSnakeCase = (name) => /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/.test(name);
+/**
+ * Records a leaf binding identifier so SCREAMING_SNAKE_CASE exports are checked.
+ */
+const collectFromIdentifier = (identifier, identifiers) => {
+    identifiers.push(identifier);
+};
+/**
+ * Queues the rest element argument when it is a supported binding pattern so
+ * nested destructuring inside `...` is still inspected for exported constants.
+ */
+const collectFromRestElement = (restElement, queue) => {
+    const argument = restElement.argument;
+    if (argument.type === utils_1.AST_NODE_TYPES.Identifier ||
+        argument.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+        argument.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+        queue.push(argument);
+    }
+};
+/**
+ * Walks object destructuring to capture identifiers and queue nested patterns
+ * (including defaults and rest spreads) so every bound name is inspected.
+ */
+const collectFromObjectPattern = (pattern, identifiers, queue) => {
+    for (const property of pattern.properties) {
+        if (property.type === utils_1.AST_NODE_TYPES.Property) {
+            const value = property.value;
+            if (value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                identifiers.push(value);
+            }
+            else if (value.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                queue.push(value.left);
+            }
+            else if (value.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+                value.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                queue.push(value);
+            }
+        }
+        else if (property.type === utils_1.AST_NODE_TYPES.RestElement) {
+            collectFromRestElement(property, queue);
+        }
+    }
+};
+/**
+ * Walks array destructuring to collect identifiers and queue nested patterns
+ * so array defaults, nesting, and rest elements are not skipped.
+ */
+const collectFromArrayPattern = (pattern, identifiers, queue) => {
+    for (const element of pattern.elements) {
+        if (!element) {
+            continue;
+        }
+        if (element.type === utils_1.AST_NODE_TYPES.Identifier) {
+            identifiers.push(element);
+        }
+        else if (element.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+            queue.push(element.left);
+        }
+        else if (element.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+            element.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+            queue.push(element);
+        }
+        else if (element.type === utils_1.AST_NODE_TYPES.RestElement) {
+            collectFromRestElement(element, queue);
+        }
+    }
+};
+/**
+ * Traverses a binding pattern depth-first and returns every leaf Identifier
+ * so exported destructuring binds are all checked for SCREAMING_SNAKE_CASE.
+ */
+const collectBindingIdentifiers = (pattern) => {
+    const identifiers = [];
+    const queue = [pattern];
+    while (queue.length > 0) {
+        const current = queue.pop();
+        if (!current) {
+            continue;
+        }
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.Identifier:
+                collectFromIdentifier(current, identifiers);
+                break;
+            case utils_1.AST_NODE_TYPES.ObjectPattern:
+                collectFromObjectPattern(current, identifiers, queue);
+                break;
+            case utils_1.AST_NODE_TYPES.ArrayPattern:
+                collectFromArrayPattern(current, identifiers, queue);
+                break;
+            default:
+                break;
+        }
+    }
+    return identifiers;
+};
+exports.default = (0, createRule_1.createRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow exporting SCREAMING_SNAKE_CASE constants from .dynamic.ts/.dynamic.tsx files; move static constants to non-dynamic modules instead.',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [],
+        messages: {
+            noStaticConstantInDynamicFile: 'Global constant "{{name}}" is exported from a .dynamic file. .dynamic files are reserved for runtime-only behavior; move this constant to a non-dynamic module (e.g., config.ts) and import it so static values do not live alongside dynamic code paths.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.filename ?? context.getFilename();
+        if (!isDynamicFilename(filename)) {
+            return {};
+        }
+        return {
+            ExportNamedDeclaration(node) {
+                const declaration = node.declaration;
+                if (!declaration ||
+                    declaration.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
+                    declaration.kind !== 'const') {
+                    return;
+                }
+                declaration.declarations.forEach((declarator) => {
+                    const { id } = declarator;
+                    const identifiers = collectBindingIdentifiers(id);
+                    for (const identifier of identifiers) {
+                        if (!isScreamingSnakeCase(identifier.name)) {
+                            continue;
+                        }
+                        context.report({
+                            node: identifier,
+                            messageId: 'noStaticConstantInDynamicFile',
+                            data: { name: identifier.name },
+                        });
+                    }
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-static-constants-in-dynamic-files.js.map

package/lib/rules/no-try-catch-already-exists-in-transaction.d.ts

@@ -0,0 +1 @@
+export declare const noTryCatchAlreadyExistsInTransaction: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noAlreadyExistsCatchInTransaction", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;