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

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.18",
+  "version": "1.20.19",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",

package/release-manifest.json

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