@blumintinc/eslint-plugin-blumint 1.20.21 → 1.20.22

package/lib/index.js

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

package/lib/rules/parallelize-async-operations.d.ts

@@ -2,6 +2,7 @@ import { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         sideEffectPatterns?: Array<string | RegExp>;
+        ignoreTestFiles?: boolean;
     }
 ];
 export declare const parallelizeAsyncOperations: TSESLint.RuleModule<"parallelizeAsyncOperations", Options, TSESLint.RuleListener>;

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

@@ -3,8 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parallelizeAsyncOperations = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+// Anchored at the end of the path so multi-part suffixes such as
+// `EventRegistry.integration.test.ts` are recognized while production modules
+// that merely contain the word (`testHelpers.ts`, `latest.ts`, `contest/Thing.ts`)
+// keep their enforcement.
+const TEST_FILE_SUFFIX = /\.(test|spec)\.[cm]?[jt]sx?$/;
+// Jest convention directories hold test-only modules regardless of file name.
+const TEST_FILE_DIRECTORY = /(^|\/)(__tests__|__mocks__)\//;
+/**
+ * A test suite serves no requests and is not latency-critical, so the rule's
+ * rationale — that sequential awaits make network and I/O latency add up — does
+ * not apply to it. Its awaits instead encode ordering: `await` an interaction,
+ * then `await` an assertion that observes the DOM state the interaction
+ * produced. That dependency is a side effect rather than a value, so it is
+ * invisible to the syntactic barriers below, and Promise.all would race the
+ * assertion against the interaction (issue #1395).
+ */
+const isTestFile = (filename) => TEST_FILE_SUFFIX.test(filename) || TEST_FILE_DIRECTORY.test(filename);
 const defaultOptions = [
     {
+        ignoreTestFiles: true,
         sideEffectPatterns: [
             'updatecounter',
             'setcounter',
@@ -28,6 +46,15 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             recommended: 'error',
         },
         fixable: 'code',
+        // `defaultOptions` above is the single source of truth for defaults; the
+        // schema deliberately declares none. ESLint validates rule options with an
+        // ajv instance configured `useDefaults: true`, which writes schema defaults
+        // INTO the supplied options object before `defaultOptions` are merged. A
+        // schema `default: []` on sideEffectPatterns therefore erases the built-in
+        // side-effect patterns for any consumer who passes an options object at all
+        // -- including one that only sets `ignoreTestFiles` -- so `commit`, `flush`,
+        // and the counter patterns stop acting as ordering barriers and the rule
+        // reports the very sequences it is meant to leave alone.
         schema: [
             {
                 type: 'object',
@@ -40,7 +67,9 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                                 { type: 'object', instanceof: 'RegExp' },
                             ],
                         },
-                        default: [],
+                    },
+                    ignoreTestFiles: {
+                        type: 'boolean',
                     },
                 },
                 additionalProperties: false,
@@ -52,6 +81,14 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
     },
     defaultOptions,
     create(context, [options]) {
+        // Normalize Windows backslash separators so the forward-slash directory
+        // check matches on every platform. Without this, `getFilename()` returns
+        // `C:\repo\src\__tests__\Foo.ts` on Windows and the exemption silently
+        // fails there.
+        const filename = context.getFilename().replace(/\\/g, '/');
+        if ((options?.ignoreTestFiles ?? true) && isTestFile(filename)) {
+            return {};
+        }
         const sourceCode = context.sourceCode;
         const sideEffectMatchers = (options?.sideEffectPatterns ?? []).map((pattern) => typeof pattern === 'string' ? new RegExp(pattern, 'i') : pattern);
         const reportedRanges = new Set();

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

@@ -1,51 +1,11 @@
 "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
@@ -84,8 +44,6 @@ 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, '');
         }
@@ -364,56 +322,45 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
             return targets;
         }
         /**
-         * 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 — or when no import
-         * specifier that resolves from this file can be derived.
+         * Whether the rewritten `cloneDeep(...)` call resolves in this file, which is
+         * true only where the file already imports the helper as a value.
+         *
+         * The specifier that reaches the helper is a property of the consuming
+         * project, not of this rule: the module is absent from some consumers
+         * entirely, and where it exists the two TypeScript tiers reach it by
+         * different forms. Writing an import from a guessed specifier therefore
+         * trades working code for a build error (#1396), so an existing import is
+         * demanded as proof of a path that resolves here — the same policy
+         * `enforce-querykey-ts` applies to its own import.
+         *
+         * A binding of the name from anywhere else is not proof and must not be
+         * reused: `lodash`'s `cloneDeep` accepts no overrides argument, a local
+         * declaration would shadow the helper, and a namespace or type-only import
+         * supplies no callable value.
          */
-        function buildImportFixes(fixer, scope) {
+        function bindsCloneDeepHelper(scope) {
             const existing = utils_1.ASTUtils.findVariable(scope, CLONE_DEEP_NAME);
-            if (existing) {
-                const [definition] = existing.defs;
-                if (!definition) {
-                    return null;
-                }
-                const definitionNode = definition.node;
-                if (definitionNode.type !== utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                    definitionNode.type !== utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
-                    return null;
-                }
-                if (definitionNode.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                    definitionNode.importKind === 'type') {
-                    return null;
-                }
-                const declaration = definitionNode.parent;
-                if (!declaration ||
-                    declaration.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
-                    declaration.importKind === 'type' ||
-                    !isCloneDeepModule(String(declaration.source.value))) {
-                    return null;
-                }
-                return [];
+            if (!existing) {
+                return false;
             }
-            const importDeclarations = sourceCode.ast.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-            const reusable = importDeclarations.find((declaration) => declaration.importKind !== 'type' &&
-                isCloneDeepModule(String(declaration.source.value)) &&
-                declaration.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier));
-            if (reusable) {
-                const namedSpecifiers = reusable.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
-                const lastSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
-                return [fixer.insertTextAfter(lastSpecifier, `, ${CLONE_DEEP_NAME}`)];
+            const [definition] = existing.defs;
+            if (!definition) {
+                return false;
             }
-            // 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 definitionNode = definition.node;
+            if (definitionNode.type !== utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                definitionNode.type !== utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+                return false;
             }
-            const importText = `import { ${CLONE_DEEP_NAME} } from '${cloneDeepSpecifier}';\n`;
-            const [firstImport] = importDeclarations;
-            if (firstImport) {
-                return [fixer.insertTextBefore(firstImport, importText)];
+            if (definitionNode.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                definitionNode.importKind === 'type') {
+                return false;
             }
-            return [fixer.insertTextBeforeRange([0, 0], importText)];
+            const declaration = definitionNode.parent;
+            return (!!declaration &&
+                declaration.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                declaration.importKind !== 'type' &&
+                isCloneDeepModule(String(declaration.source.value)));
         }
         // Find the outermost object expression that needs cloneDeep
         function findOutermostPartialDeepCopy(node) {
@@ -468,6 +415,9 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                             node,
                             messageId: 'preferCloneDeep',
                             fix(fixer) {
+                                if (!bindsCloneDeepHelper(scope)) {
+                                    return null;
+                                }
                                 const rewrites = [];
                                 const targets = startsWithSpread(node)
                                     ? [node]
@@ -482,11 +432,7 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                                     }
                                     rewrites.push(fixer.replaceText(target, call));
                                 }
-                                const importFixes = buildImportFixes(fixer, scope);
-                                if (importFixes === null) {
-                                    return null;
-                                }
-                                return [...importFixes, ...rewrites];
+                                return rewrites;
                             },
                         });
                     }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "version": "1.20.22",
+    "date": "2026-07-30T00:39:18.760Z",
+    "rules": [
+      {
+        "name": "parallelize-async-operations",
+        "changeType": "fix",
+        "issues": [
+          1395
+        ],
+        "summary": "exempt test files and stop schema defaults erasing barriers (closes #1395)"
+      },
+      {
+        "name": "prefer-clone-deep",
+        "changeType": "fix",
+        "issues": [
+          1396
+        ],
+        "summary": "only autofix when the file already imports the helper (closes #1396)"
+      }
+    ]
+  },
   {
     "version": "1.20.21",
     "date": "2026-07-29T23:50:58.620Z",