@blumintinc/eslint-plugin-blumint 1.20.17 → 1.20.19

package/lib/index.js

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

package/lib/rules/parallelize-async-operations.js

@@ -191,6 +191,40 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
          * name (getRefreshToken must NOT match).
          */
         const REFETCH_PATTERN = /^(refresh|reload|refetch|revalidate|resync|sync)/i;
+        /**
+         * Matches navigation callees by their leading verb. A route transition is an
+         * ordering barrier rather than a data dependency: the awaits around it are
+         * sequenced so their side effects land on the intended page. `await
+         * push(url)` followed by `await acceptInvite(...)` is written that way so the
+         * accept flow's dialogs mount on the destination page; Promise.all starts the
+         * accept flow concurrently with the route transition, so its dialogs open on
+         * the source page and are unmounted mid-navigation. The reverse order is
+         * equally load-bearing -- parallelizing `await save()` with a following
+         * `await push(url)` can navigate away before the save settles -- so a
+         * navigation anywhere in the run blocks the whole run. Anchored at the start
+         * so it fires on the callee's own verb (pushRoute, navigateTo,
+         * redirectToLogin) rather than on an arbitrary substring elsewhere in the
+         * name.
+         */
+        const NAVIGATION_PATTERN = /^(push|replace|navigate|redirect|reroute|goto)/i;
+        /**
+         * Matches router-like receivers so that every method invoked on one counts
+         * as navigation (`router.back()`, `history.go(-1)`, `navigation.reset()`).
+         * Keyed on the receiver rather than the method because the remaining history
+         * verbs (back, forward, go) are far too generic to match on their own.
+         */
+        const NAVIGATION_RECEIVER_PATTERN = /^(router|history|navigation|nav)$/i;
+        /**
+         * Checks whether an awaited call performs a route transition.
+         */
+        function isNavigationCall(awaitExpr) {
+            const receiverName = getCalleeReceiverName(awaitExpr);
+            if (receiverName && NAVIGATION_RECEIVER_PATTERN.test(receiverName)) {
+                return true;
+            }
+            const methodName = getCalleeMethodName(awaitExpr);
+            return !!methodName && NAVIGATION_PATTERN.test(methodName);
+        }
         /**
          * Extracts the callee's method name (the identifier bearing the leading
          * verb) from an await expression argument. Handles both direct
@@ -364,6 +398,22 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                     return true;
                 }
             }
+            // 6. Navigation ordering barrier. An awaited route transition sequences
+            // the awaits around it by UI lifetime rather than by data: the operations
+            // before it must settle on the source page, and the operations after it
+            // must mount on the destination page. Promise.all runs every operand
+            // concurrently, which races both of those against the route change --
+            // dialogs opened by a following await appear on the source page and are
+            // destroyed when the transition lands. Unlike the guard and refetch
+            // barriers, position does not matter: a navigation is a barrier whether it
+            // leads or trails the run. Captured results qualify too, since the hazard
+            // is the transition itself, not the value it returns.
+            for (const node of awaitNodes) {
+                const awaitExpr = getAwaitExpression(node);
+                if (awaitExpr && isNavigationCall(awaitExpr)) {
+                    return true;
+                }
+            }
             // If any node is a variable declaration with destructuring, consider it as having dependencies
             for (const node of awaitNodes) {
                 if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
@@ -374,7 +424,7 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                     }
                 }
             }
-            // 6. Shared-receiver ordering barrier. Two awaited calls whose callees are
+            // 7. Shared-receiver ordering barrier. Two awaited calls whose callees are
             // member expressions on the SAME receiver identifier (e.g. `ref.set(x)`
             // then `ref.get()`) can carry a read-after-write / write-after-write
             // dependency: the later call may observe or overwrite state the earlier

package/lib/rules/prefer-clone-deep.js

@@ -1,11 +1,51 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferCloneDeep = void 0;
+const path_1 = __importDefault(require("path"));
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const CLONE_DEEP_NAME = 'cloneDeep';
 const CLONE_DEEP_MODULE = 'functions/src/util/cloneDeep';
+const CLONE_DEEP_TARGET = 'src/util/cloneDeep';
+const FUNCTIONS_TIER_SEGMENT = '/functions/src/';
+const FUNCTIONS_ROOT_SEGMENT = '/functions/';
 const INDENT_STEP = '  ';
+const toPosixPath = (filePath) => filePath.replace(/\\/g, '/');
+const ensureRelativeSpecifier = (specifier) => specifier.startsWith('.') ? specifier : `./${specifier}`;
+const isWindowsDrivePath = (filePath) => /^[A-Za-z]:[\\/]/.test(filePath);
+const isValidRelativePath = (relativePath) => relativePath !== '' &&
+    !path_1.default.isAbsolute(relativePath) &&
+    !isWindowsDrivePath(relativePath);
+/**
+ * The helper lives in one place but the two TypeScript tiers reach it
+ * differently: the root tsconfig maps `functions/*` through `paths`, so files
+ * outside `functions/` resolve the bare specifier, while `functions/tsconfig.json`
+ * is rooted at `functions/` and declares no `paths`, leaving backend files able
+ * to reach a sibling util only by relative path. A single hardcoded specifier
+ * therefore emits an unresolvable import for every backend fix (#1389).
+ *
+ * Returns null when no correct specifier exists, which makes the caller decline
+ * the fix rather than write an import that cannot resolve.
+ */
+function buildCloneDeepSpecifier(sourceFilePath, cwd) {
+    const absoluteFilename = toPosixPath(path_1.default.isAbsolute(sourceFilePath)
+        ? sourceFilePath
+        : path_1.default.join(cwd, sourceFilePath));
+    const tierIndex = absoluteFilename.indexOf(FUNCTIONS_TIER_SEGMENT);
+    if (tierIndex === -1) {
+        return CLONE_DEEP_MODULE;
+    }
+    const functionsRoot = absoluteFilename.slice(0, tierIndex + FUNCTIONS_ROOT_SEGMENT.length);
+    const targetPath = path_1.default.join(functionsRoot, CLONE_DEEP_TARGET);
+    const relativePath = path_1.default.relative(path_1.default.dirname(absoluteFilename), targetPath);
+    if (!isValidRelativePath(relativePath)) {
+        return null;
+    }
+    return ensureRelativeSpecifier(toPosixPath(relativePath));
+}
 /**
  * Only BluMint's own `cloneDeep` accepts an overrides argument, so an existing
  * binding coming from anywhere else (notably `lodash`) must not be reused by the
@@ -44,6 +84,8 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
         // Track processed nodes to avoid duplicate reports
         const processedNodes = new Set();
         const sourceCode = context.sourceCode;
+        const cwd = typeof context.getCwd === 'function' ? context.getCwd() : process.cwd();
+        const cloneDeepSpecifier = buildCloneDeepSpecifier(context.getFilename(), cwd);
         function normalizedTextOf(node) {
             return sourceCode.getText(node).replace(/\s+/g, '');
         }
@@ -324,7 +366,8 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
         /**
          * Returns the fixes required for `cloneDeep` to resolve, an empty list when
          * it already does, or null when a conflicting binding of that name exists —
-         * shadowing it would silently call something else.
+         * shadowing it would silently call something else — or when no import
+         * specifier that resolves from this file can be derived.
          */
         function buildImportFixes(fixer, scope) {
             const existing = utils_1.ASTUtils.findVariable(scope, CLONE_DEEP_NAME);
@@ -360,7 +403,12 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                 const lastSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
                 return [fixer.insertTextAfter(lastSpecifier, `, ${CLONE_DEEP_NAME}`)];
             }
-            const importText = `import { ${CLONE_DEEP_NAME} } from '${CLONE_DEEP_MODULE}';\n`;
+            // Reusing an existing import needs no specifier of its own, so only a
+            // freshly written import depends on one being derivable.
+            if (cloneDeepSpecifier === null) {
+                return null;
+            }
+            const importText = `import { ${CLONE_DEEP_NAME} } from '${cloneDeepSpecifier}';\n`;
             const [firstImport] = importDeclarations;
             if (firstImport) {
                 return [fixer.insertTextBefore(firstImport, importText)];

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.19",
+    "date": "2026-07-29T18:36:35.802Z",
+    "rules": [
+      {
+        "name": "prefer-clone-deep",
+        "changeType": "fix",
+        "issues": [
+          1389
+        ],
+        "summary": "derive autofix import specifier from file tier (closes #1389)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.18",
+    "date": "2026-07-29T17:40:51.418Z",
+    "rules": [
+      {
+        "name": "parallelize-async-operations",
+        "changeType": "fix",
+        "issues": [
+          1388
+        ],
+        "summary": "treat route transitions as an ordering barrier (closes #1388)"
+      }
+    ]
+  },
   {
     "version": "1.20.17",
     "date": "2026-07-29T10:47:56.581Z",