@blumintinc/eslint-plugin-blumint 1.20.155 → 1.20.157

package/lib/index.js

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

package/lib/rules/enforce-positive-naming.js

@@ -55,7 +55,10 @@ const IN_EXCEPTIONS = [
     'increases',
     'increasing',
     'increasingly',
+    'increment',
     'incremental',
+    'incremented',
+    'incrementing',
     'increments',
     'incriminating',
     'incubation',
@@ -190,8 +193,11 @@ const IN_EXCEPTIONS = [
     'inhaling',
     'inherent',
     'inherently',
+    'inherit',
     'inheritance',
     'inherited',
+    'inheriting',
+    'inherits',
     'initial',
     'initially',
     'initials',
@@ -219,6 +225,10 @@ const IN_EXCEPTIONS = [
     'inland',
     'inlay',
     'inlet',
+    'inline',
+    'inlined',
+    'inlines',
+    'inlining',
     'inmate',
     'inmates',
     'inn',
@@ -294,6 +304,10 @@ const IN_EXCEPTIONS = [
     'instances',
     'instant',
     'instantaneous',
+    'instantiate',
+    'instantiated',
+    'instantiates',
+    'instantiating',
     'instantly',
     'instead',
     'instigated',
@@ -340,6 +354,11 @@ const IN_EXCEPTIONS = [
     'intake',
     'integer',
     'integers',
+    'integrate',
+    'integrated',
+    'integrates',
+    'integrating',
+    'integration',
     'intel',
     'intellect',
     'intellectual',

package/lib/rules/logical-top-to-bottom-grouping.js

@@ -1806,6 +1806,49 @@ function moveSegment(segments, fromIndex, toIndex) {
     next.splice(toIndex < fromIndex ? toIndex : toIndex - 1, 0, moved.replace(/[ \t]+$/u, ''));
     return next;
 }
+const LINE_TERMINATORS = new Set(['\n', '\r', '\u2028', '\u2029']);
+/**
+ * Whether text appended to `text` would start on a fresh line.
+ *
+ * Trailing spaces and tabs are skipped: a segment ends with the indentation that
+ * belonged to whatever followed it, and that indentation still leaves an appended
+ * segment on a line of its own.
+ */
+function endsWithLineTerminator(text) {
+    let cursor = text.length - 1;
+    while (cursor >= 0 && (text[cursor] === ' ' || text[cursor] === '\t')) {
+        cursor -= 1;
+    }
+    return cursor >= 0 && LINE_TERMINATORS.has(text[cursor]);
+}
+/**
+ * The line break the source itself uses, so a separator restored below matches its
+ * neighbours instead of mixing endings into a CRLF file.
+ */
+function lineBreakOf(text) {
+    const index = text.indexOf('\n');
+    return index > 0 && text[index - 1] === '\r' ? '\r\n' : '\n';
+}
+/**
+ * Concatenates reordered segments, restoring the statement separation the source
+ * carried positionally.
+ *
+ * A segment runs up to where the next one began, so it normally already ends with the
+ * line break that separated them. Two do not: the block's last segment stops at `}` or
+ * at the end of the file, and a statement sharing a line with its predecessor never had
+ * a break in front of it. Once a reordering moves such a segment away from the end,
+ * appending the next segment directly runs two statements together — and where the
+ * first ends in a `//` comment that is not a formatting blemish, since the appended
+ * statement becomes comment text and vanishes from the program (#2023).
+ *
+ * Only the joins are separated. Nothing is appended after the final segment, whose
+ * successor is the untouched text outside the replaced range.
+ */
+function joinSegments(segments, lineBreak) {
+    return segments.reduce((text, segment, index) => index === 0 || endsWithLineTerminator(text)
+        ? text + segment
+        : text + lineBreak + segment, '');
+}
 /**
  * Emits an entire reordering as one fix by permuting the block's text segments.
  *
@@ -1827,7 +1870,7 @@ function buildReorderFix(body, moves, parent, sourceCode, fixer) {
     if (first > last) {
         return null;
     }
-    return fixer.replaceTextRange([bounds[first], bounds[last + 1]], reordered.slice(first, last + 1).join(''));
+    return fixer.replaceTextRange([bounds[first], bounds[last + 1]], joinSegments(reordered.slice(first, last + 1), lineBreakOf(sourceCode.getText())));
 }
 /**
  * A fix is emitted only for a reordering the detector scores at zero relocatable

package/lib/rules/prefer-nullish-coalescing-boolean-props.js

@@ -27,6 +27,7 @@ exports.preferNullishCoalescingBooleanProps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const ts = __importStar(require("typescript"));
 const createRule_1 = require("../utils/createRule");
+const replacementSegments_1 = require("../utils/replacementSegments");
 const BOOLEAN_PROP_REGEX = /^(is|has|should|can|will|do|does|did|was|were|enable|disable)/;
 function isBooleanType(type, checker) {
     if (type.isUnion()) {
@@ -531,6 +532,68 @@ function needsSelfParens(node, sourceCode) {
     }
     return !isParenthesized(node, sourceCode);
 }
+/**
+ * Comments the rewrite would delete.
+ *
+ * The fix rebuilds the whole expression from `getText` of each operand, so every
+ * comment written inside the node but outside both operand ranges has no anchor
+ * in the replacement: the trivia around the `||` operator, and anything sitting
+ * inside source-level parentheses that the rebuild discards. Comments nested
+ * within an operand travel with that operand's own text and are never stranded.
+ */
+function strandedComments(node, sourceCode) {
+    const enclosedBy = (operand) => (comment) => comment.range[0] >= operand.range[0] &&
+        comment.range[1] <= operand.range[1];
+    const inLeft = enclosedBy(node.left);
+    const inRight = enclosedBy(node.right);
+    return sourceCode
+        .getCommentsInside(node)
+        .filter((comment) => !inLeft(comment) && !inRight(comment));
+}
+function groupStrandedComments(node, sourceCode) {
+    const operator = sourceCode.getTokenAfter(node.left, {
+        filter: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '||',
+    });
+    const groups = {
+        leading: [],
+        beforeOperator: [],
+        afterOperator: [],
+        trailing: [],
+    };
+    for (const comment of strandedComments(node, sourceCode)) {
+        if (comment.range[1] <= node.left.range[0]) {
+            groups.leading.push(comment);
+        }
+        else if (comment.range[0] >= node.right.range[1]) {
+            groups.trailing.push(comment);
+        }
+        else if (operator && comment.range[1] <= operator.range[0]) {
+            groups.beforeOperator.push(comment);
+        }
+        else {
+            groups.afterOperator.push(comment);
+        }
+    }
+    return groups;
+}
+/**
+ * `return`, `throw` and `yield` forbid a LineTerminator between themselves and
+ * their operand, so a carried comment that demands its own line cannot sit
+ * between one of them and the rewritten expression: a line comment there ends
+ * the statement through ASI, and so does a block comment carrying a line
+ * terminator, which the grammar reads AS a LineTerminator (#1963). Such a
+ * comment rides ahead of the keyword instead.
+ *
+ * The keyword token is the anchor rather than the start of its line because an
+ * insertion point immediately before a token is always a token boundary, while a
+ * line start can fall inside a multi-line template literal and would be written
+ * into the template's text.
+ */
+const RESTRICTED_KEYWORDS = new Set(['return', 'throw', 'yield']);
+function restrictedKeywordBefore(node, sourceCode) {
+    const before = sourceCode.getTokenBefore(node);
+    return before && RESTRICTED_KEYWORDS.has(before.value) ? before : null;
+}
 exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
     name: 'prefer-nullish-coalescing-boolean-props',
     meta: {
@@ -582,10 +645,67 @@ exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
                                 right: rightText,
                             },
                             fix(fixer) {
-                                const replacement = `${parenthesizeLogical(leftText, node.left)} ?? ${parenthesizeLogical(rightText, node.right)}`;
-                                return fixer.replaceText(node, needsSelfParens(node, sourceCode)
-                                    ? `(${replacement})`
-                                    : replacement);
+                                const groups = groupStrandedComments(node, sourceCode);
+                                // Whether the replacement is parenthesized is decided by the
+                                // expression's context exactly as it is without comments:
+                                // parentheses are tokens, so letting a carried comment add them
+                                // would make the comment change the emitted program.
+                                const selfParens = needsSelfParens(node, sourceCode);
+                                const text = sourceCode.getText();
+                                const toSegment = (comment) => ({
+                                    text: text.slice(comment.range[0], comment.range[1]),
+                                    breakAfter: (0, replacementSegments_1.requiresLineBreakAfter)(comment),
+                                });
+                                // A carried comment's only anchor is the line the expression
+                                // opens on, which can start mid-line.
+                                const startLine = sourceCode.lines[node.loc.start.line - 1] ?? '';
+                                const indent = /^[\t ]*/.exec(startLine)?.[0] ?? '';
+                                // Inside parentheses a newline can never trigger ASI, so every
+                                // comment can ride within the replacement on a line of its own.
+                                // Without them, a leading comment that demands its own line
+                                // moves ahead of a restricted keyword when one governs the
+                                // expression; everywhere else a line break before the
+                                // expression is inert.
+                                const keyword = selfParens
+                                    ? null
+                                    : restrictedKeywordBefore(node, sourceCode);
+                                const hoisted = keyword
+                                    ? groups.leading.filter(replacementSegments_1.requiresOwnLine)
+                                    : [];
+                                const segments = [
+                                    ...groups.leading
+                                        .filter((comment) => !hoisted.includes(comment))
+                                        .map(toSegment),
+                                    {
+                                        text: parenthesizeLogical(leftText, node.left),
+                                        breakAfter: false,
+                                    },
+                                    ...groups.beforeOperator.map(toSegment),
+                                    { text: '??', breakAfter: false },
+                                    ...groups.afterOperator.map(toSegment),
+                                    {
+                                        text: parenthesizeLogical(rightText, node.right),
+                                        breakAfter: false,
+                                    },
+                                    ...groups.trailing.map(toSegment),
+                                ];
+                                if (selfParens) {
+                                    return fixer.replaceText(node, (0, replacementSegments_1.joinSegments)(segments, indent));
+                                }
+                                const body = (0, replacementSegments_1.joinSegmentBody)(segments, indent);
+                                const trailing = segments[segments.length - 1].breakAfter
+                                    ? `\n${indent}`
+                                    : '';
+                                const replacement = fixer.replaceText(node, `${body}${trailing}`);
+                                if (!keyword || hoisted.length === 0) {
+                                    return replacement;
+                                }
+                                return [
+                                    fixer.insertTextBefore(keyword, hoisted
+                                        .map((comment) => `${text.slice(comment.range[0], comment.range[1])}\n${indent}`)
+                                        .join('')),
+                                    replacement,
+                                ];
                             },
                         });
                     }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.20.157",
+    "date": "2026-08-16T06:24:21.626Z",
+    "rules": [
+      {
+        "name": "enforce-positive-naming",
+        "changeType": "fix",
+        "issues": [
+          2025
+        ],
+        "summary": "treat the inherit/increment/integrate/instantiate/inline families as in- exceptions (closes #2025)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.156",
+    "date": "2026-08-15T18:39:54.919Z",
+    "rules": [
+      {
+        "name": "logical-top-to-bottom-grouping",
+        "changeType": "fix",
+        "issues": [
+          2023
+        ],
+        "summary": "separate reordered statements so a relocated one cannot land inside a trailing // comment (closes #2023)"
+      },
+      {
+        "name": "prefer-nullish-coalescing-boolean-props",
+        "changeType": "fix",
+        "issues": [
+          2024
+        ],
+        "summary": "carry the comments stranded between the operands instead of deleting them (closes #2024)"
+      }
+    ]
+  },
   {
     "version": "1.20.155",
     "date": "2026-08-15T14:21:55.491Z",