@blumintinc/eslint-plugin-blumint 1.20.8 → 1.20.10

package/lib/index.js

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

package/lib/rules/enforce-early-destructuring.js

@@ -739,6 +739,8 @@ function buildDestructuringGroups(callback, depTextSet, visitorKeys, sourceCode)
                         declarations,
                         inits,
                         baseName: existingGroup?.baseName ?? baseName ?? null,
+                        hasTypeAnnotation: Boolean(existingGroup?.hasTypeAnnotation) ||
+                            Boolean(declarator.id.typeAnnotation),
                     });
                 }
             }
@@ -764,6 +766,18 @@ function validateGroupsForHoisting(groups, callback, scope, visitorKeys, reserve
     if (hasCrossGroupNameCollision(groups)) {
         return null;
     }
+    // The hoisted declaration re-emits the pattern from property texts against a
+    // `(obj) ?? {}` initializer. A declarator annotation cannot survive that: the
+    // `{}` fallback almost never satisfies the annotation, and widening it to one
+    // that does requires the type checker. Reporting without a fix is preferable
+    // to silently dropping the annotation or manufacturing a type error, and a
+    // single annotated declarator withholds the whole fix because a partial hoist
+    // would still rewrite the dependency array around the statement left behind.
+    for (const group of groups.values()) {
+        if (group.hasTypeAnnotation) {
+            return null;
+        }
+    }
     const declarationsToRemove = new Set();
     const initsToIgnore = new Set();
     for (const group of groups.values()) {

package/lib/rules/enforce-m3-sentence-case.js

@@ -198,42 +198,193 @@ function isAllCapsViolation(text, ignoredWordsSet) {
     return !allExempt;
 }
 /**
- * Builds the corrected version of the text for the suggestion / fix.
- * — ALL-CAPS: Capitalises only the first letter of the first word, lowercases
- *   the rest (respecting acronyms and ignored words).
- * — Title Case: Lowercases non-first words that are not acronyms / proper nouns.
+ * Splits a whitespace-delimited token into its leading punctuation, the bare
+ * word, and its trailing punctuation, so casing can be applied to the word
+ * without disturbing quotes/brackets/periods around it.  Only *surrounding*
+ * punctuation is peeled off, so a possessive stays whole: `USER'S` yields the
+ * single core `USER'S` rather than a `USER` word and a stray `'S`.
  */
-function buildSuggestionText(text, ignoredWordsSet) {
+function splitWordAffixes(raw) {
+    const lead = /^[^\w]*/.exec(raw)?.[0] ?? '';
+    const rest = raw.slice(lead.length);
+    const trail = /[^\w]*$/.exec(rest)?.[0] ?? '';
+    return { lead, core: rest.slice(0, rest.length - trail.length), trail };
+}
+/**
+ * Upper-cases the first alphabetic character, leaving any leading punctuation
+ * untouched so `(text` becomes `(Text` rather than staying lower-case.
+ */
+function capitalizeFirstLetter(text) {
+    const index = text.search(/[a-zA-Z]/);
+    if (index === -1)
+        return text;
+    return (text.slice(0, index) +
+        text.charAt(index).toUpperCase() +
+        text.slice(index + 1));
+}
+/**
+ * True when every letter in the token is upper-case (`USER'S`, `FORM`), which
+ * means lower-casing just the leading character would leave a shouting tail.
+ */
+function isAllUpperCase(text) {
+    const letters = text.replace(/[^a-zA-Z]/g, '');
+    return letters.length > 0 && letters === letters.toUpperCase();
+}
+/**
+ * Maps the lower-cased form of every ignored word to its canonical spelling so
+ * an ALL-CAPS occurrence (`GOOGLE`) can be restored to `Google` rather than
+ * flattened to `google`.
+ */
+function buildCanonicalIgnoredWords(ignoredWordsSet) {
+    const canonical = new Map();
+    ignoredWordsSet.forEach((word) => {
+        const key = word.toLowerCase();
+        if (!canonical.has(key))
+            canonical.set(key, word);
+    });
+    return canonical;
+}
+/**
+ * Builds the corrected text for an ALL-CAPS violation: the entire string is
+ * lower-cased and each sentence's first letter is capitalised.  Only words in
+ * the explicit acronym allowlist and ignored/proper nouns keep their casing —
+ * the length-based acronym heuristic cannot be used here because *every* token
+ * of an ALL-CAPS string looks like an acronym.
+ */
+function buildAllCapsSuggestionText(text, ignoredWordsSet) {
+    const canonicalIgnoredWords = buildCanonicalIgnoredWords(ignoredWordsSet);
+    return splitIntoSentences(text)
+        .map((sentence) => sentence
+        .split(/\s+/)
+        .map((raw, index) => {
+        const { lead, core, trail } = splitWordAffixes(raw);
+        if (!core)
+            return raw;
+        const canonical = canonicalIgnoredWords.get(core.toLowerCase());
+        if (canonical)
+            return `${lead}${canonical}${trail}`;
+        if (ACRONYM_ALLOWLIST.has(core))
+            return raw;
+        const lowered = core.toLowerCase();
+        const cased = index === 0 ? capitalizeFirstLetter(lowered) : lowered;
+        return `${lead}${cased}${trail}`;
+    })
+        .join(' '))
+        .join(' ');
+}
+/**
+ * Builds the corrected text for a Title Case violation: non-first words that
+ * are neither acronyms nor proper nouns are lower-cased.  Mixed-case tokens
+ * only lose their leading capital (`Name` → `name`) so intra-word casing such
+ * as `McDonald` survives, while shouting tokens (`CHANGES`) are lower-cased in
+ * full.
+ */
+function buildTitleCaseSuggestionText(text, ignoredWordsSet) {
     const sentences = splitIntoSentences(text);
     return sentences
         .map((sentence) => {
         const words = sentence.split(/\s+/);
         return words
             .map((raw, index) => {
-            const word = raw.replace(/^[^\w]+|[^\w]+$/g, '');
-            if (!word)
+            const { lead, core, trail } = splitWordAffixes(raw);
+            if (!core)
                 return raw;
-            if (index === 0) {
-                // Preserve ignored words in their original capitalisation; for all-caps
-                // first words, lower-case everything except the initial letter.
-                if (ignoredWordsSet.has(word))
-                    return raw;
-                if (isAcronymToken(word))
-                    return raw;
-                // Sentence-start: ensure first letter is capital
-                return raw.charAt(0).toUpperCase() + raw.slice(1).toLowerCase();
-            }
-            if (ignoredWordsSet.has(word))
+            // Proper nouns and acronyms keep their original capitalisation.
+            if (ignoredWordsSet.has(core))
                 return raw;
-            if (isAcronymToken(word))
+            if (isAcronymToken(core))
                 return raw;
-            // Non-first word: lower-case
-            return raw.charAt(0).toLowerCase() + raw.slice(1);
+            const lowered = isAllUpperCase(core)
+                ? core.toLowerCase()
+                : core.charAt(0).toLowerCase() + core.slice(1);
+            // Sentence-start: ensure the first letter is a capital.
+            const cased = index === 0 ? capitalizeFirstLetter(lowered) : lowered;
+            return `${lead}${cased}${trail}`;
         })
             .join(' ');
     })
         .join(' ');
 }
+/**
+ * Escape sequences for characters that cannot appear literally inside a
+ * JavaScript string literal.
+ */
+const JS_STRING_ESCAPES = new Map([
+    ['\\', '\\\\'],
+    ['\n', '\\n'],
+    ['\r', '\\r'],
+    ['\t', '\\t'],
+    ['\b', '\\b'],
+    ['\f', '\\f'],
+    ['\v', '\\v'],
+    ['\u2028', '\\u2028'],
+    ['\u2029', '\\u2029'],
+]);
+/**
+ * Escapes text for re-emission inside a JavaScript string literal delimited by
+ * `quote`.  Without this the rebuilt literal is unparseable as soon as the text
+ * contains the delimiter (`'THE USER\'S FILE'`), a backslash, or a line
+ * terminator.
+ */
+function escapeJsString(text, quote) {
+    let escaped = '';
+    for (let index = 0; index < text.length; index++) {
+        const char = text.charAt(index);
+        if (char === quote) {
+            escaped += `\\${char}`;
+            continue;
+        }
+        const mapped = JS_STRING_ESCAPES.get(char);
+        if (mapped) {
+            escaped += mapped;
+            continue;
+        }
+        if (char < ' ' || char === '\u007f') {
+            escaped += `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`;
+            continue;
+        }
+        escaped += char;
+    }
+    return escaped;
+}
+/**
+ * Escapes text for re-emission inside a JSX attribute string (`label="…"`).
+ * JSX attribute strings do not process backslash escapes, so the delimiter can
+ * only be represented as a character reference.  `&` is re-encoded because the
+ * value read off the AST has already been entity-decoded.
+ */
+function escapeJsxAttributeString(text, quote) {
+    const escaped = text.split('&').join('&amp;');
+    return quote === "'"
+        ? escaped.split("'").join('&#39;')
+        : escaped.split('"').join('&quot;');
+}
+/**
+ * Characters that change the meaning of JSX children and must therefore be
+ * written back as character references.  `JSXText.value` is entity-decoded, so
+ * emitting it verbatim can break parsing (`&lt;` → `<`) or silently turn text
+ * into an expression container (`&#123;x&#125;` → `{x}`).
+ */
+const JSX_TEXT_ENTITIES = new Map([
+    ['&', '&amp;'],
+    ['<', '&lt;'],
+    ['>', '&gt;'],
+    ['{', '&#123;'],
+    ['}', '&#125;'],
+]);
+function escapeJsxText(text) {
+    return text.replace(/[&<>{}]/g, (char) => JSX_TEXT_ENTITIES.get(char) ?? char);
+}
+/**
+ * Replaces the first occurrence of `search` without treating `$` sequences in
+ * the replacement as `String.prototype.replace` patterns.
+ */
+function replaceFirst(text, search, replacement) {
+    const index = text.indexOf(search);
+    if (index === -1)
+        return replacement;
+    return text.slice(0, index) + replacement + text.slice(index + search.length);
+}
 /**
  * Returns the trimmed text to check and whether it is worth checking.
  * JSXText nodes often contain only whitespace / newlines from formatting.
@@ -314,6 +465,35 @@ exports.enforceM3SentenceCase = (0, createRule_1.createRule)({
                 return true;
             return false;
         }
+        /**
+         * Produces the replacement source text for the reported node, re-escaping
+         * the suggestion for whichever literal form it is being written back into.
+         * Returns null when the node is not a rewritable literal.
+         */
+        function buildFixText(reportNode, checkable, suggestion) {
+            if (reportNode.type === utils_1.AST_NODE_TYPES.Literal) {
+                if (typeof reportNode.value !== 'string')
+                    return null;
+                const raw = context.getSourceCode().getText(reportNode);
+                const quote = raw.charAt(0);
+                // Template literals never reach here (they are skipped as dynamic), so
+                // only the two string-literal delimiters are rewritable.
+                if (quote !== '"' && quote !== "'")
+                    return null;
+                // Surrounding whitespace of the original value is preserved; only the
+                // trimmed, checked portion is re-cased.
+                const replaced = replaceFirst(reportNode.value, checkable, suggestion);
+                const inner = reportNode.parent?.type === utils_1.AST_NODE_TYPES.JSXAttribute
+                    ? escapeJsxAttributeString(replaced, quote)
+                    : escapeJsString(replaced, quote);
+                return `${quote}${inner}${quote}`;
+            }
+            if (reportNode.type === utils_1.AST_NODE_TYPES.JSXText) {
+                const replaced = replaceFirst(reportNode.value, checkable, suggestion);
+                return escapeJsxText(replaced);
+            }
+            return null;
+        }
         /**
          * Core checker.  Reports on `reportNode` if `text` violates M3 sentence case.
          */
@@ -325,7 +505,7 @@ exports.enforceM3SentenceCase = (0, createRule_1.createRule)({
                 return;
             // ALL-CAPS check first (higher severity and different fix)
             if (isAllCapsViolation(checkable, ignoredWordsSet)) {
-                const suggestion = buildSuggestionText(checkable, ignoredWordsSet);
+                const suggestion = buildAllCapsSuggestionText(checkable, ignoredWordsSet);
                 context.report({
                     node: reportNode,
                     messageId: 'allCaps',
@@ -335,17 +515,10 @@ exports.enforceM3SentenceCase = (0, createRule_1.createRule)({
                             messageId: 'allCaps',
                             data: { text: checkable, suggestion },
                             fix(fixer) {
-                                if (reportNode.type === utils_1.AST_NODE_TYPES.Literal) {
-                                    const raw = context.getSourceCode().getText(reportNode);
-                                    const quote = raw[0];
-                                    return fixer.replaceText(reportNode, `${quote}${suggestion}${quote}`);
-                                }
-                                if (reportNode.type === utils_1.AST_NODE_TYPES.JSXText) {
-                                    const original = reportNode.value;
-                                    const replaced = original.replace(checkable, suggestion);
-                                    return fixer.replaceText(reportNode, replaced);
-                                }
-                                return null;
+                                const fixText = buildFixText(reportNode, checkable, suggestion);
+                                return fixText === null
+                                    ? null
+                                    : fixer.replaceText(reportNode, fixText);
                             },
                         },
                     ],
@@ -359,7 +532,7 @@ exports.enforceM3SentenceCase = (0, createRule_1.createRule)({
                 violatingWords.push(...titleCaseViolatingWords(sentence, ignoredWordsSet));
             });
             if (violatingWords.length > 0) {
-                const suggestion = buildSuggestionText(checkable, ignoredWordsSet);
+                const suggestion = buildTitleCaseSuggestionText(checkable, ignoredWordsSet);
                 context.report({
                     node: reportNode,
                     messageId: 'titleCase',
@@ -369,17 +542,10 @@ exports.enforceM3SentenceCase = (0, createRule_1.createRule)({
                             messageId: 'titleCase',
                             data: { text: checkable, suggestion },
                             fix(fixer) {
-                                if (reportNode.type === utils_1.AST_NODE_TYPES.Literal) {
-                                    const raw = context.getSourceCode().getText(reportNode);
-                                    const quote = raw[0];
-                                    return fixer.replaceText(reportNode, `${quote}${suggestion}${quote}`);
-                                }
-                                if (reportNode.type === utils_1.AST_NODE_TYPES.JSXText) {
-                                    const original = reportNode.value;
-                                    const replaced = original.replace(checkable, suggestion);
-                                    return fixer.replaceText(reportNode, replaced);
-                                }
-                                return null;
+                                const fixText = buildFixText(reportNode, checkable, suggestion);
+                                return fixText === null
+                                    ? null
+                                    : fixer.replaceText(reportNode, fixText);
                             },
                         },
                     ],

package/lib/rules/enforce-props-naming-consistency.js

@@ -3,6 +3,84 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforcePropsNamingConsistency = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const renameFixes_1 = require("../utils/renameFixes");
+/**
+ * A body-less signature — an interface or object-type method member, or a
+ * `declare`/overload constructor — has no statements, so its parameter name is
+ * documentation-only and can never be referenced. A declaration-only rename is
+ * therefore complete rather than partial, and stays correct even though the
+ * scope analyzer models no variable for such a parameter.
+ */
+const isBodylessSignature = (owner) => owner.type === utils_1.AST_NODE_TYPES.TSMethodSignature ||
+    owner.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
+/**
+ * Finds the class (declaration or expression) that owns a method definition.
+ */
+const getEnclosingClass = (node) => {
+    const classBody = node.parent;
+    if (classBody?.type !== utils_1.AST_NODE_TYPES.ClassBody) {
+        return null;
+    }
+    const classNode = classBody.parent;
+    if (classNode?.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+        classNode?.type === utils_1.AST_NODE_TYPES.ClassExpression) {
+        return classNode;
+    }
+    return null;
+};
+/**
+ * Reports whether renaming a constructor parameter property is unsafe to
+ * autofix.
+ *
+ * A parameter property (`private readonly settings: FooProps`) declares BOTH a
+ * constructor-local binding and a `this.settings` class field. The scope
+ * analyzer only models the binding, so a scope-driven rename silently rewrites
+ * the field declaration while leaving every `this.settings` access — and every
+ * plain `settings` use the analyzer attributes elsewhere — pointing at a name
+ * that no longer exists (Issue #1358). Since the field half of the rename
+ * cannot be resolved through scope analysis, the fix is withheld whenever the
+ * name occurs anywhere in the class other than at its declaration.
+ */
+const parameterPropertyRenameIsUnsafe = (classNode, name, declarationId) => {
+    let unsafe = false;
+    const visit = (node) => {
+        if (unsafe) {
+            return;
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+            node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
+            node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.property.name === name) {
+            unsafe = true;
+            return;
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.name === name &&
+            node !== declarationId) {
+            unsafe = true;
+            return;
+        }
+        for (const key of Object.keys(node)) {
+            if (key === 'parent') {
+                continue;
+            }
+            const value = node[key];
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (ASTHelpers_1.ASTHelpers.isNode(child)) {
+                        visit(child);
+                    }
+                }
+            }
+            else if (ASTHelpers_1.ASTHelpers.isNode(value)) {
+                visit(value);
+            }
+        }
+    };
+    visit(classNode);
+    return unsafe;
+};
 exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
     name: 'enforce-props-naming-consistency',
     meta: {
@@ -51,9 +129,39 @@ exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
         function isPropsNameWithPrefix(paramName) {
             return paramName.endsWith('Props') || paramName === 'props';
         }
-        // Fix parameter name to "props"
-        function fixParameterName(fixer, param) {
-            return fixer.replaceText(param, 'props');
+        // Build the complete rename: the parameter declaration AND every in-file
+        // reference to it, rewriting only name tokens.
+        //
+        // `fixer.replaceText(param, 'props')` used to be the whole fix, which was
+        // wrong twice over: an `Identifier` range spans its optional marker and its
+        // type annotation, so replacing it deleted the very `: FooProps` annotation
+        // that triggered the report, and the body kept referencing the old name
+        // (Issue #1358). Returns null whenever the rename cannot be applied
+        // everywhere, so the report stands on its own instead of corrupting the
+        // source.
+        function buildParameterRenameFixes(fixer, owner, param) {
+            const sourceCode = context.getSourceCode();
+            // `getDeclaredVariables` on a function returns every parameter plus
+            // `arguments` and, for a declaration, the function's own name — and those
+            // can share a name (`function config(config: XProps)`), so the lookup
+            // matches on declaration identity instead of on the name.
+            const variable = context
+                .getDeclaredVariables(owner)
+                .find((candidate) => candidate.defs.some((def) => def.name === param)) ?? null;
+            if (!variable) {
+                if (!isBodylessSignature(owner)) {
+                    return null;
+                }
+                const declarationFix = (0, renameFixes_1.renameIdentifierToken)(fixer, sourceCode, param, 'props');
+                return declarationFix ? [declarationFix] : null;
+            }
+            return (0, renameFixes_1.buildVariableRenameFixes)({
+                fixer,
+                sourceCode,
+                variable,
+                declarationId: param,
+                newName: 'props',
+            });
         }
         // Check function parameters
         function checkFunctionParams(node) {
@@ -77,7 +185,7 @@ exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
                         node: param,
                         messageId: 'usePropsName',
                         data: { paramName: param.name },
-                        fix: (fixer) => fixParameterName(fixer, param),
+                        fix: (fixer) => buildParameterRenameFixes(fixer, node, param),
                     });
                 }
             }
@@ -109,6 +217,7 @@ exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
             if (propsTypeParams.length > 1) {
                 return; // Skip constructors with multiple Props parameters
             }
+            const enclosingClass = getEnclosingClass(node);
             for (const param of constructor.params) {
                 if (shouldBeNamedProps(param) &&
                     param.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -117,18 +226,28 @@ exports.enforcePropsNamingConsistency = (0, createRule_1.createRule)({
                         node: param,
                         messageId: 'usePropsName',
                         data: { paramName: param.name },
-                        fix: (fixer) => fixParameterName(fixer, param),
+                        fix: (fixer) => buildParameterRenameFixes(fixer, constructor, param),
                     });
                 }
                 else if (param.type === utils_1.AST_NODE_TYPES.TSParameterProperty &&
                     param.parameter.type === utils_1.AST_NODE_TYPES.Identifier &&
                     shouldBeNamedProps(param.parameter) &&
                     !isPropsNameWithPrefix(param.parameter.name)) {
+                    const declarationId = param.parameter;
                     context.report({
-                        node: param.parameter,
+                        node: declarationId,
                         messageId: 'usePropsName',
-                        data: { paramName: param.parameter.name },
-                        fix: (fixer) => fixParameterName(fixer, param.parameter),
+                        data: { paramName: declarationId.name },
+                        fix: (fixer) => {
+                            // A parameter property also declares a `this.<name>` field the
+                            // scope analyzer does not model, so renaming it is only safe
+                            // when the name appears nowhere else in the class.
+                            if (!enclosingClass ||
+                                parameterPropertyRenameIsUnsafe(enclosingClass, declarationId.name, declarationId)) {
+                                return null;
+                            }
+                            return buildParameterRenameFixes(fixer, constructor, declarationId);
+                        },
                     });
                 }
             }