@blumintinc/eslint-plugin-blumint 1.20.182 → 1.20.183

package/lib/index.js

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

package/lib/rules/enforce-verb-noun-naming.js

@@ -4089,6 +4089,16 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                     parent.key.type === utils_1.AST_NODE_TYPES.Identifier) {
                     return parent.key.name;
                 }
+                // A method holds its name on the member key exactly as a field does.
+                // Without this arm a method's `FunctionExpression` is anonymous, and an
+                // anonymous function never reaches the PascalCase component evidence —
+                // leaving `Panel() { return <div />; }` judged by the weak
+                // props-and-JSX fallback alone, which a parameterless component fails.
+                if (parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition &&
+                    !parent.computed &&
+                    parent.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return parent.key.name;
+                }
             }
             return '';
         }
@@ -4134,12 +4144,15 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
          * scope analysis, which records JSX element names as references.
          */
         function isUsedAsReactComponent(node, functionName) {
-            // A class field's name is a member, not a lexical binding, so a variable
+            // A class member's name is a member, not a lexical binding, so a variable
             // of the same name found in scope belongs to some other symbol entirely
-            // and says nothing about the field. `<this.Foo />` is a member expression
-            // and records no reference to resolve, so the field relies on the other
-            // component evidence.
-            if (node.parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
+            // and says nothing about the member. `<this.Foo />` is a member expression
+            // and records no reference to resolve, so the member relies on the other
+            // component evidence. This holds for a method as much as for a field:
+            // resolving `Panel` lexically from inside a class would answer with an
+            // imported component of that name.
+            if (node.parent?.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+                node.parent?.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
                 return false;
             }
             const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
@@ -4281,6 +4294,15 @@ exports.enforceVerbNounNaming = (0, createRule_1.createRule)({
                 // Skip constructors since they are special class methods
                 if (node.kind === 'constructor')
                     return;
+                // A component is a noun by convention, and `Panel() { return <div />; }`
+                // is the same member as `Panel = () => <div />` with one token changed.
+                // The carve-out reaches every other spelling of a function, so a method
+                // that is a component answers to it too. A `set` accessor is an
+                // assignment target rather than a callable, so it can never be a
+                // component and is deliberately left to the naming demand.
+                if (node.kind === 'method' && isReactComponent(node.value)) {
+                    return;
+                }
                 if (!isVerbPhrase(node.key.name)) {
                     context.report({
                         node: node.key,

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

@@ -22,6 +22,179 @@ const TEST_FILE_DIRECTORY = /(^|\/)(__tests__|__mocks__)\//;
  * assertion against the interaction (issue #1395).
  */
 const isTestFile = (filename) => TEST_FILE_SUFFIX.test(filename) || TEST_FILE_DIRECTORY.test(filename);
+/**
+ * Module specifiers whose exports operate the filesystem.
+ *
+ * The `node:`-prefixed and bare spellings name the same built-in module, and
+ * `graceful-fs` is a drop-in wrapper over it, so a run mixing the spellings
+ * still touches ONE resource. Membership is by specifier rather than by callee
+ * name because the name alone proves nothing: a project's own `writeFile`
+ * helper shares the name while sharing no resource.
+ */
+const FS_MODULE_SOURCES = new Set([
+    'fs',
+    'node:fs',
+    'fs/promises',
+    'node:fs/promises',
+    'graceful-fs',
+]);
+/**
+ * Filesystem operations that only OBSERVE the filesystem.
+ *
+ * Two observations commute -- neither can change what the other returns -- so a
+ * run of them carries no ordering and stays parallelizable, which is where this
+ * rule's value lies for I/O-bound reads. Every other operation is treated as
+ * mutating.
+ *
+ * The set is an allowlist read fail-safe, so an operation it does not know
+ * counts as mutating. The failure directions are not symmetric: misreading a
+ * mutation as an observation races a write against its own precondition and
+ * ships a silent corruption, whereas misreading an observation as a mutation
+ * only declines a parallelization. An fs surface this list does not enumerate
+ * therefore keeps the barrier.
+ */
+const READ_ONLY_FS_OPERATIONS = new Set([
+    'readFile',
+    'readdir',
+    'stat',
+    'lstat',
+    'fstat',
+    'access',
+    'realpath',
+    'readlink',
+    'opendir',
+    'exists',
+]);
+/**
+ * The `*Sync` variant of an fs operation performs the same operation on the
+ * same resource, so it classifies identically to the asynchronous spelling and
+ * the suffix is dropped before the lookup. This keeps the allowlist to one
+ * entry per operation, which is what stops a `readFileSync` omission from
+ * quietly reclassifying a read as a mutation.
+ */
+const SYNC_OPERATION_SUFFIX = /Sync$/;
+function isReadOnlyFsOperation(operation) {
+    return READ_ONLY_FS_OPERATIONS.has(operation.replace(SYNC_OPERATION_SUFFIX, ''));
+}
+/**
+ * Strips the wrappers that carry no value of their own, so a shape test reaches
+ * the expression the source actually denotes.
+ *
+ * `a?.b` is wrapped in a ChainExpression, so a bare `MemberExpression` or
+ * `CallExpression` test sees the wrapper instead and answers no. Here that
+ * answer is the UNSAFE one -- an unrecognised `require` spelling yields no
+ * filesystem binding, which withdraws the ordering barrier rather than merely
+ * declining a parallelization -- so the optional spellings are unwrapped to the
+ * same node their non-optional spellings produce. `create` declares its own
+ * `unwrapExpression` for the same purpose; this one exists because binding
+ * collection runs at module scope, where that closure is out of reach.
+ */
+function unwrapWrappers(node) {
+    let current = node;
+    while (current.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+        current = current.expression;
+    }
+    return current;
+}
+/**
+ * The module specifier a `require(...)` call loads, when the call names it as a
+ * string literal.
+ *
+ * `require('fs').promises` is the same load one member deeper, so a member
+ * expression rooted at the call answers with the call's own specifier: the
+ * binding it produces still reaches the filesystem.
+ */
+function requiredModuleSource(node) {
+    if (!node) {
+        return null;
+    }
+    const unwrapped = unwrapWrappers(node);
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        return requiredModuleSource(unwrapped.object);
+    }
+    if (unwrapped.type !== utils_1.AST_NODE_TYPES.CallExpression ||
+        unwrapped.arguments.length !== 1) {
+        return null;
+    }
+    const callee = unwrapWrappers(unwrapped.callee);
+    if (callee.type !== utils_1.AST_NODE_TYPES.Identifier || callee.name !== 'require') {
+        return null;
+    }
+    const [specifier] = unwrapped.arguments;
+    return specifier.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof specifier.value === 'string'
+        ? specifier.value
+        : null;
+}
+/**
+ * Every binding in the file's module scope that denotes something loaded from a
+ * filesystem module, mapped to the EXPORTED name it denotes when it denotes a
+ * single operation (`import { writeFile as wf }` -> `wf` denotes `writeFile`),
+ * and to null when it denotes the module object itself (a namespace, default or
+ * whole-module `require` binding, whose operation is named at the call site
+ * instead).
+ *
+ * The exported name is what a bare callee is classified by, so a renamed import
+ * classifies as the operation it actually calls rather than falling to the
+ * mutating default on a name the fs surface never had.
+ *
+ * Resolution is lexical and same-file by design: `RuleTester` runs with no
+ * `parserOptions.project`, so a type-aware answer is unavailable exactly where
+ * the barrier has to be proven.
+ */
+function collectFsBindings(program) {
+    const bindings = new Map();
+    const recordPattern = (id) => {
+        if (id.type === utils_1.AST_NODE_TYPES.Identifier) {
+            bindings.set(id.name, null);
+            return;
+        }
+        if (id.type !== utils_1.AST_NODE_TYPES.ObjectPattern) {
+            return;
+        }
+        for (const property of id.properties) {
+            if (property.type !== utils_1.AST_NODE_TYPES.Property ||
+                property.computed ||
+                property.key.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                continue;
+            }
+            const local = property.value;
+            if (local.type === utils_1.AST_NODE_TYPES.Identifier) {
+                bindings.set(local.name, property.key.name);
+            }
+        }
+    };
+    for (const statement of program.body) {
+        const declaration = statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
+            statement.declaration
+            ? statement.declaration
+            : statement;
+        if (declaration.type === utils_1.AST_NODE_TYPES.ImportDeclaration) {
+            if (!FS_MODULE_SOURCES.has(declaration.source.value)) {
+                continue;
+            }
+            for (const specifier of declaration.specifiers) {
+                // A namespace or default specifier binds the module OBJECT, whose
+                // operation is named at the call site, so it records no exported name.
+                bindings.set(specifier.local.name, specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier
+                    ? specifier.imported.name
+                    : null);
+            }
+            continue;
+        }
+        if (declaration.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+            for (const declarator of declaration.declarations) {
+                const source = requiredModuleSource(declarator.init);
+                if (source && FS_MODULE_SOURCES.has(source)) {
+                    recordPattern(declarator.id);
+                }
+            }
+        }
+    }
+    return bindings;
+}
 /**
  * Matches prettier's own default. The autofix authors a whole statement a
  * formatter owns, so a layout it emits that prettier would not is rewritten on
@@ -202,6 +375,16 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             return {};
         }
         const sourceCode = context.sourceCode;
+        // The file's filesystem bindings are a property of its module scope, not of
+        // any one run, so they are resolved once per file and reused by every
+        // candidate run the traversal reaches.
+        let fsBindings = null;
+        const getFsBindings = () => {
+            if (fsBindings === null) {
+                fsBindings = collectFsBindings(sourceCode.ast);
+            }
+            return fsBindings;
+        };
         // The width the autofix lays the rewritten statement out against. It lives
         // in the consumer's formatter configuration, which no rule context carries,
         // so a project formatting at 100 or 120 states it here.
@@ -1356,6 +1539,49 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             // every such write is by construction published to the outer scope.
             return { names, instancePaths: new Set(targets.instancePaths) };
         }
+        /**
+         * Names the filesystem operation an await performs, or null when the await
+         * does not reach the filesystem through a binding this file declares.
+         *
+         * The classification keys on the ORIGIN of the callee's root binding rather
+         * than on the callee's spelling, so a project-local helper that happens to
+         * be called `writeFile` is not mistaken for the fs export of that name, and
+         * a renamed import (`writeFile as wf`) is not missed for lacking it.
+         *
+         * The operation is read off the LAST member of a member callee
+         * (`fs.promises.writeFile` -> `writeFile`), which is where the module object
+         * spells it, and off the imported name for a bare callee, which is where a
+         * named import spells it. A computed member whose key is not a literal names
+         * an operation the source does not state, so it yields the empty string and
+         * classifies as mutating, matching the fail-safe the allowlist is read with.
+         */
+        function getFsOperationName(awaitExpr) {
+            const argument = unwrapExpression(awaitExpr.argument);
+            if (argument.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                return null;
+            }
+            const callee = unwrapExpression(argument.callee);
+            const root = getPathRoot(callee);
+            if (root.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return null;
+            }
+            const bindings = getFsBindings();
+            if (!bindings.has(root.name)) {
+                return null;
+            }
+            if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                const { property } = callee;
+                if (!callee.computed && property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return property.name;
+                }
+                if (property.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof property.value === 'string') {
+                    return property.value;
+                }
+                return '';
+            }
+            return bindings.get(root.name) ?? root.name;
+        }
         /**
          * Checks if there are dependencies between await expressions
          */
@@ -1744,6 +1970,53 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                     }
                 }
             }
+            // 13. Shared external-resource ordering barrier (filesystem). Two awaits
+            // that operate the same filesystem are ordered by that resource, not by
+            // any JS value: `writeFile(pending, data)` then `rename(pending, path)`
+            // passes nothing from one call to the other, yet the second one's
+            // precondition is precisely the first one's side effect. Every barrier
+            // above reads bindings, receivers and slots -- the JS-level surface -- so
+            // a dependency carried entirely through an external resource is invisible
+            // to all of them, and the run reads as independent while being strictly
+            // ordered. Promise.all issues all of it in one tick, which either throws
+            // ENOENT or publishes a partial state, and WHICH of the two is a race, so
+            // the damage is timing-dependent rather than reproducible. (#2166)
+            //
+            // The barrier engages only when at least one operation MUTATES. Two
+            // observations of the filesystem commute -- neither can change what the
+            // other returns -- so `readFile(a)` then `readFile(b)` is a genuine
+            // latency mistake and keeps its report, which is where the rule earns
+            // most of its value on I/O-bound code. A mutation makes the ordering
+            // observable, and observable ordering is exactly what the rewrite
+            // destroys.
+            //
+            // A single fs await raises no ordering question: the resource has to be
+            // SHARED for the sequencing to exist, so a run mixing one fs call with
+            // unrelated network calls still parallelizes.
+            //
+            // Member-callee spellings (`fs.writeFile()`, `fs.promises.rename()`) are
+            // incidentally held by the shared-receiver barrier above, which keys on
+            // the receiver they have in common. They are classified here too because
+            // that coverage is a side effect of an unrelated question: it lapses the
+            // moment a file mixes spellings (`fs.writeFile()` then a named-import
+            // `rename()`), which shares the resource while sharing no receiver.
+            let fsAwaitCount = 0;
+            let mutatesFilesystem = false;
+            for (const node of awaitNodes) {
+                const awaitExpr = getAwaitExpression(node);
+                if (!awaitExpr)
+                    continue;
+                const operation = getFsOperationName(awaitExpr);
+                if (operation === null)
+                    continue;
+                fsAwaitCount++;
+                if (!isReadOnlyFsOperation(operation)) {
+                    mutatesFilesystem = true;
+                }
+            }
+            if (fsAwaitCount >= 2 && mutatesFilesystem) {
+                return true;
+            }
             return false;
         }
         /**

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "version": "1.20.183",
+    "date": "2026-08-27T17:21:40.008Z",
+    "rules": [
+      {
+        "name": "enforce-verb-noun-naming",
+        "changeType": "fix",
+        "issues": [
+          2165
+        ],
+        "summary": "reach the class-METHOD spelling with the React-component carve-out (closes #2165)"
+      },
+      {
+        "name": "parallelize-async-operations",
+        "changeType": "fix",
+        "issues": [
+          2166
+        ],
+        "summary": "barrier awaits that share the filesystem (closes #2166)"
+      }
+    ]
+  },
   {
     "version": "1.20.182",
     "date": "2026-08-27T12:12:45.593Z",