@blumintinc/eslint-plugin-blumint 1.16.2 → 1.17.0

package/lib/rules/prefer-use-base62-id.js

@@ -0,0 +1,483 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferUseBase62Id = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const minimatch_1 = require("minimatch");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_TARGET_PATHS = [
+    'src/hooks/**',
+    'src/contexts/**',
+    'src/pages/**',
+    'src/components/**',
+];
+/**
+ * Returns true when the given source path ends with "util/uuidv4Base62",
+ * covering both relative and absolute import forms used in the BluMint monorepo.
+ */
+function isUuidv4Base62Source(source) {
+    // Strip any file extension the bundler may have appended
+    const normalized = source.replace(/\.(js|ts|tsx|jsx|mjs|cjs)$/, '');
+    return (normalized === 'uuidv4Base62' ||
+        normalized.endsWith('/uuidv4Base62') ||
+        normalized.endsWith('\\uuidv4Base62'));
+}
+/**
+ * Returns true when the function name matches the React hook naming convention:
+ * starts with "use" followed by an uppercase letter.
+ */
+function isHookName(name) {
+    return /^use[A-Z]/.test(name);
+}
+/**
+ * Returns true when the name is PascalCase (starts with uppercase letter),
+ * which is the naming convention for React components.
+ */
+function isPascalCase(name) {
+    return /^[A-Z]/.test(name);
+}
+/**
+ * Checks whether a node is a React component or hook function.
+ * Hooks: function whose name starts with "use" followed by an uppercase letter.
+ * Components: function with a PascalCase name.
+ */
+function isComponentOrHook(node) {
+    // FunctionDeclaration: function MyComponent() {} or function useHook() {}
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+        return isPascalCase(node.id.name) || isHookName(node.id.name);
+    }
+    // FunctionExpression or ArrowFunctionExpression assigned to a variable:
+    // const MyComponent = () => {} or const useHook = () => {}
+    const parent = node.parent;
+    if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+        const id = parent.id;
+        if (id.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return isPascalCase(id.name) || isHookName(id.name);
+        }
+    }
+    return false;
+}
+/**
+ * Recursively searches the given node tree for any CallExpression that calls
+ * one of the tracked uuidv4Base62 local names.
+ */
+function containsUuidv4Base62Call(node, trackedNames) {
+    if (!node)
+        return false;
+    if (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+        trackedNames.has(node.callee.name)) {
+        return true;
+    }
+    // Walk child nodes
+    for (const key of Object.keys(node)) {
+        if (key === 'parent')
+            continue;
+        const child = node[key];
+        if (child && typeof child === 'object') {
+            if (Array.isArray(child)) {
+                for (const item of child) {
+                    if (item &&
+                        typeof item === 'object' &&
+                        'type' in item &&
+                        containsUuidv4Base62Call(item, trackedNames)) {
+                        return true;
+                    }
+                }
+            }
+            else if ('type' in child &&
+                containsUuidv4Base62Call(child, trackedNames)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Returns true when the argument to useRef contains uuidv4Base62() anywhere
+ * in its expression tree (direct call or inside a larger expression).
+ */
+function useRefArgContainsUuid(callNode, trackedNames) {
+    if (callNode.arguments.length === 0)
+        return false;
+    return containsUuidv4Base62Call(callNode.arguments[0], trackedNames);
+}
+/**
+ * For a useState call, returns the argument node that contains uuidv4Base62()
+ * (either the direct first arg or the body of the first arrow function arg).
+ * Returns null when uuidv4Base62() is not found.
+ */
+function getUseStateUuidArg(callNode, trackedNames) {
+    if (callNode.arguments.length === 0)
+        return null;
+    const arg = callNode.arguments[0];
+    // Direct call: useState(uuidv4Base62()) or useState(expr ?? uuidv4Base62())
+    if (containsUuidv4Base62Call(arg, trackedNames))
+        return arg;
+    // Lazy initializer: useState(() => uuidv4Base62()) or useState(() => { return ...; })
+    if (arg.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+        arg.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+        if (containsUuidv4Base62Call(arg.body, trackedNames))
+            return arg.body;
+    }
+    return null;
+}
+/**
+ * Returns true when the useMemo call has an empty dependency array as its
+ * second argument.
+ */
+function hasEmptyDepsArray(callNode) {
+    if (callNode.arguments.length < 2)
+        return false;
+    const deps = callNode.arguments[1];
+    return (deps.type === utils_1.AST_NODE_TYPES.ArrayExpression && deps.elements.length === 0);
+}
+/**
+ * Checks whether the given identifier (the ref variable name) has its
+ * `.current` property assigned anywhere in the enclosing function body.
+ * This mirrors the useState setter-usage heuristic for useRef.
+ */
+function isRefCurrentReassigned(refName, functionBody) {
+    let found = false;
+    function walk(node) {
+        if (!node || found)
+            return;
+        // Look for `refName.current = ...`
+        if (node.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+            node.left.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            !node.left.computed &&
+            node.left.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.left.object.name === refName &&
+            node.left.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.left.property.name === 'current') {
+            found = true;
+            return;
+        }
+        for (const key of Object.keys(node)) {
+            if (key === 'parent')
+                continue;
+            const child = node[key];
+            if (child && typeof child === 'object') {
+                if (Array.isArray(child)) {
+                    for (const item of child) {
+                        if (item && typeof item === 'object' && 'type' in item) {
+                            walk(item);
+                        }
+                    }
+                }
+                else if ('type' in child) {
+                    walk(child);
+                }
+            }
+        }
+    }
+    walk(functionBody);
+    return found;
+}
+exports.preferUseBase62Id = (0, createRule_1.createRule)({
+    name: 'prefer-use-base62-id',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer `useBase62Id()` over `uuidv4Base62()` inside useState/useRef/useMemo for stable component IDs to avoid SSR hydration mismatches',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    targetPaths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: DEFAULT_TARGET_PATHS,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            preferUseBase62IdHook: "Prefer `useBase62Id()` from 'src/hooks/useBase62Id' for stable component IDs. `uuidv4Base62()` uses crypto.getRandomValues() which causes SSR hydration mismatches. `useBase62Id()` is deterministic across server and client rendering.",
+            preferUseBase62IdUseMemo: "Prefer `useBase62Id()` from 'src/hooks/useBase62Id' for stable component IDs. `useMemo(() => uuidv4Base62(), [])` with an empty dependency array is functionally equivalent to `useState(() => uuidv4Base62())` and causes SSR hydration mismatches. Use `useBase62Id()` instead.",
+            preferUseBase62IdTopLevel: 'Calling `uuidv4Base62()` at the top level of a component regenerates the ID on every render. Use `useBase62Id()` for a stable ID, or move the call inside a callback for per-operation uniqueness.',
+        },
+    },
+    defaultOptions: [{}],
+    create(context, [options]) {
+        const targetPaths = options.targetPaths ?? DEFAULT_TARGET_PATHS;
+        // Check whether the current file is inside a target path
+        const filename = context.getFilename();
+        const isInTargetPath = targetPaths.some((pattern) => (0, minimatch_1.minimatch)(filename, pattern, { matchBase: false }));
+        if (!isInTargetPath)
+            return {};
+        // Local names bound to the uuidv4Base62 export in the current file
+        const trackedUuidNames = new Set();
+        const pendingUseStateCalls = [];
+        const pendingUseRefCalls = [];
+        /**
+         * Finds the enclosing React component or hook function body for a given
+         * AST node, walking up the parent chain.
+         */
+        function getEnclosingComponentOrHookBody(node) {
+            let current = node.parent;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    if (isComponentOrHook(current)) {
+                        return current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression
+                            ? current.body
+                            : current.body;
+                    }
+                    // A non-component/hook function boundary — stop searching, we're
+                    // inside a nested callback or event handler.
+                    return null;
+                }
+                current = current.parent;
+            }
+            return null;
+        }
+        /**
+         * Returns the depth at which the immediate parent is a React component or
+         * hook function body, ignoring expression-statement wrappers. Specifically,
+         * returns true when the node's parent chain is:
+         *   ComponentOrHookBody → [ExpressionStatement] → VariableDeclaration → node
+         * i.e. the call is a direct statement inside the component body (not nested
+         * in a callback, effect, or hook call argument).
+         */
+        function isDirectChildOfComponentBody(callNode) {
+            // Walk up past VariableDeclarator → VariableDeclaration → ...
+            let current = callNode.parent;
+            // Allow: CallExpression is the init of a VariableDeclarator
+            if (current?.type !== utils_1.AST_NODE_TYPES.VariableDeclarator)
+                return false;
+            current = current.parent;
+            if (current?.type !== utils_1.AST_NODE_TYPES.VariableDeclaration)
+                return false;
+            current = current.parent;
+            if (current?.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+                current = current.parent;
+            }
+            // The parent must be a block that belongs to a component or hook
+            if (current?.type !== utils_1.AST_NODE_TYPES.BlockStatement)
+                return false;
+            const block = current;
+            const functionNode = block.parent;
+            if (!functionNode)
+                return false;
+            if (functionNode.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                functionNode.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                functionNode.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                return isComponentOrHook(functionNode);
+            }
+            return false;
+        }
+        /**
+         * Returns true when the given CallExpression to useState/useRef/useMemo is
+         * a direct top-level statement inside a React component or hook body
+         * (i.e. not nested inside another hook's callback argument, useEffect, etc.).
+         * Walking upward, the first function boundary we hit determines the answer:
+         * if it is a component or hook → true; otherwise → false.
+         */
+        function isAtComponentTopLevel(callNode) {
+            let current = callNode.parent;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    // The first enclosing function boundary determines whether we are at
+                    // the component/hook top level. If it is not a component or hook (e.g.
+                    // a callback, effect, or event handler), the call is nested and should
+                    // not be flagged.
+                    return isComponentOrHook(current);
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        return {
+            ImportDeclaration(node) {
+                if (!isUuidv4Base62Source(node.source.value))
+                    return;
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        specifier.imported.name === 'uuidv4Base62') {
+                        // Track the local alias (e.g. import { uuidv4Base62 as uuid } ...)
+                        trackedUuidNames.add(specifier.local.name);
+                    }
+                }
+            },
+            CallExpression(node) {
+                if (trackedUuidNames.size === 0)
+                    return;
+                const callee = node.callee;
+                if (callee.type !== utils_1.AST_NODE_TYPES.Identifier)
+                    return;
+                // --- Pattern 3: useMemo(() => uuidv4Base62(), []) ---
+                if (callee.name === 'useMemo') {
+                    if (!hasEmptyDepsArray(node))
+                        return;
+                    const firstArg = node.arguments[0];
+                    if (!firstArg ||
+                        (firstArg.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                            firstArg.type !== utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                        return;
+                    }
+                    if (!containsUuidv4Base62Call(firstArg.body, trackedUuidNames)) {
+                        return;
+                    }
+                    if (!isAtComponentTopLevel(node))
+                        return;
+                    context.report({
+                        node,
+                        messageId: 'preferUseBase62IdUseMemo',
+                    });
+                    return;
+                }
+                // --- Pattern 1: useState(uuidv4Base62()) or useState(() => uuidv4Base62()) ---
+                if (callee.name === 'useState') {
+                    if (!isAtComponentTopLevel(node))
+                        return;
+                    const uuidArg = getUseStateUuidArg(node, trackedUuidNames);
+                    if (!uuidArg)
+                        return;
+                    // Inspect parent to determine setter destructuring
+                    const parent = node.parent;
+                    let setterName = null;
+                    let noSetterDestructured = false;
+                    if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        parent.id.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+                        const elements = parent.id.elements;
+                        if (elements.length >= 2 && elements[1]) {
+                            // Setter is present in destructuring
+                            const setter = elements[1];
+                            if (setter.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                setterName = setter.name;
+                            }
+                            else {
+                                // Non-identifier setter (e.g. rest, pattern): conservatively skip
+                                return;
+                            }
+                        }
+                        else {
+                            // Only value destructured, no setter: `const [id] = useState(...)`
+                            noSetterDestructured = true;
+                        }
+                    }
+                    else if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        // const state = useState(...) — no destructuring, no setter reference
+                        noSetterDestructured = true;
+                    }
+                    else {
+                        // useState not assigned to a variable — treat as no setter
+                        noSetterDestructured = true;
+                    }
+                    pendingUseStateCalls.push({
+                        callNode: node,
+                        setterName,
+                        noSetterDestructured,
+                    });
+                    return;
+                }
+                // --- Pattern 2: useRef(uuidv4Base62()) ---
+                if (callee.name === 'useRef') {
+                    if (!isAtComponentTopLevel(node))
+                        return;
+                    if (!useRefArgContainsUuid(node, trackedUuidNames))
+                        return;
+                    // Find the variable name assigned to the ref
+                    const parent = node.parent;
+                    let refName = null;
+                    if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        refName = parent.id.name;
+                    }
+                    const functionBody = getEnclosingComponentOrHookBody(node);
+                    pendingUseRefCalls.push({
+                        callNode: node,
+                        refName,
+                        functionBody,
+                    });
+                    return;
+                }
+                // --- Pattern 4: bare top-level uuidv4Base62() call ---
+                if (trackedUuidNames.has(callee.name)) {
+                    if (!isDirectChildOfComponentBody(node))
+                        return;
+                    context.report({
+                        node,
+                        messageId: 'preferUseBase62IdTopLevel',
+                    });
+                }
+            },
+            'Program:exit'() {
+                // Evaluate pending useState calls
+                for (const pending of pendingUseStateCalls) {
+                    const { callNode, setterName, noSetterDestructured } = pending;
+                    if (noSetterDestructured) {
+                        // No setter — always flag
+                        context.report({
+                            node: callNode,
+                            messageId: 'preferUseBase62IdHook',
+                        });
+                        continue;
+                    }
+                    if (setterName === null)
+                        continue;
+                    // Check whether the setter identifier is referenced anywhere in the
+                    // file beyond its destructuring site
+                    const scope = context.getScope();
+                    // Walk up to Program scope
+                    let programScope = scope;
+                    while (programScope.upper) {
+                        programScope = programScope.upper;
+                    }
+                    // Find the variable for the setter
+                    function findVarInScope(searchScope, name) {
+                        for (const variable of searchScope.variables) {
+                            if (variable.name === name) {
+                                // References beyond the definition itself indicate usage
+                                const usageRefs = variable.references.filter(
+                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                (ref) => !ref.isWrite() || !ref.init);
+                                return usageRefs.length > 0;
+                            }
+                        }
+                        for (const childScope of searchScope.childScopes) {
+                            if (findVarInScope(childScope, name))
+                                return true;
+                        }
+                        return false;
+                    }
+                    const setterIsUsed = findVarInScope(programScope, setterName);
+                    if (!setterIsUsed) {
+                        context.report({
+                            node: callNode,
+                            messageId: 'preferUseBase62IdHook',
+                        });
+                    }
+                }
+                // Evaluate pending useRef calls
+                for (const pending of pendingUseRefCalls) {
+                    const { callNode, refName, functionBody } = pending;
+                    if (!refName || !functionBody) {
+                        // Cannot determine ref name or body — flag conservatively
+                        context.report({
+                            node: callNode,
+                            messageId: 'preferUseBase62IdHook',
+                        });
+                        continue;
+                    }
+                    if (!isRefCurrentReassigned(refName, functionBody)) {
+                        context.report({
+                            node: callNode,
+                            messageId: 'preferUseBase62IdHook',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-use-base62-id.js.map

package/lib/rules/prefer-use-theme.d.ts

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

package/lib/rules/prefer-use-theme.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferUseTheme = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * The style module path fragments that contain theme constants. Matching is
+ * done via substring check on the raw import source value, so relative paths
+ * like `../../../styles/palette` and absolute-from-src paths like
+ * `src/styles/palette` both match `styles/palette`.
+ */
+const BANNED_STYLE_MODULE_FRAGMENTS = new Set([
+    'styles/palette',
+    'styles/elevations',
+    'styles/shadows',
+    'styles/scrollbars',
+    'styles/panels',
+    'styles/lineClamp',
+    'styles/typography',
+    'styles/system',
+    'styles/layout',
+]);
+/**
+ * The named export constants that are exposed on the MUI theme object and must
+ * be accessed via `useTheme()` (or the `sx` theme callback) rather than direct
+ * import. Only these specific names are flagged to avoid false positives from
+ * other exports (e.g. `COLORS`, `EASING`) that are NOT on the theme object.
+ */
+const BANNED_CONSTANTS = new Set([
+    'PALETTE',
+    'RARITIES',
+    'RARITIES_HOVER',
+    'RARITIES_BACKGROUND',
+    'ELEVATION',
+    'ELEVATIONS',
+    'SHADOWS',
+    'SHADOWS_HARD',
+    'BACKDROP_FILTERS',
+    'GLOWS',
+    'SCROLLBARS',
+    'PANELS',
+    'LINE_CLAMP',
+    'TYPOGRAPHY',
+    'ZINDEX',
+    'ASPECT_RATIO',
+    'BREAKPOINTS',
+    'BORDER_RADIUS',
+    'CONTAINER_WIDTH',
+]);
+/**
+ * Map from constant name to its theme-object equivalent path, used in the
+ * error message so that developers know exactly where to find the value on the
+ * theme object.
+ */
+const THEME_EQUIVALENTS = {
+    PALETTE: 'theme.palette',
+    RARITIES: 'theme.palette.rarity',
+    RARITIES_HOVER: 'theme.palette.rarityHover',
+    RARITIES_BACKGROUND: 'theme.palette.rarityBackground',
+    ELEVATION: 'theme.palette.background.elevation',
+    ELEVATIONS: 'theme.palette.background.elevation',
+    SHADOWS: 'theme.shadows',
+    SHADOWS_HARD: 'theme.shadowsHard',
+    BACKDROP_FILTERS: 'theme.glass',
+    GLOWS: 'theme.glow',
+    SCROLLBARS: 'theme.scrollbars',
+    PANELS: 'theme.panels',
+    LINE_CLAMP: 'theme.lineClamp',
+    TYPOGRAPHY: 'theme.typography',
+    ZINDEX: 'theme.zIndex',
+    ASPECT_RATIO: 'theme.aspectRatio',
+    BREAKPOINTS: 'theme.breakpoints',
+    BORDER_RADIUS: 'theme.shape.borderRadius',
+    CONTAINER_WIDTH: 'theme.mixins',
+};
+/**
+ * Target file path fragments that the rule enforces inside. Files outside
+ * these directories are not flagged — this avoids false positives in utility
+ * or configuration modules that may have legitimate reasons to reference
+ * constants outside of a React rendering context.
+ */
+const TARGET_PATH_FRAGMENTS = [
+    'src/components/',
+    'src/hooks/',
+    'src/contexts/',
+    'src/pages/',
+];
+/** Returns true when the file is inside one of the target directories. */
+function isInTargetPath(filename) {
+    return TARGET_PATH_FRAGMENTS.some((fragment) => filename.includes(fragment));
+}
+/**
+ * Returns true when the file is inside `src/styles/`. These files BUILD the
+ * theme object and cannot use `useTheme()` because the hook is unavailable
+ * outside React component rendering context.
+ */
+function isInStylesDir(filename) {
+    return filename.includes('src/styles/');
+}
+/** Returns true when the file is a test or spec file. */
+function isTestFile(filename) {
+    return (filename.endsWith('.test.ts') ||
+        filename.endsWith('.test.tsx') ||
+        filename.endsWith('.spec.ts') ||
+        filename.endsWith('.spec.tsx') ||
+        filename.includes('__tests__/'));
+}
+/**
+ * Returns true when the import source resolves to one of the banned style
+ * modules. Matching is done via substring check, so both relative paths
+ * (`../../../styles/palette`) and paths with a `src/` prefix
+ * (`src/styles/palette`) are detected.
+ */
+function isBannedStyleModule(source) {
+    for (const fragment of BANNED_STYLE_MODULE_FRAGMENTS) {
+        if (source.includes(fragment)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.preferUseTheme = (0, createRule_1.createRule)({
+    name: 'prefer-use-theme',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce reading MUI theme values via useTheme() or the sx theme callback instead of importing theme constants directly from src/styles/* modules.',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            preferUseTheme: "Import '{{importName}}' from '{{sourceModule}}' bypasses the MUI theme system. Use useTheme() and access {{themeEquivalent}} instead.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.getFilename?.() ??
+            context.filename ??
+            '';
+        // Files that build the theme are always exempt.
+        if (isInStylesDir(filename)) {
+            return {};
+        }
+        // Test/spec files are exempt — they often assert against raw constant values.
+        if (isTestFile(filename)) {
+            return {};
+        }
+        // Only enforce inside the four target directories.
+        if (!isInTargetPath(filename)) {
+            return {};
+        }
+        return {
+            ImportDeclaration(node) {
+                // Type-only import declarations never bypass the theme system.
+                if (node.importKind === 'type') {
+                    return;
+                }
+                const source = node.source.value;
+                if (!isBannedStyleModule(source)) {
+                    return;
+                }
+                // Namespace imports (`import * as X from '...'`) expose all exports,
+                // so we flag the entire namespace specifier when the source is banned.
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                        context.report({
+                            node: specifier,
+                            messageId: 'preferUseTheme',
+                            data: {
+                                importName: `* as ${specifier.local.name}`,
+                                sourceModule: source,
+                                themeEquivalent: 'the theme object via useTheme()',
+                            },
+                        });
+                        continue;
+                    }
+                    // Named imports: only flag specifiers that are in the banned set.
+                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                        // Skip type-only specifiers within a value import statement.
+                        if (specifier.importKind === 'type') {
+                            continue;
+                        }
+                        const importedName = specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier
+                            ? specifier.imported.name
+                            : '';
+                        if (!BANNED_CONSTANTS.has(importedName)) {
+                            continue;
+                        }
+                        const themeEquivalent = THEME_EQUIVALENTS[importedName] ??
+                            'the theme object via useTheme()';
+                        context.report({
+                            node: specifier,
+                            messageId: 'preferUseTheme',
+                            data: {
+                                importName: importedName,
+                                sourceModule: source,
+                                themeEquivalent,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=prefer-use-theme.js.map