@blumintinc/eslint-plugin-blumint 1.20.67 → 1.20.68

package/lib/index.js

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

package/lib/rules/prefer-union-from-const-array.js

@@ -54,17 +54,28 @@ function isNameInScope(scope, name) {
  * between consecutive lines. Reading it from the source keeps emitted code in
  * the author's units instead of assuming a two-space, space-indented file.
  */
-function indentUnitOf(text) {
+function indentUnitOf(sourceCode) {
+    const text = sourceCode.getText();
+    const blockComments = sourceCode
+        .getAllComments()
+        .filter((comment) => comment.type === utils_1.AST_TOKEN_TYPES.Block)
+        .map((comment) => comment.range);
+    // A block comment's interior lines carry whatever alignment the comment uses
+    // — the `*` one column in from its own indentation, or, for commented-out
+    // code, the original code's depths. Neither is a nesting step of the file, and
+    // counting them makes a JSDoc-heavy file look 1-space indented. Keying on the
+    // comment's range rather than a leading `*` also covers a body without them.
+    const continuesBlockComment = (offset) => blockComments.some(([start, end]) => start < offset && offset < end);
     const frequencies = new Map();
     let previous = '';
+    let offset = 0;
     for (const line of text.split('\n')) {
+        const lineStart = offset;
+        offset += line.length + 1;
         if (line.trim() === '') {
             continue;
         }
-        // A block comment's continuation lines align on the `*` one column in from
-        // the comment's own indentation. That is comment alignment, not a nesting
-        // step, and counting it makes any JSDoc-heavy file look 1-space indented.
-        if (line.trimStart().startsWith('*')) {
+        if (continuesBlockComment(lineStart)) {
             continue;
         }
         const match = /^[ \t]*/.exec(line);
@@ -121,7 +132,7 @@ exports.preferUnionFromConstArray = (0, createRule_1.createRule)({
         let indentUnit = null;
         const fileIndentUnit = () => {
             if (indentUnit === null) {
-                indentUnit = indentUnitOf(sourceCode.getText());
+                indentUnit = indentUnitOf(sourceCode);
             }
             return indentUnit;
         };

package/lib/utils/ruleTester.d.ts

@@ -17,9 +17,11 @@ type ParserOptionsCarrier = {
  * and its rule silently drops out of the fixer, convergence, collision and
  * crash sweeps. `src/tests/no-local-rule-tester.test.ts` enforces that.
  *
- * A file needing parser options the shared instances do not declare — ES module
- * scope analysis, a type-aware `project` — attaches them per case rather than
- * forking a tester. RuleTester deep merges each case's config over the tester's,
+ * A file needing parser options the shared instances do not declare — a
+ * type-aware `project`, a non-default `ecmaVersion` — attaches them per case
+ * rather than forking a tester. The shared instances already declare ES module
+ * scope analysis, so a case restating `sourceType: 'module'` is redundant but
+ * harmless. RuleTester deep merges each case's config over the tester's,
  * and options a case declares itself still win over the ones applied here, so a
  * case keeps any override it already had. Carrying the options on the case also
  * means the harvested corpus records the parser configuration a snippet was

package/lib/utils/ruleTester.js

@@ -3,12 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withParserOptions = exports.ruleTesterMarkdown = exports.ruleTesterJson = exports.ruleTesterJsx = exports.ruleTesterTs = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const eslint_1 = require("eslint");
+/**
+ * `sourceType: 'module'` matches how the linted codebase actually parses: every
+ * consumer source file is an ES module, so its top-level declarations live in a
+ * module scope nested inside the global one.
+ *
+ * `@typescript-eslint/parser` defaults to `'script'`, under which a top-level
+ * `import`/`const` still binds — the binding hangs off the *global* scope rather
+ * than a module scope. References therefore still resolve either way, but the
+ * scope shape differs: under `'script'` `globalScope.variables` carries the
+ * file's own declarations and there is no module scope at all. A rule that
+ * discriminates on `scope.type`, walks `globalScope.childScopes`, or reads
+ * `globalScope.variables` would otherwise be exercised against a shape no real
+ * file has. `src/tests/rule-tester-parse-mode.test.ts` pins this.
+ */
+const SHARED_PARSER_OPTIONS = {
+    sourceType: 'module',
+};
 exports.ruleTesterTs = new utils_1.ESLintUtils.RuleTester({
     parser: '@typescript-eslint/parser',
+    parserOptions: { ...SHARED_PARSER_OPTIONS },
 });
 exports.ruleTesterJsx = new utils_1.ESLintUtils.RuleTester({
     parser: '@typescript-eslint/parser',
     parserOptions: {
+        ...SHARED_PARSER_OPTIONS,
         ecmaFeatures: {
             jsx: true,
         },
@@ -32,9 +51,11 @@ exports.ruleTesterMarkdown = new eslint_1.RuleTester({
  * and its rule silently drops out of the fixer, convergence, collision and
  * crash sweeps. `src/tests/no-local-rule-tester.test.ts` enforces that.
  *
- * A file needing parser options the shared instances do not declare — ES module
- * scope analysis, a type-aware `project` — attaches them per case rather than
- * forking a tester. RuleTester deep merges each case's config over the tester's,
+ * A file needing parser options the shared instances do not declare — a
+ * type-aware `project`, a non-default `ecmaVersion` — attaches them per case
+ * rather than forking a tester. The shared instances already declare ES module
+ * scope analysis, so a case restating `sourceType: 'module'` is redundant but
+ * harmless. RuleTester deep merges each case's config over the tester's,
  * and options a case declares itself still win over the ones applied here, so a
  * case keeps any override it already had. Carrying the options on the case also
  * means the harvested corpus records the parser configuration a snippet was

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,18 @@
 [
+  {
+    "version": "1.20.68",
+    "date": "2026-08-01T18:03:14.950Z",
+    "rules": [
+      {
+        "name": "prefer-union-from-const-array",
+        "changeType": "fix",
+        "issues": [
+          1577
+        ],
+        "summary": "exclude block comments by range when inferring the indent unit (closes #1577)"
+      }
+    ]
+  },
   {
     "version": "1.20.67",
     "date": "2026-08-01T17:17:30.817Z",