@blumintinc/eslint-plugin-blumint 1.20.151 → 1.20.152

package/lib/index.js

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

package/lib/rules/enforce-querykey-ts.js

@@ -123,20 +123,19 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
         ]);
         const sourceCode = context.getSourceCode();
         /**
-         * Reports are buffered until the whole file has been walked so the fixer can
-         * put every substituted constant into a single import instead of racing
-         * per-violation insertions that overlap and get dropped.
+         * Reports are buffered until the whole file has been walked so each fix is
+         * planned against the file's complete import picture: what a substituted
+         * constant resolves to, and whether the fix has to bring an import with it,
+         * are questions about the whole file rather than about the text above the
+         * violation.
          */
         const pendingReports = [];
         /**
-         * The queryKeys import rides on one violation's fix, which makes that
-         * violation the file's import carrier. ESLint collects fixes before it
-         * applies inline disable directives, so a suppressed carrier takes the
-         * import down with it while the surviving substitutions still land —
-         * leaving the file referencing constants nothing imports (#1410).
-         * Resolving suppression here keeps a suppressed violation out of the plan
-         * entirely: it neither claims the carrier slot nor contributes a specifier
-         * to the import, which would otherwise be imported and never used.
+         * A violation the author has waived with an inline disable directive is
+         * left out of the fix plan, so no constant is resolved for it and no import
+         * is written for it (#1410). This is the decision ESLint reaches anyway
+         * when it discards a suppressed message together with its fix, taken one
+         * step earlier where the rule can see it.
          */
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         /**
@@ -264,10 +263,13 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                 : queryKeysSpecifier;
         }
         /**
-         * Make the substituted constants resolve: extend the file's queryKeys import
+         * Make a substituted constant resolve: extend the file's queryKeys import
          * when there is one to extend, otherwise add a fresh import statement.
+         *
+         * The caller asks for this only where the constant binds to nothing, so the
+         * emitted specifier is never a duplicate of one the file already has.
          */
-        function buildImportFix(fixer, constants) {
+        function buildImportFix(fixer, constant) {
             const importDeclarations = importDeclarationsOf();
             const queryKeysDeclarations = queryKeysDeclarationsOf();
             const reusable = queryKeysDeclarations.find((declaration) => declaration.importKind !== 'type' &&
@@ -275,7 +277,7 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             if (reusable) {
                 const namedSpecifiers = reusable.specifiers.filter(isValueImportSpecifier);
                 const lastSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
-                return fixer.insertTextAfter(lastSpecifier, constants.map((constant) => `, ${constant}`).join(''));
+                return fixer.insertTextAfter(lastSpecifier, `, ${constant}`);
             }
             // A namespace or type-only queryKeys import cannot take named value
             // specifiers, but its path is proof of how this file reaches the module.
@@ -283,7 +285,7 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
             if (source === null) {
                 return null;
             }
-            const importText = `import { ${constants.join(', ')} } from '${source}';\n`;
+            const importText = `import { ${constant} } from '${source}';\n`;
             const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
             if (importDeclarations.length) {
                 // The statement joins an import block, and the anchor is that block's
@@ -310,7 +312,6 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
         }
         function flushReports() {
             const resolutions = new Map();
-            const missingConstants = [];
             const canImport = importSourceOf() !== null;
             // The location handed to `context.report` below is what ESLint matches a
             // directive against, so suppression is resolved from exactly that node.
@@ -329,20 +330,7 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                     continue;
                 }
                 resolutions.set(report, { name, state });
-                if (state === 'missing' && !missingConstants.includes(name)) {
-                    missingConstants.push(name);
-                }
             }
-            // The first applied substitution carries the import for every other one:
-            // its fix range then starts at the top of the file and ends before the
-            // remaining literals, so no two fixes of this rule overlap in a pass.
-            // Suppressed reports are skipped so the slot falls to a survivor.
-            const importCarrier = pendingReports.find((report) => {
-                const resolution = resolutions.get(report);
-                return (!suppressed.has(report) &&
-                    resolution !== undefined &&
-                    resolution.state !== 'conflict');
-            });
             // Suppressed violations are still reported: ESLint discards them, and
             // reporting keeps the user's directive "used" so that
             // `--report-unused-disable-directives` does not flag it.
@@ -363,8 +351,20 @@ exports.enforceQueryKeyTs = (0, createRule_1.createRule)({
                         const fixes = [
                             fixer.replaceText(substitution.keyNode, resolution.name),
                         ];
-                        if (report === importCarrier && missingConstants.length > 0) {
-                            const importFix = buildImportFix(fixer, missingConstants);
+                        // Every fix stands on its own: the one that writes a constant is
+                        // the one that imports it. Concentrating the file's imports into a
+                        // single carrier fix made every other fix depend on that one being
+                        // applied, and ESLint drops a fix whose range overlaps a fix it has
+                        // already taken from another rule — so the carrier lost that race
+                        // while the literal-only fixes still landed, leaving the file
+                        // naming an identifier nothing imports (#2012).
+                        //
+                        // Two such fixes both reach for the import declaration, so within a
+                        // pass they overlap and ESLint applies one of them. That converges:
+                        // the unapplied violation is re-reported on the next pass and its
+                        // constant then binds to, or extends, the import that landed.
+                        if (resolution.state === 'missing') {
+                            const importFix = buildImportFix(fixer, resolution.name);
                             if (!importFix) {
                                 return null;
                             }

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

@@ -25,6 +25,41 @@ function isCloneDeepModule(source) {
         source.startsWith('@/') ||
         source.endsWith('util/cloneDeep'));
 }
+function isConstAssertion(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
+        node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+        node.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        node.typeAnnotation.typeName.name === 'const');
+}
+/**
+ * A `const` assertion is legal only on a literal, so leaving one wrapped around
+ * the emitted `cloneDeep(...)` call yields TS1355 and turns a compiling file
+ * into a broken one (#2011). The fix is declined there rather than absorbing
+ * the assertion, which is the conservative reading of a `const` the author
+ * asked for on a value this rule replaces.
+ *
+ * The whole assertion chain is walked because each of its links still applies
+ * to the emitted call: `as Foo as const`, `satisfies Foo as const` and
+ * `! as const` are TS1355 just the same. The walk stops at the first parent
+ * that is not an assertion, which keeps `as const` on an ENCLOSING literal
+ * fixable — that assertion still has a literal to apply to.
+ *
+ * Only a `const` assertion is disqualifying: `as Foo` and `satisfies Foo` are
+ * legal on a call expression and keep their fix.
+ */
+function isConstAsserted(node) {
+    let current = node.parent;
+    while (current &&
+        (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+            current.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
+            current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression)) {
+        if (isConstAssertion(current)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
 exports.preferCloneDeep = (0, createRule_1.createRule)({
     name: 'prefer-clone-deep',
     meta: {
@@ -444,6 +479,9 @@ exports.preferCloneDeep = (0, createRule_1.createRule)({
                                     return null;
                                 }
                                 for (const target of targets) {
+                                    if (isConstAsserted(target)) {
+                                        return null;
+                                    }
                                     const call = buildCloneDeepCall(target);
                                     if (call === null) {
                                         return null;

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,26 @@
 [
+  {
+    "version": "1.20.152",
+    "date": "2026-08-14T10:28:08.765Z",
+    "rules": [
+      {
+        "name": "enforce-querykey-ts",
+        "changeType": "fix",
+        "issues": [
+          2012
+        ],
+        "summary": "carry each key's import on its own fix (closes #2012)"
+      },
+      {
+        "name": "prefer-clone-deep",
+        "changeType": "fix",
+        "issues": [
+          2011
+        ],
+        "summary": "decline the fix under a const assertion (closes #2011)"
+      }
+    ]
+  },
   {
     "version": "1.20.151",
     "date": "2026-08-14T02:27:13.012Z",