@blumintinc/eslint-plugin-blumint 1.21.17 → 1.21.18

package/lib/index.js

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

package/lib/rules/enforce-empty-object-check.d.ts

@@ -1,9 +1,23 @@
 import { TSESLint } from '@typescript-eslint/utils';
+/**
+ * The emptiness call the fixer emits, and where its binding comes from.
+ *
+ * Recognition and EMISSION are separate settings on purpose. `emptyCheckFunctions`
+ * is an allowlist of spellings the rule accepts and carries no import path, so
+ * reusing it to emit would write a bare call to an identifier the file does not
+ * import, and — since it defaults to `isEmpty` — would silently change what every
+ * existing consumer's `--fix` produces (#2360).
+ */
+type EmptyCheckFix = {
+    name: string;
+    importPath?: string;
+};
 type Options = [
     {
         objectNamePattern?: string[];
         ignoreInLoops?: boolean;
         emptyCheckFunctions?: string[];
+        emptyCheckFix?: EmptyCheckFix;
         printWidth?: number;
     }
 ];

package/lib/rules/enforce-empty-object-check.js

@@ -28,6 +28,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const ts = __importStar(require("typescript"));
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const importInsertion_1 = require("../utils/importInsertion");
 const DEFAULT_OBJECT_SUFFIXES = [
     'Config',
     'Configs',
@@ -79,6 +80,20 @@ const NON_OBJECT_LIKE_NAMES = [
     'array',
     'arr',
 ];
+/**
+ * The emptiness operand the fixer writes beside the falsiness check.
+ *
+ * `Object.keys(...).length === 0` needs nothing in scope, so it stays the
+ * default and every consumer that has not opted in keeps byte-identical output.
+ * A consumer whose config BANS the `Object` accessors names a helper instead,
+ * without which `--fix` has no fixed point: the rewrite it just wrote is
+ * rejected by the same run that produced it (#2360).
+ */
+function buildEmptyCheckText(identifierText, emptyCheckFix) {
+    return emptyCheckFix
+        ? `${emptyCheckFix.name}(${identifierText})`
+        : `Object.keys(${identifierText}).length === 0`;
+}
 function hasBooleanPrefixBoundary(name) {
     const lower = name.toLowerCase();
     return BOOLEAN_PREFIXES.some((prefix) => {
@@ -1163,7 +1178,7 @@ function getDeclarationStatement(declaration) {
  * width was measured (#2095).
  */
 function planWidenedFix(input) {
-    const { sourceCode, target, identifierText, needsParentheses } = input;
+    const { sourceCode, target, identifierText, emptyCheckText, needsParentheses, } = input;
     const source = sourceCode.getText();
     const root = getLayoutRoot(target);
     const parent = root.parent;
@@ -1175,7 +1190,7 @@ function planWidenedFix(input) {
         operator: '||',
         parts: [
             { kind: 'leaf', text: `${target.operator}${identifierText}` },
-            { kind: 'leaf', text: `Object.keys(${identifierText}).length === 0` },
+            { kind: 'leaf', text: emptyCheckText },
         ],
     };
     const docContext = {
@@ -1514,6 +1529,150 @@ function planReturnFix(root, parent, flat, doc, { sourceCode, printWidth }, sour
     }
     return { range: [root.range[0], root.range[1]], text: lines.join('\n') };
 }
+/** Every name a binding pattern introduces. */
+function collectPatternNames(pattern, names) {
+    switch (pattern.type) {
+        case utils_1.AST_NODE_TYPES.Identifier:
+            names.add(pattern.name);
+            return;
+        case utils_1.AST_NODE_TYPES.ObjectPattern:
+            for (const property of pattern.properties) {
+                collectPatternNames(property.type === utils_1.AST_NODE_TYPES.RestElement
+                    ? property.argument
+                    : property.value, names);
+            }
+            return;
+        case utils_1.AST_NODE_TYPES.ArrayPattern:
+            for (const element of pattern.elements) {
+                if (element) {
+                    collectPatternNames(element, names);
+                }
+            }
+            return;
+        case utils_1.AST_NODE_TYPES.AssignmentPattern:
+            collectPatternNames(pattern.left, names);
+            return;
+        case utils_1.AST_NODE_TYPES.RestElement:
+            collectPatternNames(pattern.argument, names);
+            return;
+        default:
+    }
+}
+/**
+ * The names already declared at the module's top level.
+ *
+ * An import is only safe to insert when the name is free: a second binding of a
+ * name the file already declares — imported from anywhere, or declared locally —
+ * is a redeclaration error, which is a worse outcome than the lint warning the
+ * insertion was meant to avoid.
+ */
+function moduleBindingNames(program) {
+    const names = new Set();
+    for (const statement of program.body) {
+        const node = statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
+            statement.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration
+            ? statement.declaration
+            : statement;
+        if (!node) {
+            continue;
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.ImportDeclaration) {
+            for (const specifier of node.specifiers) {
+                names.add(specifier.local.name);
+            }
+            continue;
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+            for (const declarator of node.declarations) {
+                collectPatternNames(declarator.id, names);
+            }
+            continue;
+        }
+        if ((node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+            node.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+            node.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration ||
+            node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
+            node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+            node.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration ||
+            node.type === utils_1.AST_NODE_TYPES.TSDeclareFunction ||
+            node.type === utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration) &&
+            node.id?.type === utils_1.AST_NODE_TYPES.Identifier) {
+            names.add(node.id.name);
+        }
+    }
+    return names;
+}
+/** A module specifier written as source text, with its quotes escaped. */
+function quoteModuleSpecifier(importPath) {
+    return `'${importPath.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+/**
+ * The edit that brings the emitted helper into scope, or null when nothing is
+ * needed.
+ *
+ * A helper call the file cannot resolve trades a lint warning for an undefined
+ * identifier, so emission and import travel together in ONE fixer. Four
+ * outcomes are distinguished, because they are four different mistakes:
+ *
+ * * the name is already bound — insert nothing, whatever path it came from,
+ *   since a second binding would not compile;
+ * * a value import from the same path already has a named-specifier list — join
+ *   it, so the file keeps one declaration per module;
+ * * a file with imports gains a declaration after the LAST of them, which is
+ *   past every prologue by construction;
+ * * a file with none defers to `importInsertion`, whose anchor owns the
+ *   placement a raw offset gets wrong: a `'use client'` demoted out of the
+ *   prologue, a `#!` pushed off line 1, or a line-binding suppression comment
+ *   severed from the line it covers.
+ */
+function planImportInsertion(sourceCode, emptyCheckFix) {
+    const { name, importPath } = emptyCheckFix;
+    if (!importPath) {
+        return null;
+    }
+    const program = sourceCode.ast;
+    if (moduleBindingNames(program).has(name)) {
+        return null;
+    }
+    const imports = program.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+    for (const declaration of imports) {
+        /** A type-only import carries no value binding for the call to resolve. */
+        if (declaration.importKind === 'type' ||
+            declaration.source.value !== importPath) {
+            continue;
+        }
+        const specifiers = declaration.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
+        const last = specifiers[specifiers.length - 1];
+        if (!last) {
+            continue;
+        }
+        /**
+         * A specifier list Prettier has already broken keeps one name per row, so
+         * joining it inline would emit a layout the next format run undoes.
+         */
+        const indent = declaration.loc.start.line === declaration.loc.end.line
+            ? null
+            : getLineIndent(last, sourceCode);
+        const text = indent === null ? `, ${name}` : `,\n${indent}${name}`;
+        return {
+            offset: last.range[1],
+            apply: (fixer) => fixer.insertTextAfter(last, text),
+        };
+    }
+    const statement = `import { ${name} } from ${quoteModuleSpecifier(importPath)};`;
+    const lastImport = imports[imports.length - 1];
+    if (lastImport) {
+        return {
+            offset: lastImport.range[1],
+            apply: (fixer) => fixer.insertTextAfter(lastImport, `\n${statement}`),
+        };
+    }
+    const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
+    return {
+        offset: anchor.kind === 'before' ? anchor.target.range[0] : anchor.index,
+        apply: (fixer) => (0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, anchor, `${statement}\n`),
+    };
+}
 exports.enforceEmptyObjectCheck = (0, createRule_1.createRule)({
     name: 'enforce-empty-object-check',
     meta: {
@@ -1538,6 +1697,20 @@ exports.enforceEmptyObjectCheck = (0, createRule_1.createRule)({
                         type: 'array',
                         items: { type: 'string' },
                     },
+                    emptyCheckFix: {
+                        type: 'object',
+                        properties: {
+                            /**
+                             * A bare identifier, so the emitted call is the shape the
+                             * recognition arm accepts — anything else would leave `--fix`
+                             * rewriting text it reports again on the next pass.
+                             */
+                            name: { type: 'string', pattern: '^[A-Za-z_$][A-Za-z0-9_$]*$' },
+                            importPath: { type: 'string', minLength: 1 },
+                        },
+                        required: ['name'],
+                        additionalProperties: false,
+                    },
                     printWidth: {
                         type: 'number',
                         minimum: 1,
@@ -1556,7 +1729,7 @@ exports.enforceEmptyObjectCheck = (0, createRule_1.createRule)({
         const parserServices = sourceCode.parserServices;
         const checker = parserServices?.program?.getTypeChecker();
         const options = context.options[0] ?? {};
-        const { objectNamePattern = [], ignoreInLoops = false, emptyCheckFunctions = [], } = options;
+        const { objectNamePattern = [], ignoreInLoops = false, emptyCheckFunctions = [], emptyCheckFix, } = options;
         const printWidth = typeof options.printWidth === 'number' && options.printWidth > 0
             ? options.printWidth
             : DEFAULT_PRINT_WIDTH;
@@ -1564,9 +1737,16 @@ exports.enforceEmptyObjectCheck = (0, createRule_1.createRule)({
             ...DEFAULT_OBJECT_SUFFIXES,
             ...objectNamePattern,
         ]);
+        /**
+         * The emitted helper counts as a satisfying check even when it is absent
+         * from `emptyCheckFunctions`. Without this the fixer would report its own
+         * output, so `--fix` would rewrite the same guard on every pass — the
+         * fixed point this option exists to restore (#2360).
+         */
         const emptyCheckFunctionsSet = new Set([
             ...DEFAULT_EMPTY_CHECK_FUNCTIONS,
             ...emptyCheckFunctions,
+            ...(emptyCheckFix ? [emptyCheckFix.name] : []),
         ]);
         const processedExpressions = new WeakSet();
         const processedNegations = new WeakSet();
@@ -1883,6 +2063,31 @@ exports.enforceEmptyObjectCheck = (0, createRule_1.createRule)({
             }
             return isObjectLikeName(identifier.name, patternSet);
         }
+        /**
+         * Whether a binding between the report site and the module scope would
+         * capture the emitted helper call.
+         *
+         * A bare call resolves wherever the CALL sits, so an inner binding of the
+         * same name silently takes it over — the rewrite compiles, reads
+         * correctly, and calls something else entirely (#1455, #1456 are this
+         * shape). No spelling of the call escapes that, so the fix is declined
+         * and the report stands on its own; the message already says what to
+         * write.
+         *
+         * The unconfigured emission is untouched by this: `Object` is a global
+         * rather than a module binding, and its output is a compatibility
+         * contract (#2360).
+         */
+        function emissionIsShadowed(node, name) {
+            let scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
+            while (scope) {
+                if (scope.variables.some((variable) => variable.name === name)) {
+                    return scope.type !== 'module' && scope.type !== 'global';
+                }
+                scope = scope.upper;
+            }
+            return false;
+        }
         function reportNegation(node, identifier) {
             if (processedNegations.has(node)) {
                 return;
@@ -1906,8 +2111,12 @@ exports.enforceEmptyObjectCheck = (0, createRule_1.createRule)({
                     name: identifier.name,
                 },
                 fix(fixer) {
+                    if (emptyCheckFix && emissionIsShadowed(node, emptyCheckFix.name)) {
+                        return null;
+                    }
                     const identifierText = sourceCode.getText(identifier);
-                    const guard = `${node.operator}${identifierText} || Object.keys(${identifierText}).length === 0`;
+                    const emptyCheckText = buildEmptyCheckText(identifierText, emptyCheckFix);
+                    const guard = `${node.operator}${identifierText} || ${emptyCheckText}`;
                     const needsParentheses = replacementNeedsParentheses(node, sourceCode);
                     const replacement = needsParentheses ? `(${guard})` : guard;
                     /**
@@ -1923,13 +2132,27 @@ exports.enforceEmptyObjectCheck = (0, createRule_1.createRule)({
                         sourceCode,
                         target: node,
                         identifierText,
+                        emptyCheckText,
                         needsParentheses,
                         printWidth,
                     });
-                    if (widened) {
-                        return fixer.replaceTextRange(widened.range, widened.text);
+                    const guardEdit = widened ?? {
+                        range: node.range,
+                        text: replacement,
+                    };
+                    const importFix = emptyCheckFix
+                        ? planImportInsertion(sourceCode, emptyCheckFix)
+                        : null;
+                    if (!importFix) {
+                        return fixer.replaceTextRange(guardEdit.range, guardEdit.text);
                     }
-                    return fixer.replaceText(node, replacement);
+                    const guardFix = {
+                        offset: guardEdit.range[0],
+                        apply: (target) => target.replaceTextRange(guardEdit.range, guardEdit.text),
+                    };
+                    return [importFix, guardFix]
+                        .sort((left, right) => left.offset - right.offset)
+                        .map((edit) => edit.apply(fixer));
                 },
             });
         }

package/lib/rules/prevent-children-clobber.js

@@ -352,7 +352,17 @@ function typeNodeExcludesProperty(node, propertyName, resolveAlias, seen = new S
         if (node.typeParameters?.params) {
             const argumentsAreTheType = closedLiteralCounts &&
                 PROPERTY_PRESERVING_WRAPPERS.has(wrapperNameOf(node.typeName) ?? '');
-            return node.typeParameters.params.some((param) => typeNodeExcludesProperty(param, propertyName, resolveAlias, seen, argumentsAreTheType));
+            if (node.typeParameters.params.some((param) => typeNodeExcludesProperty(param, propertyName, resolveAlias, seen, argumentsAreTheType))) {
+                return true;
+            }
+            // Arguments that prove nothing are not proof that the referenced alias
+            // proves nothing, so a reference carrying them still falls through to its
+            // own body. Returning here made `type P<T> = Omit<X, 'children'>` report
+            // when referenced as `P<string>` while the byte-identical unparameterized
+            // spelling passed. Type arguments are deliberately NOT substituted into
+            // the body: an unbound parameter there proves nothing, which is the
+            // conservative answer, and an undeclared wrapper still resolves to
+            // nothing and still reports.
         }
         // Keyed by position as well as by name: the same alias proves different
         // things in a props position than inside an arbitrary generic, so a visit

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "version": "1.21.18",
+    "date": "2026-09-07T22:15:12.507Z",
+    "rules": [
+      {
+        "name": "enforce-empty-object-check",
+        "changeType": "fix",
+        "issues": [
+          2360
+        ],
+        "summary": "emit a configurable empty-check helper (closes #2360)"
+      },
+      {
+        "name": "prevent-children-clobber",
+        "changeType": "fix",
+        "issues": [
+          2361
+        ],
+        "summary": "resolve a parameterized props alias (closes #2361)"
+      }
+    ]
+  },
   {
     "version": "1.21.17",
     "date": "2026-09-07T12:35:50.668Z",