@blumintinc/eslint-plugin-blumint 1.20.172 → 1.20.173

package/lib/index.js

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

package/lib/rules/enforce-assert-safe-object-key.js

@@ -652,8 +652,14 @@ function foldKeyDomains(domains) {
  * the key and its bracket splits that set in half. Claiming the access instead
  * leaves a competing rewrite of it either wholly discarded (and re-made against
  * the fixed text on a later pass) or wholly applied, both of which parse.
+ *
+ * `keyEnd` is where the written key ends once the parentheses around it are
+ * counted in, which is what the bracket closing a computed property is looked
+ * for after: in `{ [(id)]: value }` the token following the key itself is the
+ * `)`, and reading that as "no bracket here" would shrink the span back onto the
+ * key and leave the property's own brackets outside it.
  */
-function accessSpan(sourceCode, written) {
+function accessSpan(sourceCode, written, keyEnd = written) {
     const { parent } = written;
     if (!parent) {
         return null;
@@ -669,7 +675,7 @@ function accessSpan(sourceCode, written) {
         // A computed property's range runs past its key to the end of its value,
         // which the wrap has no business claiming; the bracket that closes the key
         // is where this access ends.
-        const closing = sourceCode.getTokenAfter(written);
+        const closing = sourceCode.getTokenAfter(keyEnd);
         return closing?.value === ']'
             ? [parent.range[0], closing.range[1]]
             : [written.range[0], written.range[1]];
@@ -681,6 +687,119 @@ function accessSpan(sourceCode, written) {
     }
     return null;
 }
+/**
+ * The grouping parentheses written around a key, innermost first.
+ *
+ * A pair is claimed only when both halves face the key at once, which is what
+ * keeps a parenthesis belonging to some enclosing construct out of the run: the
+ * `(` of `if (key in obj)` and of `read(key in obj)` is answered by the `in`
+ * keyword rather than by a `)`, so the walk stops before it.
+ *
+ * Anything other than whitespace between a parenthesis and what it encloses ends
+ * the walk too. That text is a comment, and dropping the parenthesis would move
+ * the comment out of the group the author wrote it inside — where a line comment
+ * decides what the lines after it may hold.
+ */
+function groupingParensAround(sourceCode, node) {
+    const pairs = [];
+    const { text } = sourceCode;
+    let innerStart = node.range[0];
+    let innerEnd = node.range[1];
+    let open = sourceCode.getTokenBefore(node);
+    let close = sourceCode.getTokenAfter(node);
+    while (open?.value === '(' && close?.value === ')') {
+        if (text.slice(open.range[1], innerStart).trim() !== '' ||
+            text.slice(innerEnd, close.range[0]).trim() !== '') {
+            break;
+        }
+        pairs.push({ open, close });
+        innerStart = open.range[0];
+        innerEnd = close.range[1];
+        open = sourceCode.getTokenBefore(open);
+        close = sourceCode.getTokenAfter(close);
+    }
+    return pairs;
+}
+/**
+ * Whether the parentheses the source wrote around a key can be dropped.
+ *
+ * The emission is a call, which is the tightest-binding expression there is, and
+ * every position that yields an access span takes one bare: between the brackets
+ * of a lookup or of a computed property, and as the left operand of `in`. So the
+ * pair is redundant the moment the key is wrapped, and prettier deletes it
+ * again — which is the whole defect (#2108).
+ *
+ * The one thing the parenthesis is doing is separating the key from the token
+ * before it. Dropping it where that token ends in an identifier character would
+ * fuse the two into one word, so the pair stays there.
+ */
+function dropsGroupingParens(text, span, outermost) {
+    const prefix = text.slice(span[0], outermost.open.range[0]);
+    const preceding = prefix === '' ? text.slice(Math.max(0, span[0] - 1), span[0]) : prefix;
+    return !/[\p{ID_Continue}$]$/u.test(preceding);
+}
+/**
+ * Prettier's default print width, which is what this repo and agora both format
+ * with. Wrapping a key widens the line it sits on, and a line the formatter
+ * would break is a line the formatter DOES break: agora runs prettier and
+ * `eslint --fix` over the same tree, so an emission past this width churns the
+ * file on every pass (#2108).
+ */
+const PRINT_WIDTH = 80;
+/** Prettier's default `tabWidth`, the step it indents a broken body by. */
+const INDENT_STEP = '  ';
+/**
+ * A `;` closing the rewritten line, optionally followed by same-line
+ * comments. Prettier leaves such comments where they are — after the `;` on
+ * the closing line — when it opens a lookup, so the emission may carry them
+ * (measured against prettier 2.8.8). A comment after a `,` is re-hosted
+ * BEFORE the comma instead, a relocation the emitter declines to model.
+ */
+const SEMICOLON_WITH_TRAILING_COMMENTS = /^;(?:\s*\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:\s*\/\/.*)?$/;
+/**
+ * Bodies prettier keeps on the arrow's own line instead of breaking after `=>`.
+ * Each of these opens a block of its own that absorbs the overflow, so a break
+ * inserted ahead of one is a layout prettier does not print.
+ */
+const HUGGED_ARROW_BODY_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.ArrayExpression,
+    utils_1.AST_NODE_TYPES.ObjectExpression,
+    utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
+    utils_1.AST_NODE_TYPES.TemplateLiteral,
+    utils_1.AST_NODE_TYPES.TaggedTemplateExpression,
+    utils_1.AST_NODE_TYPES.SequenceExpression,
+    utils_1.AST_NODE_TYPES.JSXElement,
+    utils_1.AST_NODE_TYPES.JSXFragment,
+]);
+/**
+ * Positions where a concise arrow body is laid out by the construct around it
+ * rather than by the arrow's own group: an argument list hugs its last argument
+ * and breaks the list first, and an arrow chain is printed as one unit. The
+ * accepted positions are the ones measured against prettier 2.8.8 — a
+ * declarator's initializer, a property or class-property value, an assignment's
+ * right-hand side, and a returned or thrown value.
+ */
+const BREAKABLE_ARROW_OWNER_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.VariableDeclarator,
+    utils_1.AST_NODE_TYPES.Property,
+    utils_1.AST_NODE_TYPES.PropertyDefinition,
+    utils_1.AST_NODE_TYPES.AssignmentExpression,
+    utils_1.AST_NODE_TYPES.ReturnStatement,
+]);
+/**
+ * The arrow function whose concise body holds the key, or null when the key
+ * sits somewhere the arrow's `=>` does not govern — in its parameters, in a
+ * block body, or in no arrow at all.
+ */
+function enclosingConciseArrow(node) {
+    let child = node;
+    let parent = node.parent;
+    while (parent && parent.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+        child = parent;
+        parent = parent.parent;
+    }
+    return parent && parent.body === child ? parent : null;
+}
 /**
  * An enum is a compiler-checked finite set. Members with literal initializers
  * enumerate their runtime key strings (which is what lets the forbidden-name
@@ -899,17 +1018,213 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
          * span (discarded whole, and re-made against the fixed text on the next
          * pass) or wholly outside it. Both parse. The re-emitted head and tail are
          * copied verbatim from the source, so the text this fix produces is
-         * character-for-character what replacing the key alone produced.
+         * character-for-character what replacing the key alone produced — bar the
+         * grouping parentheses `dropsGroupingParens` settles.
          */
-        const wrapKey = (fixer, node, argText) => {
-            const replacement = `assertSafe(${argText})`;
-            const span = accessSpan(context.sourceCode, node);
+        const planWrap = (node, argText) => {
+            const { sourceCode } = context;
+            const replacement = `${ASSERT_SAFE_NAME}(${argText})`;
+            const parens = groupingParensAround(sourceCode, node);
+            const outermost = parens[parens.length - 1];
+            const span = accessSpan(sourceCode, node, outermost?.close ?? node);
             if (!span) {
-                return fixer.replaceText(node, replacement);
+                return { range: [node.range[0], node.range[1]], text: replacement };
             }
             const [start, end] = span;
-            const { text } = context.sourceCode;
-            return fixer.replaceTextRange([start, end], `${text.slice(start, node.range[0])}${replacement}${text.slice(node.range[1], end)}`);
+            const { text } = sourceCode;
+            const edits = [
+                { range: [node.range[0], node.range[1]], text: replacement },
+            ];
+            if (outermost && dropsGroupingParens(text, span, outermost)) {
+                for (const pair of parens) {
+                    edits.push({ range: [pair.open.range[0], pair.open.range[1]], text: '' }, { range: [pair.close.range[0], pair.close.range[1]], text: '' });
+                }
+                edits.sort((left, right) => left.range[0] - right.range[0]);
+            }
+            let emitted = '';
+            let cursor = start;
+            for (const edit of edits) {
+                emitted += `${text.slice(cursor, edit.range[0])}${edit.text}`;
+                cursor = edit.range[1];
+            }
+            return {
+                range: [start, end],
+                text: `${emitted}${text.slice(cursor, end)}`,
+            };
+        };
+        /**
+         * The line break prettier prints after `=>` once the wrap has widened the
+         * arrow body past the print width, or null where this emitter cannot say
+         * what prettier would print.
+         *
+         * Prettier lays a concise arrow body out as `group(indent([line, body]))`,
+         * so the break after `=>` is the FIRST one it reaches for: a body that fits
+         * on the indented line is laid out exactly this way, and one that does not
+         * is broken further inside — which `planMemberBreak` prints for the one
+         * shape it has measured, and which this emitter otherwise declines rather
+         * than guesses at. Every other decline below is deliberate for the same
+         * reason — the one-line emission it falls back to is what shipped before
+         * the width was measured at all, so a decline costs formatting and never
+         * meaning.
+         */
+        const planArrowBreak = (node, wrap) => {
+            const { sourceCode } = context;
+            const { line } = node.loc.start;
+            const original = sourceCode.lines[line - 1] ?? '';
+            const delta = wrap.text.length - (wrap.range[1] - wrap.range[0]);
+            if (original.length + delta <= PRINT_WIDTH) {
+                return null;
+            }
+            // A span that already crosses lines carries the author's own breaks, so
+            // the single line measured above is not the whole of what moves.
+            if (wrap.text.includes('\n') ||
+                sourceCode.getLocFromIndex(wrap.range[0]).line !== line ||
+                sourceCode.getLocFromIndex(wrap.range[1]).line !== line) {
+                return null;
+            }
+            const arrow = enclosingConciseArrow(node);
+            const body = arrow?.body;
+            if (!arrow ||
+                !body ||
+                body.type === utils_1.AST_NODE_TYPES.BlockStatement ||
+                HUGGED_ARROW_BODY_TYPES.has(body.type) ||
+                !arrow.parent ||
+                !BREAKABLE_ARROW_OWNER_TYPES.has(arrow.parent.type)) {
+                return null;
+            }
+            const arrowToken = sourceCode.getTokenBefore(body);
+            if (arrowToken?.value !== '=>' ||
+                arrowToken.loc.end.line !== line ||
+                body.loc.start.line !== line ||
+                body.loc.end.line !== line ||
+                sourceCode.text.slice(arrowToken.range[1], body.range[0]).trim() !== '') {
+                return null;
+            }
+            // Prettier indents the body one step in from the line the arrow's own
+            // group opens on, which is the line its parameter list starts.
+            const anchor = sourceCode.lines[arrow.loc.start.line - 1] ?? '';
+            const bodyIndent = `${/^[\t ]*/.exec(anchor)?.[0] ?? ''}${INDENT_STEP}`;
+            const head = original.slice(0, arrowToken.loc.end.column).trimEnd();
+            const tail = original.slice(body.loc.start.column);
+            if (head.length > PRINT_WIDTH ||
+                bodyIndent.length + tail.length + delta > PRINT_WIDTH) {
+                return null;
+            }
+            return {
+                range: [arrowToken.range[1], body.range[0]],
+                text: `\n${bodyIndent}`,
+            };
+        };
+        /**
+         * The wrap re-emitted in the shape prettier prints a computed lookup in
+         * once the wrap has widened the line past the print width and the break
+         * after `=>` is already taken, or null where this emitter cannot say what
+         * prettier would print.
+         *
+         * Prettier lays a computed lookup out as `object[` + indent(softline +
+         * key) + softline + `]`, so a body that no longer fits on its own line is
+         * opened at the bracket with the key one step in; the call is then
+         * measured on that line and, where it does not fit there either, opened
+         * at its own parenthesis with the argument one step further in and a
+         * trailing comma. Both steps are measured against prettier 2.8.8 at
+         * agora's options, whose `trailingComma: "all"` is what puts the comma
+         * after the argument (#2134).
+         *
+         * The emission is limited to the shape measured: a single-line lookup
+         * that starts its line as the whole body of an arrow whose `=>` closes
+         * an earlier line, followed by the `;` or `,` that ends the statement or
+         * the element — a `;` optionally carrying same-line comments. Anything
+         * else — a key the author
+         * parenthesized or commented, a lookup broken across lines, a key so long
+         * that even its own line overflows — falls back to the one-line emission,
+         * which is what shipped before the width was measured at all.
+         */
+        const planMemberBreak = (node, wrap, argText) => {
+            const { sourceCode } = context;
+            const { text } = sourceCode;
+            const { line } = node.loc.start;
+            const original = sourceCode.lines[line - 1] ?? '';
+            const delta = wrap.text.length - (wrap.range[1] - wrap.range[0]);
+            if (original.length + delta <= PRINT_WIDTH) {
+                return null;
+            }
+            const member = node.parent;
+            if (!member ||
+                member.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                !member.computed ||
+                member.property !== node ||
+                wrap.range[0] !== member.range[0] ||
+                wrap.range[1] !== member.range[1] ||
+                wrap.text.includes('\n') ||
+                member.loc.start.line !== line ||
+                member.loc.end.line !== line ||
+                groupingParensAround(sourceCode, node).length > 0 ||
+                sourceCode.getCommentsInside(member).length > 0) {
+                return null;
+            }
+            const arrow = enclosingConciseArrow(node);
+            const body = arrow?.body;
+            // An optional chain wraps the lookup in a ChainExpression of the same
+            // extent, so the body is the lookup either way.
+            const bodyIsLookup = body === member ||
+                (body?.type === utils_1.AST_NODE_TYPES.ChainExpression &&
+                    body.expression === member);
+            const arrowToken = sourceCode.getTokenBefore(member);
+            if (!arrow ||
+                !bodyIsLookup ||
+                arrowToken?.value !== '=>' ||
+                arrowToken.loc.end.line >= line) {
+                return null;
+            }
+            // A comment on a line of its own between `=>` and the body stays on
+            // that line and leaves the body's layout untouched, so it is carried;
+            // one that shares the arrow's line is text prettier relocates into the
+            // parameter list, which this emitter does not model.
+            const gapComments = sourceCode.getTokensBetween(arrowToken, member, {
+                includeComments: true,
+            });
+            if (gapComments.some((comment) => comment.loc.start.line <= arrowToken.loc.end.line)) {
+                return null;
+            }
+            const openBracket = sourceCode.getTokenBefore(node);
+            const closeBracket = sourceCode.getLastToken(member);
+            if (openBracket?.value !== '[' ||
+                closeBracket?.value !== ']' ||
+                text.slice(openBracket.range[1], node.range[0]) !== '' ||
+                text.slice(node.range[1], closeBracket.range[0]) !== '') {
+                return null;
+            }
+            const indent = original.slice(0, member.loc.start.column);
+            const tail = original.slice(member.loc.end.column);
+            const isBreakableTail = tail === ';' ||
+                tail === ',' ||
+                SEMICOLON_WITH_TRAILING_COMMENTS.test(tail);
+            if (indent.trim() !== '' || !isBreakableTail) {
+                return null;
+            }
+            // Everything through the bracket — `m[`, `s.map[`, `m?.[`, `m[a][` —
+            // stays on the body's line; prettier opens only the outermost lookup.
+            const head = text.slice(member.range[0], openBracket.range[1]);
+            if (indent.length + head.length > PRINT_WIDTH) {
+                return null;
+            }
+            const keyIndent = `${indent}${INDENT_STEP}`;
+            const argIndent = `${keyIndent}${INDENT_STEP}`;
+            const call = `${ASSERT_SAFE_NAME}(${argText})`;
+            let key;
+            if (keyIndent.length + call.length <= PRINT_WIDTH) {
+                key = `${keyIndent}${call}`;
+            }
+            else if (argIndent.length + argText.length + 1 <= PRINT_WIDTH) {
+                key = `${keyIndent}${ASSERT_SAFE_NAME}(\n${argIndent}${argText},\n${keyIndent})`;
+            }
+            else {
+                return null;
+            }
+            return {
+                range: [member.range[0], member.range[1]],
+                text: `${head}\n${key}\n${indent}]`,
+            };
         };
         /**
          * Helper function to create fixes for a node
@@ -921,7 +1236,15 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                 fixes.push(addAssertSafeImport(fixer));
                 importClaimed = true;
             }
-            fixes.push(wrapKey(fixer, node, argText));
+            const wrap = planWrap(node, argText);
+            const arrowBreak = planArrowBreak(node, wrap);
+            if (arrowBreak) {
+                fixes.push(fixer.replaceTextRange(arrowBreak.range, arrowBreak.text));
+            }
+            const access = arrowBreak
+                ? wrap
+                : planMemberBreak(node, wrap, argText) ?? wrap;
+            fixes.push(fixer.replaceTextRange(access.range, access.text));
             return fixes;
         };
         // The report is emitted even when suppressed: ESLint discards it, and