@blumintinc/eslint-plugin-blumint 1.16.0 → 1.16.2

package/lib/index.js

@@ -196,7 +196,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.16.0',
+        version: '1.16.2',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-assert-safe-object-key.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceAssertSafeObjectKey = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const DEFAULT_IMPORT_PATH = 'functions/src/util/assertSafe';
 exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
     name: 'enforce-assert-safe-object-key',
@@ -66,6 +67,29 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                 return createFixes(fixer, node, expressionText);
             },
         });
+        /**
+         * Returns true when the identifier was initialized directly from an
+         * assertSafe(...) call, e.g. `const safeKey = assertSafe(rawKey)`.
+         * Only direct, single-step initializers count — transitive aliases
+         * (const b = a) are not followed so they continue to be flagged.
+         * findVariableInScope returns the nearest binding, so an inner variable
+         * that shadows an outer assertSafe-initialized one is correctly not exempt.
+         */
+        const isAssertSafeValidatedIdentifier = (node) => {
+            const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, node.name);
+            if (!variable)
+                return false;
+            return variable.defs.some((def) => {
+                const init = def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator
+                    ? def.node.init
+                    : null;
+                return (!!init &&
+                    init.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    init.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    init.callee.name === 'assertSafe');
+            });
+        };
         return {
             ImportDeclaration(node) {
                 // Check if assertSafe is already imported
@@ -193,6 +217,11 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                         if (isLikelyArray) {
                             return;
                         }
+                        // Variables initialized directly from assertSafe(...) are already
+                        // validated — no need to double-wrap them.
+                        if (isAssertSafeValidatedIdentifier(property)) {
+                            return;
+                        }
                         const propText = context.sourceCode.getText(property);
                         reportUseAssertSafe(property, propText);
                         return;

package/lib/rules/enforce-dynamic-imports.d.ts

@@ -1,10 +1,13 @@
 export declare const RULE_NAME = "enforce-dynamic-imports";
 type Options = [
     {
+        libraries?: string[];
         ignoredLibraries?: string[];
+        internalPrefixes?: string[];
         allowImportType?: boolean;
     }
 ];
 export declare const DEFAULT_IGNORED_LIBRARIES: string[];
+export declare const DEFAULT_INTERNAL_PREFIXES: string[];
 declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"dynamicImportRequired", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
 export default _default;

package/lib/rules/enforce-dynamic-imports.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_IGNORED_LIBRARIES = exports.RULE_NAME = void 0;
+exports.DEFAULT_INTERNAL_PREFIXES = exports.DEFAULT_IGNORED_LIBRARIES = exports.RULE_NAME = void 0;
 const createRule_1 = require("../utils/createRule");
 const minimatch_1 = require("minimatch");
+const module_1 = require("module");
 exports.RULE_NAME = 'enforce-dynamic-imports';
 exports.DEFAULT_IGNORED_LIBRARIES = [
     'react',
@@ -19,6 +20,14 @@ exports.DEFAULT_IGNORED_LIBRARIES = [
     'clsx',
     'tailwind-merge',
 ];
+exports.DEFAULT_INTERNAL_PREFIXES = ['src/', 'functions/'];
+// Pre-built set of Node.js core module names for O(1) lookup.
+const NODE_BUILTINS = new Set(module_1.builtinModules);
+// Returns true for any source that resolves to a Node builtin: bare name
+// ('crypto'), node:-prefixed ('node:fs'), or path form ('fs/promises').
+const isNodeBuiltin = (source) => source.startsWith('node:') ||
+    NODE_BUILTINS.has(source) ||
+    NODE_BUILTINS.has(source.split('/')[0]);
 exports.default = (0, createRule_1.createRule)({
     name: exports.RULE_NAME,
     meta: {
@@ -31,12 +40,24 @@ exports.default = (0, createRule_1.createRule)({
             {
                 type: 'object',
                 properties: {
+                    libraries: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
                     ignoredLibraries: {
                         type: 'array',
                         items: {
                             type: 'string',
                         },
                     },
+                    internalPrefixes: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
                     allowImportType: {
                         type: 'boolean',
                     },
@@ -51,29 +72,46 @@ exports.default = (0, createRule_1.createRule)({
     defaultOptions: [
         {
             ignoredLibraries: exports.DEFAULT_IGNORED_LIBRARIES,
+            internalPrefixes: exports.DEFAULT_INTERNAL_PREFIXES,
             allowImportType: true,
         },
     ],
     create(context, [options]) {
-        const { ignoredLibraries = exports.DEFAULT_IGNORED_LIBRARIES, allowImportType = true, } = options;
-        const exactIgnored = new Set();
-        const globIgnored = [];
-        for (const lib of ignoredLibraries) {
-            const mm = new minimatch_1.Minimatch(lib);
-            if (mm.hasMagic()) {
-                globIgnored.push(mm);
-            }
-            else {
-                exactIgnored.add(lib);
+        const { libraries, ignoredLibraries = exports.DEFAULT_IGNORED_LIBRARIES, internalPrefixes = exports.DEFAULT_INTERNAL_PREFIXES, allowImportType = true, } = options;
+        // When `libraries` is provided, the rule operates in whitelist mode:
+        // only the explicitly listed libraries are enforced. This preserves
+        // backwards-compatibility with pre-1.16.0 consumer configurations.
+        // When `libraries` is absent, enforce-by-default mode applies:
+        // all external imports are flagged unless in `ignoredLibraries`.
+        const isWhitelistMode = libraries !== undefined;
+        // Build an O(1) + glob matcher from a list of library patterns.
+        const buildMatcher = (list) => {
+            const exactSet = new Set();
+            const globs = [];
+            for (const lib of list) {
+                const mm = new minimatch_1.Minimatch(lib);
+                if (mm.hasMagic()) {
+                    globs.push(mm);
+                }
+                else {
+                    exactSet.add(lib);
+                }
             }
-        }
-        const isIgnored = (source) => {
-            return (exactIgnored.has(source) ||
-                globIgnored.some((mm) => mm.match(source)));
+            return (source) => exactSet.has(source) || globs.some((mm) => mm.match(source));
         };
+        // In whitelist mode, `libraries` is defined (checked above). In
+        // enforce-by-default mode, `ignoredLibraries` is used instead.
+        const isListedInWhitelist = buildMatcher(libraries ?? []);
+        const isIgnoredLibrary = buildMatcher(ignoredLibraries);
+        // A source is external only if it looks like an npm package specifier AND
+        // is not a known-internal path. Node builtins and configured internal
+        // prefixes (e.g. src/, functions/) are excluded to avoid false positives
+        // on TypeScript baseUrl imports and Node core modules.
         const isExternal = (source) => {
-            // Treat npm-style specifiers (including numeric names like '3d-force-graph') as external; internal paths are excluded.
-            return /^[a-z0-9@]/i.test(source) && !source.startsWith('@/');
+            return (/^[a-z0-9@]/i.test(source) &&
+                !source.startsWith('@/') &&
+                !isNodeBuiltin(source) &&
+                !internalPrefixes.some((prefix) => source.startsWith(prefix)));
         };
         return {
             ImportDeclaration(node) {
@@ -88,8 +126,20 @@ exports.default = (0, createRule_1.createRule)({
                         return;
                     }
                 }
-                // Only enforce for external libraries that are NOT ignored
-                if (isExternal(importSource) && !isIgnored(importSource)) {
+                let shouldReport;
+                if (isWhitelistMode) {
+                    // Whitelist mode: report only if the source matches an explicitly
+                    // listed library. External detection and ignoredLibraries are not
+                    // consulted, so unlisted npm packages are silently allowed.
+                    shouldReport = isListedInWhitelist(importSource);
+                }
+                else {
+                    // Enforce-by-default mode: report if the source is an external
+                    // package and is not in the ignored list.
+                    shouldReport =
+                        isExternal(importSource) && !isIgnoredLibrary(importSource);
+                }
+                if (shouldReport) {
                     context.report({
                         node,
                         messageId: 'dynamicImportRequired',

package/lib/rules/logical-top-to-bottom-grouping.js

@@ -368,6 +368,18 @@ function statementReferencesAny(statement, names) {
     }
     return false;
 }
+/**
+ * Find the index of the first statement that references any of the given names,
+ * searching forward from afterIndex.
+ */
+function findFirstUsageIndex(body, names, afterIndex) {
+    for (let cursor = afterIndex; cursor < body.length; cursor += 1) {
+        if (statementReferencesAny(body[cursor], names)) {
+            return cursor;
+        }
+    }
+    return -1;
+}
 function collectAssignedNamesFromPattern(target, names) {
     if (TYPE_EXPRESSION_WRAPPERS.has(target.type) &&
         'expression' in target) {
@@ -671,10 +683,13 @@ function findEarliestSafeIndex(body, startIndex, dependencies, { allowHooks }) {
 }
 function getStartWithComments(statement, sourceCode) {
     const comments = sourceCode.getCommentsBefore(statement);
-    if (comments.length === 0) {
-        return statement.range[0];
+    const start = comments.length === 0 ? statement.range[0] : comments[0].range[0];
+    const text = sourceCode.getText();
+    let cursor = start - 1;
+    while (cursor >= 0 && (text[cursor] === ' ' || text[cursor] === '\t')) {
+        cursor -= 1;
     }
-    return comments[0].range[0];
+    return cursor + 1;
 }
 function getNextStart(body, index, parent, sourceCode) {
     const nextStatement = body[index + 1];
@@ -907,42 +922,95 @@ function isSiblingSourceDerivation(statement, sourceNodes, sourceDeclarators) {
         return !sourceDeclarators.has(name);
     });
 }
+/**
+ * Restrict late-declaration candidates to simple variables with at most an Identifier or
+ * Literal initializer. This ensures they are pure values that do not have side effects or
+ * change execution order when moved closer to their usage. More complex initializers are
+ * excluded to maintain temporal safety.
+ */
+function isLateDeclarationCandidate(statement) {
+    if (statement.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
+        statement.declarations.length !== 1) {
+        return false;
+    }
+    const [declarator] = statement.declarations;
+    return (declarator.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+        (!declarator.init ||
+            declarator.init.type === utils_1.AST_NODE_TYPES.Identifier ||
+            declarator.init.type === utils_1.AST_NODE_TYPES.Literal));
+}
+const LOOP_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.ForStatement,
+    utils_1.AST_NODE_TYPES.ForInStatement,
+    utils_1.AST_NODE_TYPES.ForOfStatement,
+    utils_1.AST_NODE_TYPES.WhileStatement,
+    utils_1.AST_NODE_TYPES.DoWhileStatement,
+]);
+/**
+ * Treat a loop as an ordering barrier for late-declaration moves when it mutates any
+ * tracked variable inside the loop body.
+ *
+ * Variables that are declared before a loop and mutated inside it (accumulators,
+ * counters, collectors) must remain before the loop so their declaration is visible
+ * across all iterations. Moving them inside would reset them on every iteration,
+ * changing program semantics. This guard applies regardless of whether the variable
+ * is also read after the loop.
+ *
+ * Assumptions:
+ * - nameSet contains the name(s) being tracked for late declaration.
+ * - body is the array of statements in the current block.
+ * - usageIndex is the index of the first statement that references the variable(s).
+ */
+function isMutatedInLoop(body, usageIndex, nameSet) {
+    const firstUsage = body[usageIndex];
+    if (!firstUsage) {
+        return false;
+    }
+    if (!LOOP_TYPES.has(firstUsage.type)) {
+        return false;
+    }
+    return statementMutatesAny(firstUsage, nameSet);
+}
 function handleLateDeclarations(ruleContext, body, parent) {
     const { sourceCode } = ruleContext;
     body.forEach((statement, index) => {
-        if (statement.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
-            statement.declarations.length !== 1) {
+        if (!isLateDeclarationCandidate(statement)) {
             return;
         }
         const [declarator] = statement.declarations;
-        if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
-            (declarator.init &&
-                declarator.init.type !== utils_1.AST_NODE_TYPES.Identifier &&
-                declarator.init.type !== utils_1.AST_NODE_TYPES.Literal)) {
-            return;
-        }
         const name = declarator.id.name;
         const dependencies = new Set();
         if (declarator.init && declarator.init.type === utils_1.AST_NODE_TYPES.Identifier) {
             dependencies.add(declarator.init.name);
         }
         const nameSet = new Set([name]);
-        let usageIndex = -1;
-        for (let cursor = index + 1; cursor < body.length; cursor += 1) {
-            if (statementReferencesAny(body[cursor], nameSet)) {
-                usageIndex = cursor;
-                break;
-            }
-        }
+        const usageIndex = findFirstUsageIndex(body, nameSet, index + 1);
         if (usageIndex === -1 || usageIndex <= index + 1) {
             return;
         }
+        // Loop mutations create a dependency barrier: declarations that precede loops and are
+        // mutated inside them cannot be safely moved, as the declaration must be visible across
+        // all iterations. Prevent false positives for this pattern.
+        if (isMutatedInLoop(body, usageIndex, nameSet)) {
+            return;
+        }
         const intervening = body.slice(index + 1, usageIndex);
         // Only move across pure declarations that do not mention the placeholder or its initializer dependencies to avoid changing closure timing or TDZ behavior.
-        const crossesImpureOrTracked = intervening.some((stmt) => {
+        const crossesImpureOrTracked = intervening.some((stmt, i) => {
             if (!isPureDeclaration(stmt, { allowHooks: false })) {
                 return true;
             }
+            // Do not hop over another declaration that is used at the same index or earlier
+            // if it is also a candidate for being moved.
+            // This prevents circular swapping of related declarations (like resolve/reject pairs).
+            if (isLateDeclarationCandidate(stmt)) {
+                const declaredNames = getDeclaredNames(stmt);
+                const firstUsageOfIntervening = findFirstUsageIndex(body, declaredNames, index + 1 + i + 1);
+                if (firstUsageOfIntervening !== -1 &&
+                    firstUsageOfIntervening <= usageIndex) {
+                    return true;
+                }
+            }
             if (statementDeclaresAny(stmt, nameSet) ||
                 statementMutatesAny(stmt, nameSet)) {
                 return true;

package/lib/rules/no-hungarian.js

@@ -352,6 +352,17 @@ exports.noHungarian = (0, createRule_1.createRule)({
                         /[A-Z]/.test(variableName[variableName.length - normalizedMarker.length]))) {
                     return true;
                 }
+                // Abbreviation markers (str, num, int, bool, arr, obj, fn, func) are
+                // short enough that the raw-character boundary heuristic below can fire
+                // on them as substrings inside real English words (e.g. "int" inside
+                // "Mint", "str" inside "stream"). For these markers, require an exact
+                // match against a full camelCase token so that "Mint" → ["Mint"] never
+                // matches "int", while genuine Hungarian like intValue → ["int","Value"]
+                // still does.
+                if (ABBREVIATION_MARKER_SET.has(normalizedMarker)) {
+                    const segments = splitCamelSegments(variableName);
+                    return segments.some((s) => s.toLowerCase() === normalizedMarker);
+                }
                 // Check for word boundaries to avoid matching substrings
                 // For example, avoid matching "int" in "points" or "str" in "stream"
                 const markerIndex = normalizedVarName.indexOf(normalizedMarker);

package/lib/rules/require-memo.js

@@ -6,6 +6,11 @@ exports.requireMemo = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const isComponentExplicitlyUnmemoized = (componentName) => componentName.toLowerCase().includes('unmemoized');
+// React's universal convention: only PascalCase-initial identifiers are
+// treated as components. camelCase names are render-prop callbacks or plain
+// helper functions that are invoked directly (e.g. MUI's renderCell(params)),
+// NOT React components — wrapping them in memo() would break callers.
+const startsWithUppercase = (name) => /^[A-Z]/.test(name);
 function isFunction(node) {
     return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
         node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
@@ -33,18 +38,21 @@ function isHigherOrderFunctionReturningJSX(node, context) {
 const isUnmemoizedArrowFunction = (parentNode) => {
     return (parentNode.type === 'VariableDeclarator' &&
         parentNode.id.type === 'Identifier' &&
+        startsWithUppercase(parentNode.id.name) &&
         !isComponentExplicitlyUnmemoized(parentNode.id.name));
 };
 const isUnmemoizedFunctionComponent = (parentNode, node) => {
     return (node.type === 'FunctionDeclaration' &&
         parentNode.type === 'Program' &&
         node.id &&
+        startsWithUppercase(node.id.name) &&
         !isComponentExplicitlyUnmemoized(node.id.name));
 };
 const isUnmemoizedExportedFunctionComponent = (parentNode, node) => {
     return (node.type === 'FunctionDeclaration' &&
         parentNode.type === 'ExportNamedDeclaration' &&
         node.id &&
+        startsWithUppercase(node.id.name) &&
         !isComponentExplicitlyUnmemoized(node.id.name));
 };
 function isMemoImport(importPath) {

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,56 @@
 [
+  {
+    "version": "1.16.2",
+    "date": "2026-06-30T22:17:37.457Z",
+    "rules": [
+      {
+        "name": "logical-top-to-bottom-grouping",
+        "changeType": "fix",
+        "issues": [
+          1247
+        ],
+        "summary": "restore loop-mutation guard and indentation-preserving idempotent autofix (closes #1247)"
+      },
+      {
+        "name": "no-hungarian",
+        "changeType": "fix",
+        "issues": [
+          1246
+        ],
+        "summary": "only flag abbreviation markers at camelCase token boundaries (closes #1246)"
+      }
+    ]
+  },
+  {
+    "version": "1.16.1",
+    "date": "2026-06-30T15:58:17.558Z",
+    "rules": [
+      {
+        "name": "enforce-assert-safe-object-key",
+        "changeType": "fix",
+        "issues": [
+          1245
+        ],
+        "summary": "treat assertSafe-cached variables as validated (closes #1245)"
+      },
+      {
+        "name": "enforce-dynamic-imports",
+        "changeType": "fix",
+        "issues": [
+          1244
+        ],
+        "summary": "restore libraries whitelist mode and exempt builtins/internal paths (closes #1244)"
+      },
+      {
+        "name": "require-memo",
+        "changeType": "fix",
+        "issues": [
+          1243
+        ],
+        "summary": "exempt camelCase render-prop callbacks (closes #1243)"
+      }
+    ]
+  },
   {
     "version": "1.16.0",
     "date": "2026-06-29T19:34:27.787Z",

package/lib/rules/prefer-memoized-props.d.ts

@@ -1,3 +0,0 @@
-type MessageIds = 'memoizeReferenceProp' | 'avoidPrimitiveMemo';
-export declare const preferMemoizedProps: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
-export {};

package/lib/rules/prefer-memoized-props.js

@@ -1,445 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preferMemoizedProps = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const createRule_1 = require("../utils/createRule");
-const HOOK_NAMES = new Set(['useMemo', 'useCallback']);
-exports.preferMemoizedProps = (0, createRule_1.createRule)({
-    name: 'prefer-memoized-props',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Require memoizing reference props (objects, arrays, functions) inside React.memo components while avoiding unnecessary useMemo for pass-through values.',
-            recommended: 'error',
-        },
-        schema: [],
-        messages: {
-            memoizeReferenceProp: 'Prop "{{propName}}" in a React.memo component receives a {{kind}} that is recreated every render, so memoized children lose referential equality and re-render. Memoize this {{kind}} with useMemo/useCallback or hoist a stable constant so the prop reference stays stable.',
-            avoidPrimitiveMemo: 'useMemo around "{{value}}" only wraps a pass-through value. Primitives already compare by value, and wrapping existing references without creating new objects does not improve stability. Return the value directly instead of adding memoization noise.',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const sourceCode = context.getSourceCode();
-        const visitorKeys = sourceCode.visitorKeys;
-        const memoizedComponents = new WeakSet();
-        const memoScopes = [];
-        const componentStack = [];
-        const scopedFunctions = new WeakSet();
-        function pushMemoScope() {
-            memoScopes.push(new Map());
-        }
-        function popMemoScope() {
-            memoScopes.pop();
-        }
-        function currentMemoScope() {
-            return memoScopes[memoScopes.length - 1];
-        }
-        function declareFunctionBinding(name, node) {
-            const scope = currentMemoScope();
-            if (!scope)
-                return;
-            scope.set(name, node);
-        }
-        function resolveFunctionBinding(name) {
-            for (let i = memoScopes.length - 1; i >= 0; i -= 1) {
-                const binding = memoScopes[i].get(name);
-                if (binding) {
-                    return binding;
-                }
-            }
-            return undefined;
-        }
-        function hoistFunctionDeclarations(statements) {
-            const scope = currentMemoScope();
-            if (!scope)
-                return;
-            for (const statement of statements) {
-                if (statement.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
-                    statement.id?.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    scope.set(statement.id.name, statement);
-                }
-            }
-        }
-        function registerFunctionVariable(node) {
-            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier)
-                return;
-            const { init } = node;
-            if (init &&
-                (init.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-                    init.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
-                declareFunctionBinding(node.id.name, init);
-            }
-        }
-        function isReactMemoCallee(callee) {
-            if (callee.type === utils_1.AST_NODE_TYPES.Identifier && callee.name === 'memo') {
-                return true;
-            }
-            if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                !callee.computed &&
-                callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                callee.property.name === 'memo') {
-                return true;
-            }
-            return false;
-        }
-        function isHookCall(node, name) {
-            if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.callee.name === name) {
-                return true;
-            }
-            return (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                !node.callee.computed &&
-                node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.callee.property.name === name);
-        }
-        function collectMemoizedComponents(node) {
-            pushMemoScope();
-            if (node.type === utils_1.AST_NODE_TYPES.Program) {
-                hoistFunctionDeclarations(node.body);
-            }
-            function traverse(current) {
-                const isFunctionLike = 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 (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
-                    current.id?.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    declareFunctionBinding(current.id.name, current);
-                }
-                let pushedScope = false;
-                if (current.type === utils_1.AST_NODE_TYPES.BlockStatement || isFunctionLike) {
-                    pushMemoScope();
-                    pushedScope = true;
-                    if (isFunctionLike &&
-                        'id' in current &&
-                        current.id?.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        declareFunctionBinding(current.id.name, current);
-                    }
-                    if (current.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                        hoistFunctionDeclarations(current.body);
-                    }
-                    else if (isFunctionLike &&
-                        current.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
-                        hoistFunctionDeclarations(current.body.body);
-                    }
-                }
-                if (current.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
-                    registerFunctionVariable(current);
-                }
-                if (current.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                    isReactMemoCallee(current.callee)) {
-                    const [firstArg] = current.arguments;
-                    if (firstArg &&
-                        (firstArg.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                            firstArg.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
-                        memoizedComponents.add(firstArg);
-                    }
-                    else if (firstArg && firstArg.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const binding = resolveFunctionBinding(firstArg.name);
-                        if (binding) {
-                            memoizedComponents.add(binding);
-                        }
-                    }
-                }
-                const keys = visitorKeys[current.type] ?? [];
-                for (const key of keys) {
-                    const value = current[key];
-                    if (Array.isArray(value)) {
-                        for (const child of value) {
-                            if (child && typeof child === 'object') {
-                                traverse(child);
-                            }
-                        }
-                    }
-                    else if (value && typeof value === 'object') {
-                        traverse(value);
-                    }
-                }
-                if (pushedScope) {
-                    popMemoScope();
-                }
-            }
-            traverse(node);
-            popMemoScope();
-        }
-        collectMemoizedComponents(sourceCode.ast);
-        function isMemoizedComponent(node) {
-            return memoizedComponents.has(node);
-        }
-        function pushComponent(node) {
-            componentStack.push({ node, scopes: [new Map()] });
-        }
-        function popComponent(node) {
-            const top = componentStack[componentStack.length - 1];
-            if (top && top.node === node) {
-                componentStack.pop();
-            }
-        }
-        function currentComponent() {
-            return componentStack[componentStack.length - 1];
-        }
-        function currentScope() {
-            const component = currentComponent();
-            if (!component)
-                return undefined;
-            return component.scopes[component.scopes.length - 1];
-        }
-        function pushScopeForNestedFunction(node) {
-            const component = currentComponent();
-            if (!component)
-                return;
-            component.scopes.push(new Map());
-            scopedFunctions.add(node);
-        }
-        function popScopeForNestedFunction(node) {
-            const component = currentComponent();
-            if (!component)
-                return;
-            if (!scopedFunctions.has(node))
-                return;
-            component.scopes.pop();
-            scopedFunctions.delete(node);
-        }
-        function unwrapExpression(expression) {
-            let current = expression;
-            while (true) {
-                if (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
-                    current.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
-                    current.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
-                    current = current.expression;
-                    continue;
-                }
-                if (current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
-                    current = current.expression;
-                    continue;
-                }
-                break;
-            }
-            return current;
-        }
-        function getBindingKind(init) {
-            if (!init) {
-                return null;
-            }
-            const unwrapped = unwrapExpression(init);
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.CallExpression &&
-                ((unwrapped.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    HOOK_NAMES.has(unwrapped.callee.name)) ||
-                    (unwrapped.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        !unwrapped.callee.computed &&
-                        unwrapped.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        HOOK_NAMES.has(unwrapped.callee.property.name)))) {
-                return null;
-            }
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.ObjectExpression)
-                return 'object';
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.ArrayExpression)
-                return 'array';
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                unwrapped.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
-                return 'function';
-            }
-            return null;
-        }
-        function recordBinding(node) {
-            const scope = currentScope();
-            if (!scope)
-                return;
-            if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier || !node.init) {
-                return;
-            }
-            const initializer = unwrapExpression(node.init);
-            const aliasKind = initializer.type === utils_1.AST_NODE_TYPES.Identifier
-                ? findBindingKind(initializer.name)
-                : null;
-            const kind = aliasKind ?? getBindingKind(initializer);
-            if (kind)
-                scope.set(node.id.name, kind);
-        }
-        function findBindingKind(name) {
-            for (let i = componentStack.length - 1; i >= 0; i -= 1) {
-                const component = componentStack[i];
-                for (let j = component.scopes.length - 1; j >= 0; j -= 1) {
-                    const binding = component.scopes[j].get(name);
-                    if (binding)
-                        return binding;
-                }
-            }
-            return null;
-        }
-        function getAttributeName(name) {
-            if (name.type === utils_1.AST_NODE_TYPES.JSXIdentifier) {
-                return name.name;
-            }
-            if (name.type === utils_1.AST_NODE_TYPES.JSXNamespacedName) {
-                return name.name.name;
-            }
-            return 'prop';
-        }
-        function reportReference(node, propName, kind) {
-            context.report({
-                node,
-                messageId: 'memoizeReferenceProp',
-                data: { propName, kind },
-            });
-        }
-        function isEnvironmentFreeLiteral(expression) {
-            const unwrapped = unwrapExpression(expression);
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.Literal)
-                return true;
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
-                unwrapped.expressions.length === 0) {
-                return true;
-            }
-            return false;
-        }
-        function isStableReference(expression) {
-            const unwrapped = unwrapExpression(expression);
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.Literal)
-                return true;
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
-                return unwrapped.expressions.every((expr) => isStableReference(expr));
-            }
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.Identifier)
-                return true;
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.MemberExpression)
-                return true;
-            if (unwrapped.type === utils_1.AST_NODE_TYPES.ChainExpression &&
-                unwrapped.expression.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                return true;
-            }
-            return false;
-        }
-        function extractReturnExpression(callback) {
-            if (callback.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
-                return callback.body;
-            }
-            const [statement] = callback.body.body;
-            if (statement &&
-                statement.type === utils_1.AST_NODE_TYPES.ReturnStatement &&
-                statement.argument) {
-                return statement.argument;
-            }
-            return null;
-        }
-        function handleUseMemo(node) {
-            if (!currentComponent() || !isHookCall(node, 'useMemo')) {
-                return;
-            }
-            const [callback, deps] = node.arguments;
-            if (!callback ||
-                (callback.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
-                    callback.type !== utils_1.AST_NODE_TYPES.FunctionExpression)) {
-                return;
-            }
-            const returnExpression = extractReturnExpression(callback);
-            if (!returnExpression)
-                return;
-            const dependencies = deps && deps.type === utils_1.AST_NODE_TYPES.ArrayExpression ? deps : null;
-            if (dependencies &&
-                dependencies.elements.length === 0 &&
-                !isEnvironmentFreeLiteral(returnExpression)) {
-                return;
-            }
-            if (isStableReference(returnExpression)) {
-                const valueText = sourceCode.getText(returnExpression).slice(0, 80);
-                context.report({
-                    node,
-                    messageId: 'avoidPrimitiveMemo',
-                    data: { value: valueText },
-                });
-            }
-        }
-        function handleJSXAttribute(node) {
-            if (!currentComponent())
-                return;
-            if (!node.value ||
-                node.value.type !== utils_1.AST_NODE_TYPES.JSXExpressionContainer) {
-                return;
-            }
-            const rawExpression = node.value.expression;
-            if (rawExpression.type === utils_1.AST_NODE_TYPES.JSXEmptyExpression) {
-                return;
-            }
-            const expression = unwrapExpression(rawExpression);
-            const propName = getAttributeName(node.name);
-            if (expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                reportReference(expression, propName, 'object');
-                return;
-            }
-            if (expression.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
-                reportReference(expression, propName, 'array');
-                return;
-            }
-            if (expression.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-                expression.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
-                reportReference(expression, propName, 'function');
-                return;
-            }
-            if (expression.type === utils_1.AST_NODE_TYPES.Identifier) {
-                const bindingKind = findBindingKind(expression.name);
-                if (bindingKind) {
-                    reportReference(expression, propName, bindingKind);
-                }
-            }
-        }
-        return {
-            FunctionDeclaration(node) {
-                if (isMemoizedComponent(node)) {
-                    pushComponent(node);
-                    return;
-                }
-                const scope = currentScope();
-                if (scope && node.id?.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    scope.set(node.id.name, 'function');
-                }
-                if (currentComponent()) {
-                    pushScopeForNestedFunction(node);
-                }
-            },
-            'FunctionDeclaration:exit'(node) {
-                if (isMemoizedComponent(node)) {
-                    popComponent(node);
-                    return;
-                }
-                popScopeForNestedFunction(node);
-            },
-            FunctionExpression(node) {
-                if (isMemoizedComponent(node)) {
-                    pushComponent(node);
-                    return;
-                }
-                if (currentComponent()) {
-                    pushScopeForNestedFunction(node);
-                }
-            },
-            'FunctionExpression:exit'(node) {
-                if (isMemoizedComponent(node)) {
-                    popComponent(node);
-                    return;
-                }
-                popScopeForNestedFunction(node);
-            },
-            ArrowFunctionExpression(node) {
-                if (isMemoizedComponent(node)) {
-                    pushComponent(node);
-                    return;
-                }
-                if (currentComponent()) {
-                    pushScopeForNestedFunction(node);
-                }
-            },
-            'ArrowFunctionExpression:exit'(node) {
-                if (isMemoizedComponent(node)) {
-                    popComponent(node);
-                    return;
-                }
-                popScopeForNestedFunction(node);
-            },
-            VariableDeclarator: recordBinding,
-            CallExpression: handleUseMemo,
-            JSXAttribute: handleJSXAttribute,
-        };
-    },
-});
-//# sourceMappingURL=prefer-memoized-props.js.map

package/lib/rules/prefer-nullish-coalescing-override.d.ts

@@ -1,7 +0,0 @@
-import { TSESLint } from '@typescript-eslint/utils';
-/**
- * This rule overrides the behavior of @typescript-eslint/prefer-nullish-coalescing
- * to only suggest using the nullish coalescing operator when checking for null/undefined,
- * not when intentionally checking for all falsy values.
- */
-export declare const preferNullishCoalescingOverride: TSESLint.RuleModule<"preferNullishCoalescing", [], TSESLint.RuleListener>;

package/lib/rules/prefer-nullish-coalescing-override.js

@@ -1,188 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preferNullishCoalescingOverride = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const createRule_1 = require("../utils/createRule");
-/**
- * This rule overrides the behavior of @typescript-eslint/prefer-nullish-coalescing
- * to only suggest using the nullish coalescing operator when checking for null/undefined,
- * not when intentionally checking for all falsy values.
- */
-exports.preferNullishCoalescingOverride = (0, createRule_1.createRule)({
-    name: 'prefer-nullish-coalescing-override',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Enforce using nullish coalescing operator instead of logical OR operator, but only when appropriate',
-            recommended: 'warn',
-        },
-        fixable: 'code',
-        schema: [],
-        messages: {
-            preferNullishCoalescing: 'Replace "{{left}} || {{right}}" with nullish coalescing when you only want a fallback for null or undefined. The logical OR operator treats "", 0, and false as missing values and silently swaps in the fallback, which hides valid data. Use "{{left}} ?? {{right}}" so only nullish inputs trigger the fallback.',
-        },
-    },
-    defaultOptions: [],
-    create(context) {
-        const contextWithSource = context;
-        const sourceCode = contextWithSource.sourceCode ?? contextWithSource.getSourceCode();
-        /**
-         * Checks if a node is in a boolean context where truthiness matters
-         */
-        function isInBooleanContext(node) {
-            const parent = node.parent;
-            if (!parent)
-                return false;
-            switch (parent.type) {
-                // Direct boolean contexts
-                case utils_1.AST_NODE_TYPES.IfStatement:
-                case utils_1.AST_NODE_TYPES.WhileStatement:
-                case utils_1.AST_NODE_TYPES.DoWhileStatement:
-                case utils_1.AST_NODE_TYPES.ForStatement:
-                    return parent.test === node;
-                case utils_1.AST_NODE_TYPES.ConditionalExpression:
-                    return parent.test === node;
-                // Logical expressions (&&, ||, !)
-                case utils_1.AST_NODE_TYPES.LogicalExpression:
-                    return true;
-                case utils_1.AST_NODE_TYPES.UnaryExpression:
-                    return parent.operator === '!';
-                // JSX expressions that expect boolean values
-                case utils_1.AST_NODE_TYPES.JSXExpressionContainer:
-                    return isJSXBooleanContext(parent);
-                default:
-                    return false;
-            }
-        }
-        /**
-         * Checks if a JSX expression container is in a boolean context
-         */
-        function isJSXBooleanContext(jsxContainer) {
-            const parent = jsxContainer.parent;
-            if (!parent)
-                return false;
-            // Check if used as a child expression (conditional rendering or child selection).
-            // Other guards (rightOperandSuggestsFalsyHandling, etc.) will prevent unsafe conversions.
-            if (parent.type === utils_1.AST_NODE_TYPES.JSXElement ||
-                parent.type === utils_1.AST_NODE_TYPES.JSXFragment) {
-                return true;
-            }
-            return false;
-        }
-        /**
-         * Checks if the right operand suggests we want to handle all falsy values
-         */
-        function rightOperandSuggestsFalsyHandling(right) {
-            // String literals suggest we want to handle empty strings too
-            if (right.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof right.value === 'string') {
-                return true;
-            }
-            // Number literals (especially 0) suggest we want to handle falsy numbers
-            if (right.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof right.value === 'number') {
-                return true;
-            }
-            // Boolean literals suggest boolean logic
-            if (right.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof right.value === 'boolean') {
-                return true;
-            }
-            return false;
-        }
-        /**
-         * Checks if the left operand is likely to be used for boolean logic
-         */
-        function leftOperandSuggestsBooleanLogic(left) {
-            // Variables with boolean-like names
-            if (left.type === utils_1.AST_NODE_TYPES.Identifier) {
-                const name = left.name.toLowerCase();
-                const booleanPrefixes = [
-                    'is',
-                    'has',
-                    'can',
-                    'should',
-                    'will',
-                    'was',
-                    'were',
-                    'are',
-                ];
-                const booleanSuffixes = [
-                    'enabled',
-                    'disabled',
-                    'active',
-                    'inactive',
-                    'valid',
-                    'invalid',
-                ];
-                return (booleanPrefixes.some((prefix) => name.startsWith(prefix)) ||
-                    booleanSuffixes.some((suffix) => name.endsWith(suffix)));
-            }
-            // Binary expressions that result in booleans
-            if (left.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
-                const comparisonOperators = [
-                    '===',
-                    '!==',
-                    '==',
-                    '!=',
-                    '<',
-                    '>',
-                    '<=',
-                    '>=',
-                ];
-                return comparisonOperators.includes(left.operator);
-            }
-            return false;
-        }
-        /**
-         * Checks if this is a variable assignment context where falsy handling is expected
-         */
-        function isVariableAssignmentWithFalsyHandling(node) {
-            const parent = node.parent;
-            if (!parent)
-                return false;
-            // Variable declarations like: const name = username || 'Anonymous'
-            if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                parent.init === node) {
-                return rightOperandSuggestsFalsyHandling(node.right);
-            }
-            // Assignment expressions like: this.name = username || 'Anonymous'
-            if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
-                parent.right === node) {
-                return rightOperandSuggestsFalsyHandling(node.right);
-            }
-            return false;
-        }
-        /**
-         * Checks if this logical OR should be converted to nullish coalescing
-         */
-        function shouldConvertToNullishCoalescing(node) {
-            void node;
-            return false;
-        }
-        void isInBooleanContext;
-        void leftOperandSuggestsBooleanLogic;
-        void rightOperandSuggestsFalsyHandling;
-        void isVariableAssignmentWithFalsyHandling;
-        return {
-            LogicalExpression(node) {
-                if (shouldConvertToNullishCoalescing(node)) {
-                    const leftText = sourceCode.getText(node.left);
-                    const rightText = sourceCode.getText(node.right);
-                    context.report({
-                        node,
-                        messageId: 'preferNullishCoalescing',
-                        data: {
-                            left: leftText,
-                            right: rightText,
-                        },
-                        fix(fixer) {
-                            return fixer.replaceText(node, `${leftText} ?? ${rightText}`);
-                        },
-                    });
-                }
-            },
-        };
-    },
-});
-//# sourceMappingURL=prefer-nullish-coalescing-override.js.map

package/lib/rules/require-usememo-object-literals.d.ts

@@ -1,4 +0,0 @@
-import { TSESTree } from '@typescript-eslint/utils';
-export declare const requireUseMemoObjectLiterals: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireUseMemo", never[], {
-    JSXAttribute(node: TSESTree.JSXAttribute): void;
-}>;

package/lib/rules/require-usememo-object-literals.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireUseMemoObjectLiterals = void 0;
-const createRule_1 = require("../utils/createRule");
-const ASTHelpers_1 = require("../utils/ASTHelpers");
-exports.requireUseMemoObjectLiterals = (0, createRule_1.createRule)({
-    name: 'require-usememo-object-literals',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: "Enforce using useMemo for inline object/array literals passed as props to JSX components to prevent unnecessary re-renders. When object/array literals are defined inline in JSX, they create new references on every render, causing child components to re-render even if the values haven't changed. Wrap them in useMemo to maintain referential equality.",
-            recommended: 'error',
-        },
-        messages: {
-            requireUseMemo: 'Inline {{literalType}} literal passed to {{componentName}} prop "{{propName}}" is recreated on every render, producing a new reference that forces child components to re-render even when values stay the same. Wrap the literal in useMemo (or hoist a memoized constant) so the prop reference remains stable between renders.',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        return {
-            JSXAttribute(node) {
-                // Skip if the value is not an expression
-                if (!node.value || node.value.type !== 'JSXExpressionContainer') {
-                    return;
-                }
-                // Skip if the prop name is 'sx' or ends with 'Sx'
-                const propName = node.name.name;
-                if (typeof propName === 'string' &&
-                    (propName === 'sx' || propName.endsWith('Sx'))) {
-                    return;
-                }
-                const { expression } = node.value;
-                // Check if the expression is an object or array literal
-                if ((expression.type === 'ObjectExpression' ||
-                    expression.type === 'ArrayExpression') &&
-                    // Ensure we're in a function component context
-                    ASTHelpers_1.ASTHelpers.getAncestors(context, node).some((ancestor) => ancestor.type === 'FunctionDeclaration' ||
-                        ancestor.type === 'ArrowFunctionExpression' ||
-                        ancestor.type === 'FunctionExpression')) {
-                    // Check if the parent component name starts with an uppercase letter
-                    // to ensure it's a React component
-                    const jsxElement = node.parent;
-                    const elementName = jsxElement.name.type === 'JSXIdentifier'
-                        ? jsxElement.name.name
-                        : '';
-                    if (elementName && /^[A-Z]/.test(elementName)) {
-                        const literalType = expression.type === 'ObjectExpression' ? 'object' : 'array';
-                        context.report({
-                            node: expression,
-                            messageId: 'requireUseMemo',
-                            data: {
-                                literalType,
-                                propName: typeof propName === 'string' ? propName : 'prop',
-                                componentName: elementName,
-                            },
-                        });
-                    }
-                }
-            },
-        };
-    },
-});
-//# sourceMappingURL=require-usememo-object-literals.js.map