@blumintinc/eslint-plugin-blumint 1.21.18 → 1.23.0

package/lib/rules/no-margin-properties.d.ts

@@ -1 +1,9 @@
-export declare const noMarginProperties: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noMarginProperties", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+type Options = [
+    {
+        exemptZero?: boolean;
+        exemptAuto?: boolean;
+        exemptNegative?: boolean;
+    }
+];
+export declare const noMarginProperties: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noMarginProperties", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/no-margin-properties.js

@@ -65,6 +65,110 @@ const MARGIN_PROPERTIES = new Set([
     'ml',
     'm',
 ]);
+const ZERO_LENGTH = /^[+-]?(?:0+\.?0*|\.0+)(?:[a-z]+|%)?$/;
+const NEGATIVE_LENGTH = /^-(?:\d+\.?\d*|\.\d+)(?:[a-z]+|%)?$/;
+function classifyMarginToken(token) {
+    if (token === 'auto')
+        return 'auto';
+    if (ZERO_LENGTH.test(token))
+        return 'zero';
+    if (NEGATIVE_LENGTH.test(token))
+        return 'negative';
+    return 'spacing';
+}
+/**
+ * A string value may be a 1-4 token `margin` shorthand (`'0 auto'`), so every
+ * token is classified; `!important` changes the cascade, not the value.
+ */
+function classifyMarginString(value) {
+    const tokens = value
+        .replace(/\s*!important\s*$/i, '')
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean);
+    return tokens.length === 0 ? ['spacing'] : tokens.map(classifyMarginToken);
+}
+function classifyMarginNumber(value) {
+    if (value === 0)
+        return 'zero';
+    return value < 0 ? 'negative' : 'spacing';
+}
+/**
+ * Every kind a margin value can take, or `null` when any part of it is
+ * unreadable (a variable, a call, a template substitution). A conditional and
+ * MUI's responsive object and array forms yield the kinds of all their
+ * branches, since any one of them may render.
+ */
+function classifyMarginValue(node) {
+    const value = unwrapAssertions(node);
+    switch (value.type) {
+        case utils_1.AST_NODE_TYPES.Literal:
+            if (typeof value.value === 'number') {
+                return [classifyMarginNumber(value.value)];
+            }
+            return typeof value.value === 'string'
+                ? classifyMarginString(value.value)
+                : null;
+        case utils_1.AST_NODE_TYPES.UnaryExpression:
+            if ((value.operator === '-' || value.operator === '+') &&
+                value.argument.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof value.argument.value === 'number') {
+                return [
+                    classifyMarginNumber(value.operator === '-'
+                        ? -value.argument.value
+                        : value.argument.value),
+                ];
+            }
+            return null;
+        case utils_1.AST_NODE_TYPES.TemplateLiteral:
+            return value.expressions.length === 0
+                ? classifyMarginString(value.quasis[0].value.cooked ?? value.quasis[0].value.raw)
+                : null;
+        case utils_1.AST_NODE_TYPES.JSXExpressionContainer:
+            return value.expression.type === utils_1.AST_NODE_TYPES.JSXEmptyExpression
+                ? null
+                : classifyMarginValue(value.expression);
+        case utils_1.AST_NODE_TYPES.ConditionalExpression:
+            return combineMarginKinds([value.consequent, value.alternate]);
+        case utils_1.AST_NODE_TYPES.ObjectExpression:
+            return combineMarginKinds(value.properties.map((entry) => entry.type === utils_1.AST_NODE_TYPES.Property && !entry.computed
+                ? entry.value
+                : null));
+        case utils_1.AST_NODE_TYPES.ArrayExpression:
+            return combineMarginKinds(value.elements.filter((element) => element !== null));
+        default:
+            return null;
+    }
+}
+/**
+ * MUI's responsive array and object forms read a `null` entry as "skip this
+ * breakpoint" (`[null, 0]` sets a margin from `sm` up only), and `sx` drops a
+ * `null` value outright, so a `null` part renders no margin at all.
+ */
+function isNullLiteral(node) {
+    const value = unwrapAssertions(node);
+    return value.type === utils_1.AST_NODE_TYPES.Literal && value.raw === 'null';
+}
+/**
+ * The kinds of every part of a composite value. A `null` part adds no kind,
+ * and a composite left with none (`[]`, `{}`, `[null, null]`) sets no margin
+ * that could earn an exemption, so it keeps the report like an unreadable one.
+ */
+function combineMarginKinds(nodes) {
+    const kinds = [];
+    for (const node of nodes) {
+        if (!node || node.type === utils_1.AST_NODE_TYPES.SpreadElement)
+            return null;
+        if (isNullLiteral(node))
+            continue;
+        const nodeKinds = classifyMarginValue(node);
+        if (!nodeKinds)
+            return null;
+        kinds.push(...nodeKinds);
+    }
+    return kinds.length === 0 ? null : kinds;
+}
 exports.noMarginProperties = (0, createRule_1.createRule)({
     name: 'no-margin-properties',
     meta: {
@@ -73,18 +177,61 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
             description: 'Prevent margin properties (margin, marginLeft, marginRight, marginTop, marginBottom, mx, my, etc.) in MUI styling because margins fight container-controlled spacing, double gutters, and misaligned breakpoints; keep spacing centralized with padding, gap, or spacing props instead.',
             recommended: 'error',
         },
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    exemptZero: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                    exemptAuto: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                    exemptNegative: {
+                        type: 'boolean',
+                        default: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             noMarginProperties: 'Margin property "{{property}}" in MUI styling fights container-controlled spacing (Stack/Grid spacing, gap, responsive gutters) and produces double gutters, misalignment, and overflow as layouts shift. Keep spacing inside the component with padding or let the parent handle separation via gap/spacing so layout remains predictable.',
         },
     },
-    defaultOptions: [],
-    create(context) {
+    defaultOptions: [
+        {
+            exemptZero: true,
+            exemptAuto: true,
+            exemptNegative: true,
+        },
+    ],
+    create(context, [options]) {
         const seenNodes = new WeakSet();
+        const exemptKinds = new Set();
+        if (options.exemptZero !== false)
+            exemptKinds.add('zero');
+        if (options.exemptAuto !== false)
+            exemptKinds.add('auto');
+        if (options.exemptNegative !== false)
+            exemptKinds.add('negative');
         function checkProperty(propertyName) {
             const normalizedName = normalizePropertyName(propertyName);
             return MARGIN_PROPERTIES.has(normalizedName);
         }
+        /**
+         * A value is exempt only when every part of it is a reset, `auto` or a
+         * negative offset whose exemption is on: one spacing token (`'0 8px'`) or
+         * one unreadable branch keeps the report.
+         */
+        function isExemptValue(value) {
+            if (!value)
+                return false;
+            const kinds = classifyMarginValue(value);
+            return !!kinds && kinds.every((kind) => exemptKinds.has(kind));
+        }
         /**
          * True if node is in a flagged MUI styling context (sx attribute, sx
          * object property, or css() call). Excludes createTheme styleOverrides:
@@ -159,7 +306,9 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
                     .join('');
                 propertyName = quasis + expressions;
             }
-            if (propertyName && checkProperty(propertyName)) {
+            if (propertyName &&
+                checkProperty(propertyName) &&
+                !isExemptValue(node.value)) {
                 // Check if in MUI styling context
                 if (isMuiStylingContext(node)) {
                     context.report({
@@ -283,7 +432,9 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
                             else if (key.type === utils_1.AST_NODE_TYPES.Literal) {
                                 propertyName = String(key.value);
                             }
-                            if (propertyName && checkProperty(propertyName)) {
+                            if (propertyName &&
+                                checkProperty(propertyName) &&
+                                !isExemptValue(prop.value)) {
                                 // Check if this variable is used in an sx prop
                                 if (sourceText.includes(`sx={${variableName}}`) ||
                                     sourceText.includes(`sx={{ ...${variableName}`) ||
@@ -307,7 +458,7 @@ exports.noMarginProperties = (0, createRule_1.createRule)({
                     if (attr.type === utils_1.AST_NODE_TYPES.JSXAttribute &&
                         attr.name.type === utils_1.AST_NODE_TYPES.JSXIdentifier) {
                         const attrName = attr.name.name;
-                        if (checkProperty(attrName)) {
+                        if (checkProperty(attrName) && !isExemptValue(attr.value)) {
                             context.report({
                                 node: attr,
                                 messageId: 'noMarginProperties',

package/lib/rules/require-sx-props-theme.d.ts

@@ -0,0 +1,2 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const requireSxPropsTheme: TSESLint.RuleModule<"requireSxPropsTheme", [], TSESLint.RuleListener>;

package/lib/rules/require-sx-props-theme.js

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireSxPropsTheme = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const createRule_1 = require("../utils/createRule");
+/**
+ * Every module MUI re-exports `SxProps` from. Matching on the module and the
+ * imported name, never the local name, is what lets a renamed import report
+ * and a same-named local type or shim stay silent.
+ */
+const SX_PROPS_SOURCES = new Set([
+    '@mui/material',
+    '@mui/material/styles',
+    '@mui/system',
+    '@mui/system/styleFunctionSx',
+]);
+/**
+ * The module a MUI app augments its theme through
+ * (`declare module '@mui/material/styles' { interface Theme { … } }`), so it is
+ * the only source whose `Theme` is provably the app theme, whichever module
+ * `SxProps` itself came from.
+ */
+const THEME_SOURCE = '@mui/material/styles';
+const SX_PROPS_NAME = 'SxProps';
+const THEME_NAME = 'Theme';
+/**
+ * The type argument list, read from whichever property the host
+ * `@typescript-eslint` version populates: v5 fills `typeParameters`, v6 adds
+ * `typeArguments`, and v8 drops `typeParameters` from `TSTypeReference`.
+ */
+function hasTypeArguments(node) {
+    const { typeArguments } = node;
+    return Boolean(typeArguments ?? node.typeParameters);
+}
+/**
+ * `import { "SxProps" as Sx }` arrives as a string literal on parsers that
+ * support arbitrary module namespace names, so both spellings are read.
+ */
+function importedNameOf(specifier) {
+    const imported = specifier.imported;
+    return imported.type === utils_1.AST_NODE_TYPES.Identifier
+        ? imported.name
+        : imported.value;
+}
+/**
+ * ES import declarations sit at the top level or directly inside an ambient
+ * `declare module '…' { }` block; nothing else can hold one.
+ */
+function collectImportDeclarations(statements, into) {
+    for (const statement of statements) {
+        if (statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration) {
+            into.push(statement);
+        }
+        else if (statement.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration &&
+            statement.body?.type === utils_1.AST_NODE_TYPES.TSModuleBlock) {
+            collectImportDeclarations(statement.body.body, into);
+        }
+    }
+}
+/**
+ * The innermost binding of `name` visible from `scope`. A value-only binding
+ * stops the walk even though TypeScript would look past it for a type name;
+ * that errs toward silence, never toward a wrong report or fix.
+ */
+function findVariable(scope, name) {
+    let current = scope;
+    while (current) {
+        const variable = current.set.get(name);
+        if (variable) {
+            return variable;
+        }
+        current = current.upper;
+    }
+    return undefined;
+}
+function importClauseOf(variable) {
+    if (!variable || variable.defs.length !== 1) {
+        return undefined;
+    }
+    const [definition] = variable.defs;
+    if (definition.type !== 'ImportBinding') {
+        return undefined;
+    }
+    const clause = definition.node;
+    return clause.type === utils_1.AST_NODE_TYPES.ImportSpecifier ||
+        clause.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        clause.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier
+        ? clause
+        : undefined;
+}
+function sourceOf(clause) {
+    return clause.parent.source.value;
+}
+function isNamedImportOf(clause, importedName, isAllowedSource) {
+    return (clause?.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        importedNameOf(clause) === importedName &&
+        isAllowedSource(sourceOf(clause)));
+}
+const isSxPropsSource = (source) => SX_PROPS_SOURCES.has(source);
+const isThemeSource = (source) => source === THEME_SOURCE;
+/**
+ * Inside `declare module '@mui/material/styles' { … }` the `Theme` in reach is
+ * the interface being augmented, and an import spliced into or above the
+ * ambient block changes what the declaration file means.
+ */
+function isInsideThemeAugmentation(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration &&
+            current.id.type === utils_1.AST_NODE_TYPES.Literal &&
+            current.id.value === THEME_SOURCE) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function isTypeOnlyImport(clause) {
+    const declaration = clause.parent;
+    return declaration.importKind === 'type' || clause.importKind === 'type';
+}
+exports.requireSxPropsTheme = (0, createRule_1.createRule)({
+    name: 'require-sx-props-theme',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: "Require MUI `SxProps` to carry the app theme as `SxProps<Theme>`, because the bare type defaults to `SxProps<{}>`: `sx` callbacks lose the theme's typing and TypeScript pays for a structural comparison against MUI's own `SxProps<Theme>`",
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            requireSxPropsTheme: "`{{typeName}}` has no theme argument, so MUI defaults it to `SxProps<{}>`: an `sx` callback's `theme` is typed `{}`, and TypeScript compares this type structurally against MUI's `SxProps<Theme>` wherever the two meet, which can cost seconds of type checking per file. Write `{{typeName}}<Theme>` with `Theme` from '@mui/material/styles'.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        const program = sourceCode.ast;
+        const allImports = [];
+        collectImportDeclarations(program.body, allImports);
+        const sxPropsLocalNames = new Set();
+        const sxNamespaceLocalNames = new Set();
+        for (const declaration of allImports) {
+            if (!isSxPropsSource(declaration.source.value)) {
+                continue;
+            }
+            for (const specifier of declaration.specifiers) {
+                if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    importedNameOf(specifier) === SX_PROPS_NAME) {
+                    sxPropsLocalNames.add(specifier.local.name);
+                }
+                else if (specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                    sxNamespaceLocalNames.add(specifier.local.name);
+                }
+            }
+        }
+        const importsSxProps = sxPropsLocalNames.size > 0 || sxNamespaceLocalNames.size > 0;
+        /**
+         * Only a top-level import can be extended or anchored after: one inside an
+         * ambient module block binds nothing outside it, and a file with no
+         * top-level import is a global script that a new import would turn into a
+         * module.
+         */
+        const topLevelImports = program.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+        const themeSourceImports = topLevelImports.filter((declaration) => isThemeSource(declaration.source.value));
+        /**
+         * An unresolved `Theme` elsewhere in the file (a global, or a name the file
+         * never declared) would silently change meaning once an import binds the
+         * name at module scope.
+         */
+        let hasUnresolvedTheme;
+        const themeIsReferencedUnresolved = () => {
+            if (hasUnresolvedTheme === undefined) {
+                const globalScope = sourceCode.scopeManager?.globalScope;
+                hasUnresolvedTheme = Boolean(globalScope?.through.some((reference) => reference.identifier.name === THEME_NAME));
+            }
+            return hasUnresolvedTheme;
+        };
+        function resolvesTo(scope, name, clause) {
+            return importClauseOf(findVariable(scope, name)) === clause;
+        }
+        function isReportableSxProps(typeName, scope) {
+            if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return (sxPropsLocalNames.has(typeName.name) &&
+                    isNamedImportOf(importClauseOf(findVariable(scope, typeName.name)), SX_PROPS_NAME, isSxPropsSource));
+            }
+            if (typeName.type !== utils_1.AST_NODE_TYPES.TSQualifiedName ||
+                typeName.right.name !== SX_PROPS_NAME ||
+                typeName.left.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                !sxNamespaceLocalNames.has(typeName.left.name)) {
+                return false;
+            }
+            const clause = importClauseOf(findVariable(scope, typeName.left.name));
+            return (clause?.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier &&
+                isSxPropsSource(sourceOf(clause)));
+        }
+        /** An existing `Theme` import, under whatever local name reaches the node. */
+        function existingThemeName(scope) {
+            if (isNamedImportOf(importClauseOf(findVariable(scope, THEME_NAME)), THEME_NAME, isThemeSource)) {
+                return THEME_NAME;
+            }
+            for (const declaration of themeSourceImports) {
+                for (const specifier of declaration.specifiers) {
+                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        importedNameOf(specifier) === THEME_NAME &&
+                        resolvesTo(scope, specifier.local.name, specifier)) {
+                        return specifier.local.name;
+                    }
+                }
+            }
+            return undefined;
+        }
+        /** `Styles.Theme` through a namespace import, which adds no binding. */
+        function namespaceThemeText(scope) {
+            for (const declaration of themeSourceImports) {
+                for (const specifier of declaration.specifiers) {
+                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier &&
+                        resolvesTo(scope, specifier.local.name, specifier)) {
+                        return `${specifier.local.name}.${THEME_NAME}`;
+                    }
+                }
+            }
+            return undefined;
+        }
+        /**
+         * Mirrors the declaration's own convention so a `verbatimModuleSyntax` or
+         * `consistent-type-imports` project stays clean: a type-only declaration
+         * takes a plain specifier, inline `type` specifiers call for another, and a
+         * declaration with no type marker follows how `SxProps` itself arrived.
+         */
+        function themeSpecifierText(declaration, sxPropsClause) {
+            if (declaration.importKind === 'type') {
+                return THEME_NAME;
+            }
+            const usesInlineType = declaration.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                specifier.importKind === 'type');
+            const sxPropsIsTypeOnly = sxPropsClause !== undefined &&
+                sxPropsClause.parent !== declaration &&
+                isTypeOnlyImport(sxPropsClause);
+            return usesInlineType || sxPropsIsTypeOnly
+                ? `type ${THEME_NAME}`
+                : THEME_NAME;
+        }
+        function extendNamedImport(declaration, specifiers, sxPropsClause) {
+            const text = themeSpecifierText(declaration, sxPropsClause);
+            const lastSpecifier = specifiers[specifiers.length - 1];
+            const openingBrace = sourceCode.getTokenBefore(specifiers[0]);
+            const isMultiline = openingBrace !== null &&
+                openingBrace.loc.end.line !== lastSpecifier.loc.start.line;
+            if (!isMultiline) {
+                return (fixer) => fixer.insertTextAfter(lastSpecifier, `, ${text}`);
+            }
+            const lineText = sourceCode.lines[lastSpecifier.loc.start.line - 1];
+            const indent = /^[\t ]*/.exec(lineText)?.[0] ?? '';
+            const trailingComma = sourceCode.getTokenAfter(lastSpecifier);
+            if (trailingComma?.value !== ',') {
+                return (fixer) => fixer.insertTextAfter(lastSpecifier, `,\n${indent}${text}`);
+            }
+            // A same-line comment after the trailing comma annotates the specifier
+            // above it, so the new specifier goes on the next line, below the comment.
+            let anchor = trailingComma;
+            for (const comment of sourceCode.getCommentsAfter(trailingComma)) {
+                if (comment.loc.start.line !== trailingComma.loc.end.line) {
+                    break;
+                }
+                anchor = comment;
+            }
+            return (fixer) => fixer.insertTextAfterRange(anchor.range, `\n${indent}${text},`);
+        }
+        function insertNewImport(lastImport) {
+            const quote = lastImport.source.raw.startsWith('"') ? '"' : "'";
+            const lastToken = sourceCode.getLastToken(lastImport);
+            const semicolon = lastToken?.value === ';' ? ';' : '';
+            const statement = `import type { ${THEME_NAME} } from ${quote}${THEME_SOURCE}${quote}${semicolon}`;
+            // A trailing same-line comment stays with the import it annotates.
+            let anchor = lastImport;
+            for (const comment of sourceCode.getCommentsAfter(lastImport)) {
+                if (comment.loc.start.line !== lastImport.loc.end.line) {
+                    break;
+                }
+                anchor = comment;
+            }
+            return (fixer) => fixer.insertTextAfterRange(anchor.range, `\n${statement}`);
+        }
+        function planFix(node, scope) {
+            if (isInsideThemeAugmentation(node)) {
+                return undefined;
+            }
+            const existing = existingThemeName(scope);
+            if (existing) {
+                return { themeText: existing };
+            }
+            // Adding a `Theme` binding is safe only where the name is free, both at
+            // the node and everywhere else in the file.
+            if (findVariable(scope, THEME_NAME) !== undefined ||
+                themeIsReferencedUnresolved()) {
+                const namespaced = namespaceThemeText(scope);
+                return namespaced ? { themeText: namespaced } : undefined;
+            }
+            const sxPropsClause = node.typeName.type === utils_1.AST_NODE_TYPES.Identifier
+                ? importClauseOf(findVariable(scope, node.typeName.name))
+                : undefined;
+            for (const declaration of themeSourceImports) {
+                const specifiers = declaration.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
+                if (specifiers.length > 0) {
+                    return {
+                        themeText: THEME_NAME,
+                        importFix: extendNamedImport(declaration, specifiers, sxPropsClause),
+                    };
+                }
+            }
+            const namespaced = namespaceThemeText(scope);
+            if (namespaced) {
+                return { themeText: namespaced };
+            }
+            const lastImport = topLevelImports[topLevelImports.length - 1];
+            if (!lastImport) {
+                return undefined;
+            }
+            return {
+                themeText: THEME_NAME,
+                importFix: insertNewImport(lastImport),
+            };
+        }
+        return {
+            TSTypeReference(node) {
+                if (!importsSxProps || hasTypeArguments(node)) {
+                    return;
+                }
+                const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
+                if (!isReportableSxProps(node.typeName, scope)) {
+                    return;
+                }
+                const plan = planFix(node, scope);
+                context.report({
+                    node,
+                    messageId: 'requireSxPropsTheme',
+                    data: { typeName: sourceCode.getText(node.typeName) },
+                    // Each report carries its own import edit so any single fix is
+                    // complete on its own. Two reports editing the same import overlap,
+                    // so ESLint applies one per pass and the next pass sees `Theme`
+                    // imported and needs only the insertions.
+                    fix: plan
+                        ? (fixer) => {
+                            const fixes = [
+                                fixer.insertTextAfter(node.typeName, `<${plan.themeText}>`),
+                            ];
+                            if (plan.importFix) {
+                                fixes.push(plan.importFix(fixer));
+                            }
+                            return fixes;
+                        }
+                        : null,
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=require-sx-props-theme.js.map

package/lib/utils/fixtureTypeProgram.js

@@ -465,6 +465,51 @@ declare module 'functions/src/util/assertSafe' {
   export function assertSafe<T extends PropertyKey>(key: T): T;
 }
 `;
+/**
+ * `@mui/material/styles`, the module `require-sx-props-theme` draws `Theme`
+ * from, and `@mui/system/styleFunctionSx`, the deepest `SxProps` it rewrites.
+ * Under the wildcard alone a named import is a VALUE of type `any`, so writing
+ * `SxProps` or `Theme` in a type position is TS2709 on the input and output
+ * alike, and every pair of that fixer was held out. It earns a shape under the
+ * stated policy: the fix writes a type argument drawn from this module, and a
+ * wrong one — an unbound `Theme`, a second `Theme` import, a namespace member
+ * that does not exist — is a type error.
+ *
+ * `SxProps` is the shipped union from `styleFunctionSx.d.ts`, with
+ * `SystemStyleObject` reduced to an open record: the CSS property types add
+ * noise, not detection. `Theme` is open for the same reason, so a fixture
+ * reading `theme.palette.*` or augmenting the interface still compiles.
+ * `useTheme` and `createTheme` carry their shipped signatures because other
+ * rules' fixtures import them from here; the barrel `@mui/material` and
+ * `@mui/system` stay on the wildcard, since fixtures import members from them
+ * that exist in no typings (`FlexRow`, `CustomWidget`).
+ */
+const MUI_SX_PROPS_SHAPE = `
+  type SystemStyleObject<Theme extends object = {}> = { [key: string]: any };
+  export type SxProps<Theme extends object = {}> =
+    | SystemStyleObject<Theme>
+    | ((theme: Theme) => SystemStyleObject<Theme>)
+    | ReadonlyArray<
+        | boolean
+        | SystemStyleObject<Theme>
+        | ((theme: Theme) => SystemStyleObject<Theme>)
+      >;
+`;
+const MUI_STYLES_STUB = `
+declare module '@mui/material/styles' {
+  export interface Theme { [key: string]: any }
+  ${MUI_SX_PROPS_SHAPE}
+  export function useTheme<T = Theme>(): T;
+  export function createTheme(options?: any, ...args: object[]): Theme;
+  export const styled: any;
+  export type CSSObject = any;
+  export type Mixins = any;
+  export type Shadows = any;
+}
+declare module '@mui/system/styleFunctionSx' {
+  ${MUI_SX_PROPS_SHAPE}
+}
+`;
 exports.STUBS = `
 declare module '*';
 ${exports.REACT_STUB}
@@ -472,6 +517,7 @@ ${exports.FIRESTORE_ADMIN_STUB}
 ${exports.FIRESTORE_CLIENT_STUB}
 ${exports.SUBSTITUTION_PARTNER_STUBS}
 ${ASSERT_SAFE_STUB}
+${MUI_STYLES_STUB}
 declare namespace JSX {
   interface IntrinsicElements { [k: string]: any }
   interface Element {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.21.18",
+  "version": "1.23.0",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",