@blumintinc/eslint-plugin-blumint 1.16.1 → 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.1',
+        version: '1.16.2',
     },
     parseOptions: {
         ecmaVersion: 2020,

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/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "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",