@blumintinc/eslint-plugin-blumint 1.20.158 → 1.20.160

package/lib/index.js

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

package/lib/rules/enforce-f-extension-for-entry-points.js

@@ -204,7 +204,15 @@ exports.enforceFExtensionForEntryPoints = (0, createRule_1.createRule)({
         const filePath = context.filename ??
             context.getFilename();
         const fileName = path_1.default.basename(filePath);
-        const entryPoints = new Set(options.entryPoints?.length ? options.entryPoints : DEFAULT_ENTRY_POINTS);
+        // Configured names EXTEND the defaults rather than replacing them. A
+        // default only matches when it is actually imported from firebase-functions
+        // or the internal wrappers, so carrying an unused one costs nothing, while
+        // dropping one silently stops enforcing the convention for that wrapper —
+        // which is what registering a single custom trigger used to do.
+        const entryPoints = new Set([
+            ...DEFAULT_ENTRY_POINTS,
+            ...(options.entryPoints ?? []),
+        ]);
         // Only apply to files under functions/src/
         const normalizedPath = filePath.replace(/\\/g, '/');
         if (!normalizedPath.includes('/functions/src/') &&

package/lib/rules/require-memo.js

@@ -323,6 +323,44 @@ function buildImportExtensionFix(fixer, program) {
  * that never renders. The report stands, the edit is withheld.
  */
 const isRewritableFunction = (node) => !node.async && !node.generator;
+/**
+ * Whether the call registers the one module factory jest hoists.
+ *
+ * `jest.mock` alone: `babel-plugin-jest-hoist` carries no case for `doMock` or
+ * `setMock`, which exist precisely to run in place, so a factory passed to
+ * either keeps its access to the module's bindings and needs no carve-out.
+ */
+function isHoistedMockCall(node) {
+    const { callee } = node;
+    if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression || callee.computed) {
+        return false;
+    }
+    const { object, property } = callee;
+    return (object.type === utils_1.AST_NODE_TYPES.Identifier &&
+        object.name === 'jest' &&
+        property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        property.name === 'mock');
+}
+/**
+ * Whether the node sits inside the factory jest hoists — the second argument of
+ * the call. The module specifier that precedes it is evaluated in place and
+ * keeps its access to the file's imports, so only the factory subtree is out of
+ * reach.
+ */
+function isInsideMockFactory(node) {
+    let child = node;
+    let parent = node.parent;
+    while (parent) {
+        if (parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+            parent.arguments[1] === child &&
+            isHoistedMockCall(parent)) {
+            return true;
+        }
+        child = parent;
+        parent = parent.parent;
+    }
+    return false;
+}
 /**
  * Whether the emitted `memo(...)` call can reach the helper, and the import edit
  * that makes it so (null when the helper is already imported).
@@ -337,6 +375,15 @@ const isRewritableFunction = (node) => !node.async && !node.generator;
  * default import rather than a `memo` binding, so it never reaches this path.
  */
 function planMemoBinding(context, fixer, node) {
+    // Jest hoists a `jest.mock()` factory above the module's imports, so the
+    // helper is unbound when the factory runs and jest rejects the reference
+    // outright ("Invalid variable access: memo"). This holds whether the import
+    // is injected here or already present, so it is decided before the
+    // already-imported shortcut below. The report stands because legal spellings
+    // exist: `import { memo as mockMemo }`, or `jest.requireActual` in-factory.
+    if (isInsideMockFactory(node)) {
+        return { available: false, importFix: null };
+    }
     const existingMemo = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), MEMO_NAME);
     if (existingMemo && !bindsMemoHelper(existingMemo)) {
         return { available: false, importFix: null };

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.160",
+    "date": "2026-08-17T02:55:06.538Z",
+    "rules": [
+      {
+        "name": "require-memo",
+        "changeType": "fix",
+        "issues": [
+          2028
+        ],
+        "summary": "decline the memo rewrite inside a jest.mock factory (closes #2028)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.159",
+    "date": "2026-08-17T02:05:07.694Z",
+    "rules": [
+      {
+        "name": "enforce-f-extension-for-entry-points",
+        "changeType": "fix",
+        "issues": [
+          2027
+        ],
+        "summary": "extend the default entry points rather than replacing them (closes #2027)"
+      }
+    ]
+  },
   {
     "version": "1.20.158",
     "date": "2026-08-16T14:52:13.506Z",