@blumintinc/eslint-plugin-blumint 1.20.142 → 1.20.144

package/lib/index.js

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

package/lib/rules/enforce-centralized-mock-firestore.js

@@ -338,27 +338,6 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                     }
                 }
             },
-            // Handle dynamic imports
-            'AwaitExpression > CallExpression[callee.type="ImportExpression"]'(node) {
-                const parent = node.parent;
-                if (parent?.type === utils_1.AST_NODE_TYPES.AwaitExpression &&
-                    parent.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                    parent.parent.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
-                    for (const prop of parent.parent.id.properties) {
-                        if (prop.type === utils_1.AST_NODE_TYPES.Property &&
-                            prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            prop.key.name === 'mockFirestore') {
-                            mockFirestoreNodes.add(parent.parent);
-                            // Track renamed destructured imports
-                            if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                prop.value.name !== 'mockFirestore') {
-                                customMockFirestoreNames.add(prop.value.name);
-                            }
-                            break;
-                        }
-                    }
-                }
-            },
             // Handle complex object destructuring
             'ObjectPattern > Property > ObjectPattern > Property > ObjectPattern > Property[key.name="mockFirestore"]'(node) {
                 let current = node;

package/lib/rules/no-redundant-annotation-assertion.js

@@ -28,6 +28,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const visitor_keys_1 = require("@typescript-eslint/visitor-keys");
 const ts = __importStar(require("typescript"));
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const arrowAnnotationGap_1 = require("../utils/arrowAnnotationGap");
 const createRule_1 = require("../utils/createRule");
 const disableDirectives_1 = require("../utils/disableDirectives");
 const importRemoval_1 = require("../utils/importRemoval");
@@ -864,7 +865,7 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
          * trading an unused import for a dangling type.
          */
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
-        function collectIfRedundant(annotation, assertion, reportNode, fixerTarget) {
+        function collectIfRedundant(annotation, assertion, reportNode, fixerTarget, arrowReturnType) {
             const matchingType = haveMatchingTypes(annotation.typeAnnotation, assertion, checker, parserServices);
             if (!matchingType)
                 return null;
@@ -872,6 +873,7 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
                 reportNode,
                 removal: annotationRemovalRange(fixerTarget, sourceCode),
                 matchingType,
+                arrowReturnType,
             };
             sites.push(site);
             return site;
@@ -890,25 +892,54 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
             // Whether the annotation is load-bearing is decided at `Program:exit`:
             // the cycle can run through a function elsewhere in the file, and every
             // annotation in it goes in the same batched fix.
-            const site = collectIfRedundant(annotation, assertionSite.assertion, reportNode, annotation);
+            const site = collectIfRedundant(annotation, assertionSite.assertion, reportNode, annotation, node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression
+                ? annotation
+                : undefined);
             if (site)
                 returnCandidates.push({ site, owners, references });
         }
+        /**
+         * The text a site's removal writes in place of the annotation.
+         *
+         * An arrow's annotation is the one that cannot simply be deleted: its slice
+         * sits inside a restricted production, so a comment left in the gap — or
+         * stranded there by the deletion — turns the output into a SyntaxError that
+         * only a compiler reports (#1969). Every other subject ends its signature at
+         * a body or a separator, so its slice is deleted exactly as before.
+         */
+        function planEdits(site) {
+            if (!site.arrowReturnType) {
+                return [{ range: site.removal, text: '' }];
+            }
+            return (0, arrowAnnotationGap_1.planArrowAnnotationEdits)(sourceCode, site.arrowReturnType, site.removal);
+        }
         /**
          * The sites whose fixes actually ship. A site is excluded when its report
-         * will be suppressed, or when its own removal orphans something the helper
-         * cannot rewrite — a local alias, an interface, a type parameter. Deleting a
-         * declaration is a materially riskier edit than dropping an import
-         * specifier, and the author is better placed to decide whether the type
-         * should go or be used elsewhere.
+         * will be suppressed, when its own removal orphans something the helper
+         * cannot rewrite — a local alias, an interface, a type parameter — or when
+         * its edits cannot be planned without moving a comment whose meaning is its
+         * position. Deleting a declaration is a materially riskier edit than
+         * dropping an import specifier, and the author is better placed to decide
+         * whether the type should go or be used elsewhere.
          *
          * Screening individually before batching keeps one unfixable site from
          * vetoing the rest: orphanhood grows monotonically with the removed set, so
          * a site that cannot be planned alone can only ever poison the batch.
          */
         function selectFixableSites(candidates) {
-            return candidates.filter((site) => !isReportSuppressed(site.reportNode) &&
-                (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [site.removal]) !== null);
+            const fixable = [];
+            for (const site of candidates) {
+                if (isReportSuppressed(site.reportNode))
+                    continue;
+                if ((0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [site.removal]) === null) {
+                    continue;
+                }
+                const edits = planEdits(site);
+                if (edits === null)
+                    continue;
+                fixable.push({ site, edits });
+            }
+            return fixable;
         }
         /**
          * The file's inference graph, built only where a return annotation is at
@@ -936,27 +967,33 @@ exports.noRedundantAnnotationAssertion = (0, createRule_1.createRule)({
                 if (reportable.length === 0)
                     return;
                 const fixable = selectFixableSites(reportable);
-                const removals = fixable.map((site) => site.removal);
+                const removals = fixable.map((entry) => entry.site.removal);
                 // One plan over every surviving removal: an import referenced solely by
                 // annotations that all go in this pass is orphaned by their union, even
                 // though no single one of them orphans it.
                 const importRanges = removals.length > 0
                     ? (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, removals)
                     : null;
+                // The batch rewrites some spans rather than deleting them, and ships as
+                // one fix: ESLint rejects a fix whose edits overlap, so an overlap
+                // withdraws the fix instead of throwing at apply time. Only a wrong
+                // premise can produce one — an annotation's gap and an import
+                // declaration are disjoint regions of the file.
+                const edits = [
+                    ...fixable.flatMap((entry) => entry.edits),
+                    ...(importRanges ?? []).map((range) => ({ range, text: '' })),
+                ];
                 // The whole batch ships as one fix, so no removal can land without the
                 // others that the import's orphanhood was judged against. The rest
                 // report without a fixer; the carrier's pass already resolves them.
-                const carrier = importRanges ? fixable[0] : undefined;
+                const carrier = importRanges && (0, arrowAnnotationGap_1.isDisjoint)(edits) ? fixable[0]?.site : undefined;
                 for (const site of reportable) {
                     context.report({
                         node: site.reportNode,
                         messageId: 'redundantAnnotationAndAssertion',
                         data: { type: site.matchingType },
-                        fix: site === carrier && importRanges
-                            ? (fixer) => [
-                                ...removals.map((range) => fixer.removeRange([range[0], range[1]])),
-                                ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
-                            ]
+                        fix: site === carrier
+                            ? (fixer) => edits.map((edit) => fixer.replaceTextRange([edit.range[0], edit.range[1]], edit.text))
                             : null,
                     });
                 }

package/lib/rules/prefer-sx-prop-over-system-props.js

@@ -146,20 +146,37 @@ const DEFAULT_MUI_COMPONENTS = new Set([
     'Toolbar',
 ]);
 /**
- * Components whose public prop API defines `color` as a closed semantic enum
- * (a palette / variant selector like `'primary' | 'secondary' | 'error' | …`),
- * not a CSS-forwarded system style prop. On these, `color` feeds
- * `ownerState.color`, selecting theme variants and MUI's internal
- * `.Mui*-color*` class selectors — moving it into `sx` both drops the variant
- * selection and produces an invalid CSS `color` value. So `color` here is a
- * first-class component prop, never a deprecated system prop.
+ * Props a component declares as its own first-class API, keyed by the
+ * (component, prop) pair. Each name below collides with a system prop, but the
+ * component *consumes* it — feeding `ownerState`, selecting a theme value and
+ * MUI's internal `.Mui*-*` class selectors — instead of forwarding it as CSS.
+ * The system-prop reading is therefore wrong for the pair whatever value is
+ * written, and moving the prop into `sx` emits a declaration whose value is not
+ * a CSS value for that property: the browser drops it, so the fix type-checks
+ * (`SxProps` accepts `string | number`), lints clean, and silently loses the
+ * styling.
+ *
+ * The keying has to be per pair, not per prop name: the same name is a genuine
+ * system prop elsewhere (`color` on `Typography`, `maxWidth` on `Box`), so
+ * exempting the bare name would blind the rule on every other component.
  */
-const COMPONENT_COLOR_IS_SEMANTIC = new Set([
-    'Button',
-    'IconButton',
-    'Chip',
-    'Badge',
+const COMPONENT_OWN_PROPS = new Map([
+    // `color` is a closed palette/variant selector (`'primary' | 'error' | …`)
+    // on these — never a CSS color (#1273). On `AppBar` it picks the *background*
+    // shade, so the system-prop reading also targets the wrong CSS property.
+    ['Button', new Set(['color'])],
+    ['IconButton', new Set(['color'])],
+    ['Chip', new Set(['color'])],
+    ['Badge', new Set(['color'])],
+    ['AppBar', new Set(['color'])],
+    // `maxWidth` is a breakpoint KEY (`'xs' | … | 'xl' | false`) that selects a
+    // width from `theme.breakpoints.values` and drives the `maxWidth*` class
+    // (#1966). As CSS, `max-width: xl` is invalid and the element unbounds.
+    ['Container', new Set(['maxWidth'])],
+    ['Dialog', new Set(['maxWidth'])],
 ]);
+/** True when `propName` belongs to `componentName`'s own prop API. */
+const componentOwnsProp = (componentName, propName) => COMPONENT_OWN_PROPS.get(componentName)?.has(propName) === true;
 /**
  * Props that must never be moved to `sx` because they are genuine component
  * API props, not MUI system styling shorthands. `direction` and `spacing` are
@@ -782,10 +799,10 @@ exports.preferSxPropOverSystemProps = (0, createRule_1.createRule)({
             return false;
         }
         function isSystemProp(name, componentName) {
-            // `color` is a semantic enum prop (not a CSS system prop) on components
-            // like Button/IconButton/Chip/Badge — exempt it there so the autofix
-            // never rewrites a variant selector into an invalid CSS color.
-            if (name === 'color' && COMPONENT_COLOR_IS_SEMANTIC.has(componentName)) {
+            // A prop the component owns is never the system prop of the same name, so
+            // the autofix must not rewrite it into a CSS declaration the browser
+            // discards.
+            if (componentOwnsProp(componentName, name)) {
                 return false;
             }
             return MUI_SYSTEM_PROPS.has(name) && !isAllowedProp(name);

package/lib/utils/arrowAnnotationGap.d.ts

@@ -0,0 +1,72 @@
+import { TSESLint, TSESTree } from '@typescript-eslint/utils';
+import { TextRange } from './importRemoval';
+/**
+ * The span between an arrow function's parameter list and its `=>` is the one
+ * place a return-type annotation sits inside a restricted production:
+ * `ArrowParameters [no LineTerminator here] =>` forbids a line terminator
+ * there, and the syntactic grammar counts a block comment carrying a line
+ * terminator AS one. Stripping the annotation and leaving such a comment behind
+ * therefore emits a hard SyntaxError (TS1200 / V8 `Unexpected token '=>'`) —
+ * which `@typescript-eslint/parser` accepts, so no reparse-based guard sees it
+ * (#1964, #1969).
+ *
+ * Every other subject an annotation can hang off — a function declaration, a
+ * method, a class property with a body, a plain binding — ends its signature at
+ * a body or a separator, so nothing about the comments around it is restricted
+ * and a plain deletion stays correct.
+ */
+/** One span of a fix, and the text that replaces it. */
+export type Edit = {
+    range: TextRange;
+    text: string;
+};
+/**
+ * A comment whose meaning is tied to where it sits. Re-emitting one somewhere
+ * else retargets it — a disable directive lands on an unrelated line and a
+ * `@ts-expect-error` becomes an error of its own — so a rewrite that would move
+ * one is withheld instead.
+ */
+export declare function isPositionalDirective(comment: TSESTree.Comment): boolean;
+/** The indentation of the line `offset` sits on, for a carried line break. */
+export declare function indentAt(source: TSESLint.SourceCode, offset: number): string;
+/**
+ * The span an arrow's return annotation occupies between the parameter list and
+ * the `=>`, together with that arrow token.
+ *
+ * The span holds the annotation, whitespace and comments and nothing else,
+ * which is what makes it safe to rewrite wholesale: no binding reference can
+ * hide in it beyond the ones the annotation itself names.
+ */
+export declare function arrowAnnotationGap(source: TSESLint.SourceCode, returnType: TSESTree.TSTypeAnnotation): {
+    gap: TextRange;
+    arrow: TSESTree.Token;
+} | null;
+/**
+ * The edits that strip an arrow function's return annotation without leaving a
+ * line terminator in the restricted gap, carrying every comment the strip
+ * strands rather than deleting it (#1877).
+ *
+ * `removal` is the span the calling rule would otherwise delete: it covers the
+ * annotation and may reach further back over the horizontal whitespace ahead of
+ * the `:`. It must lie inside the gap, which it does for any annotation the
+ * caller located on the arrow itself.
+ *
+ * A comment that must own a line is re-emitted past the `=>`, the nearest
+ * position outside the restricted gap that cannot itself begin one; hoisting it
+ * above the enclosing line would anchor an insertion at a column zero that may
+ * sit inside a template literal or JSX text, where the comment would become
+ * content rather than code. A comment that trips no restricted production stays
+ * exactly where it was written, since moving comments gratuitously is its own
+ * regression.
+ *
+ * `null` withholds the fix, for a comment whose meaning is its position and
+ * which cannot stay where it is.
+ */
+export declare function planArrowAnnotationEdits(source: TSESLint.SourceCode, returnType: TSESTree.TSTypeAnnotation, removal: TextRange): Edit[] | null;
+/**
+ * ESLint applies a fix whole or not at all, and rejects one whose edits
+ * overlap. Spans planned independently — several annotations, and the bindings
+ * their removal orphans — can only overlap if a premise behind them is wrong,
+ * so an overlap withdraws the fix rather than throwing at apply time.
+ */
+export declare function isDisjoint(edits: readonly Edit[]): boolean;

package/lib/utils/arrowAnnotationGap.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDisjoint = exports.planArrowAnnotationEdits = exports.arrowAnnotationGap = exports.indentAt = exports.isPositionalDirective = void 0;
+const disableDirectives_1 = require("./disableDirectives");
+const replacementSegments_1 = require("./replacementSegments");
+/** Every character the syntactic grammar counts as a LineTerminator. */
+const LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
+function containsRange(outer, inner) {
+    return inner[0] >= outer[0] && inner[1] <= outer[1];
+}
+const textOf = (source, range) => source.text.slice(range[0], range[1]);
+/**
+ * A comment whose meaning is tied to where it sits. Re-emitting one somewhere
+ * else retargets it — a disable directive lands on an unrelated line and a
+ * `@ts-expect-error` becomes an error of its own — so a rewrite that would move
+ * one is withheld instead.
+ */
+function isPositionalDirective(comment) {
+    if ((0, disableDirectives_1.parseDisableDirectives)([comment]).length > 0) {
+        return true;
+    }
+    const value = comment.value.trim();
+    return value.startsWith('@ts-expect-error') || value.startsWith('@ts-ignore');
+}
+exports.isPositionalDirective = isPositionalDirective;
+/** The indentation of the line `offset` sits on, for a carried line break. */
+function indentAt(source, offset) {
+    const lineStart = source.text.lastIndexOf('\n', offset - 1) + 1;
+    const [indent] = /^[ \t]*/.exec(source.text.slice(lineStart, offset)) ?? [''];
+    return indent;
+}
+exports.indentAt = indentAt;
+/**
+ * The span an arrow's return annotation occupies between the parameter list and
+ * the `=>`, together with that arrow token.
+ *
+ * The span holds the annotation, whitespace and comments and nothing else,
+ * which is what makes it safe to rewrite wholesale: no binding reference can
+ * hide in it beyond the ones the annotation itself names.
+ */
+function arrowAnnotationGap(source, returnType) {
+    const parametersEnd = source.getTokenBefore(returnType);
+    const arrow = source.getTokenAfter(returnType, {
+        filter: (token) => token.value === '=>',
+    });
+    if (!parametersEnd || !arrow)
+        return null;
+    const gap = [parametersEnd.range[1], arrow.range[0]];
+    return containsRange(gap, returnType.range) ? { gap, arrow } : null;
+}
+exports.arrowAnnotationGap = arrowAnnotationGap;
+/**
+ * Re-emits `comments` on the far side of the arrow, where a line terminator is
+ * inert, consuming the horizontal whitespace the arrow already had after it so
+ * the body keeps a single separator.
+ */
+function hoistPastArrow(source, arrow, comments) {
+    const indent = indentAt(source, arrow.range[0]);
+    const trailingText = source.text.slice(arrow.range[1]);
+    const [spacing] = /^[ \t]*/.exec(trailingText) ?? [''];
+    const body = (0, replacementSegments_1.joinSegmentBody)(comments.map((comment) => ({
+        text: textOf(source, comment.range),
+        breakAfter: true,
+    })), indent);
+    const rest = trailingText.slice(spacing.length);
+    const separator = LINE_TERMINATOR.test(rest.charAt(0))
+        ? ''
+        : (0, replacementSegments_1.requiresLineBreakAfter)(comments[comments.length - 1])
+            ? `\n${indent}`
+            : ' ';
+    return {
+        range: [arrow.range[1], arrow.range[1] + spacing.length],
+        text: ` ${body}${separator}`,
+    };
+}
+/**
+ * The edits that strip an arrow function's return annotation without leaving a
+ * line terminator in the restricted gap, carrying every comment the strip
+ * strands rather than deleting it (#1877).
+ *
+ * `removal` is the span the calling rule would otherwise delete: it covers the
+ * annotation and may reach further back over the horizontal whitespace ahead of
+ * the `:`. It must lie inside the gap, which it does for any annotation the
+ * caller located on the arrow itself.
+ *
+ * A comment that must own a line is re-emitted past the `=>`, the nearest
+ * position outside the restricted gap that cannot itself begin one; hoisting it
+ * above the enclosing line would anchor an insertion at a column zero that may
+ * sit inside a template literal or JSX text, where the comment would become
+ * content rather than code. A comment that trips no restricted production stays
+ * exactly where it was written, since moving comments gratuitously is its own
+ * regression.
+ *
+ * `null` withholds the fix, for a comment whose meaning is its position and
+ * which cannot stay where it is.
+ */
+function planArrowAnnotationEdits(source, returnType, removal) {
+    const gapInfo = arrowAnnotationGap(source, returnType);
+    if (!gapInfo)
+        return null;
+    const { gap, arrow } = gapInfo;
+    if (!containsRange(gap, removal))
+        return null;
+    const comments = source
+        .getAllComments()
+        .filter((comment) => containsRange(gap, comment.range));
+    const stranded = comments.filter((comment) => containsRange(removal, comment.range));
+    // What the plain deletion would leave between the parameters and the arrow.
+    // A comment left there contributes its own text, so a line comment or a
+    // multi-line block comment shows up here as the line terminator it is.
+    const residue = `${textOf(source, [gap[0], removal[0]])}${textOf(source, [
+        removal[1],
+        gap[1],
+    ])}`;
+    // The plain deletion is kept wherever it already lands a legal gap and
+    // strands nothing, so no output that survives today moves by a byte.
+    if (stranded.length === 0 && !LINE_TERMINATOR.test(residue)) {
+        return [{ range: removal, text: '' }];
+    }
+    // Rewriting the gap collapses the lines it spanned, which moves the line a
+    // directive inside it points at, so the whole fix is withheld rather than
+    // retargeting one. The gap a directive can share with nothing else is left
+    // untouched by the branch above.
+    if (comments.some(isPositionalDirective))
+        return null;
+    const hoisted = comments.filter(replacementSegments_1.requiresOwnLine);
+    const inline = comments
+        .filter((comment) => !(0, replacementSegments_1.requiresOwnLine)(comment))
+        .map((comment) => textOf(source, comment.range));
+    const edits = [
+        { range: gap, text: inline.length === 0 ? ' ' : ` ${inline.join(' ')} ` },
+    ];
+    if (hoisted.length > 0) {
+        edits.push(hoistPastArrow(source, arrow, hoisted));
+    }
+    return edits;
+}
+exports.planArrowAnnotationEdits = planArrowAnnotationEdits;
+/**
+ * ESLint applies a fix whole or not at all, and rejects one whose edits
+ * overlap. Spans planned independently — several annotations, and the bindings
+ * their removal orphans — can only overlap if a premise behind them is wrong,
+ * so an overlap withdraws the fix rather than throwing at apply time.
+ */
+function isDisjoint(edits) {
+    const sorted = [...edits].sort((left, right) => left.range[0] - right.range[0]);
+    return sorted.every((edit, index) => index === 0 || sorted[index - 1].range[1] <= edit.range[0]);
+}
+exports.isDisjoint = isDisjoint;
+//# sourceMappingURL=arrowAnnotationGap.js.map

package/lib/utils/restrictedProductions.d.ts

@@ -0,0 +1,45 @@
+export type RestrictedProduction = 'arrow' | 'throw';
+export type RestrictedBreach = {
+    production: RestrictedProduction;
+    /** 1-indexed line of the token that closes the gap. */
+    line: number;
+    /** The offending text between the two tokens, comments included. */
+    gap: string;
+};
+type Token = {
+    type: string;
+    value: string;
+    range: [number, number];
+};
+type Node = {
+    type: string;
+    range: [number, number];
+} & Record<string, unknown>;
+type ParsedSource = {
+    ast: Node;
+    tokens: Token[];
+} | null;
+/**
+ * `.ts` and `.tsx` are not ordered by permissiveness — only `.ts` accepts
+ * `<T>expr` and only `.tsx` accepts JSX — so a snippet is tried both ways rather
+ * than parsed under a guessed extension. A snippet that parses under neither is
+ * `null`: unparsable text is `fixture-corpus-parsability`'s axis, and reporting
+ * it here would double-count it.
+ */
+export declare function parseForRestrictedProductions(code: string): ParsedSource;
+/**
+ * Every restricted-production breach in `code`, or `null` when it does not parse
+ * at all.
+ *
+ * The gap is measured between TOKENS, so the text it spans is whitespace and
+ * comments and nothing else. That is what makes a block comment carrying a line
+ * terminator indistinguishable from a raw newline here — which is the whole
+ * point, since it is indistinguishable to the grammar too.
+ */
+export declare function restrictedProductionBreaches(code: string): RestrictedBreach[] | null;
+/**
+ * The non-comment token stream, used to prove a planted comment changed nothing
+ * but comments. `null` when the text does not parse.
+ */
+export declare function tokenSignatureOf(code: string): string | null;
+export {};

package/lib/utils/restrictedProductions.js

@@ -0,0 +1,233 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenSignatureOf = exports.restrictedProductionBreaches = exports.parseForRestrictedProductions = void 0;
+const tsParser = __importStar(require("@typescript-eslint/parser"));
+/**
+ * Restricted productions: the places the ECMAScript grammar forbids a
+ * LineTerminator, and where `@typescript-eslint/parser` accepts one anyway.
+ *
+ * A fixer that leaves — or carries — a line break into one of these gaps emits
+ * text no engine will run, and NOTHING else in this repo's pipeline says so.
+ * Every parse-based guard (`fixture-corpus-parsability`, `fix-fixpoint-closure`'s
+ * fatal check, `fix-orphan-binding-closure`'s `message.fatal` gate, the agora
+ * `fix: true` sweep) reads the broken text as clean, because the parser they all
+ * share is the one that accepts it. #1964 shipped through every one of them.
+ *
+ * WHICH productions belong here is MEASURED, not copied from the spec. The
+ * grammar lists seven; only two are detectable here, because for the rest
+ * `@typescript-eslint/parser` already agrees with V8:
+ *
+ *   | production                 | parser  | V8      | detectable here     |
+ *   | -------------------------- | ------- | ------- | ------------------- |
+ *   | `ArrowParameters [] =>`    | accepts | rejects | YES                 |
+ *   | `throw []`                 | accepts | rejects | YES                 |
+ *   | `async [] (params) =>`     | rejects | rejects | no — parser sees it |
+ *   | `async [] method()`        | rejects | rejects | no — parser sees it |
+ *   | `yield [] *`               | rejects | rejects | no — parser sees it |
+ *   | postfix `++` / `--`        | rejects | rejects | no — parser sees it |
+ *   | `return` / `yield` / label | ASI     | ASI     | no — both insert `;` |
+ *
+ * The last row is the one worth stating plainly: for `return`, `yield`,
+ * `break`/`continue` with a label and `async function`, the parser applies
+ * automatic semicolon insertion exactly as V8 does, so the two never disagree
+ * and there is no divergence to detect. The rows the parser rejects are already
+ * fatal to every parse-based guard, so they need no help from this module.
+ *
+ * `src/tests/restricted-production-closure.test.ts` re-measures that table on
+ * every run: an arm that stops being redundant (a parser upgrade turning a
+ * "rejects" into an "accepts") fails there rather than silently going unchecked.
+ */
+/**
+ * Every character the syntactic grammar counts as a LineTerminator, by code
+ * point rather than as a regular expression: U+2028 and U+2029 terminate a line
+ * in JavaScript SOURCE too, so a literal holding them cannot be written here
+ * without breaking this file.
+ */
+const LINE_TERMINATOR_CODES = new Set([0x0a, 0x0d, 0x2028, 0x2029]);
+const hasLineTerminator = (text) => {
+    for (let index = 0; index < text.length; index++) {
+        if (LINE_TERMINATOR_CODES.has(text.charCodeAt(index)))
+            return true;
+    }
+    return false;
+};
+const PARSE_OPTIONS = {
+    ecmaVersion: 2022,
+    sourceType: 'module',
+    range: true,
+    loc: true,
+    comment: true,
+    tokens: true,
+};
+/**
+ * `.ts` and `.tsx` are not ordered by permissiveness — only `.ts` accepts
+ * `<T>expr` and only `.tsx` accepts JSX — so a snippet is tried both ways rather
+ * than parsed under a guessed extension. A snippet that parses under neither is
+ * `null`: unparsable text is `fixture-corpus-parsability`'s axis, and reporting
+ * it here would double-count it.
+ */
+function parseForRestrictedProductions(code) {
+    for (const jsx of [true, false]) {
+        try {
+            const ast = tsParser.parse(code, {
+                ...PARSE_OPTIONS,
+                ecmaFeatures: { jsx },
+            });
+            if (ast.tokens)
+                return { ast, tokens: ast.tokens };
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+exports.parseForRestrictedProductions = parseForRestrictedProductions;
+function visit(node, callback) {
+    if (!node || typeof node !== 'object')
+        return;
+    const record = node;
+    if (typeof record.type === 'string' && Array.isArray(record.range)) {
+        callback(record);
+    }
+    for (const [key, value] of Object.entries(record)) {
+        // `parent` is a back-edge on some node shapes and would loop forever.
+        if (key === 'parent')
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                visit(item, callback);
+        }
+        else if (value && typeof value === 'object') {
+            visit(value, callback);
+        }
+    }
+}
+/** Index of the last token ending at or before `position`. */
+function lastTokenIndexBefore(tokens, position) {
+    let low = 0;
+    let high = tokens.length - 1;
+    let found = -1;
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        if (tokens[middle].range[1] <= position) {
+            found = middle;
+            low = middle + 1;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    return found;
+}
+const lineAt = (code, position) => code.slice(0, position).split('\n').length;
+/**
+ * Every restricted-production breach in `code`, or `null` when it does not parse
+ * at all.
+ *
+ * The gap is measured between TOKENS, so the text it spans is whitespace and
+ * comments and nothing else. That is what makes a block comment carrying a line
+ * terminator indistinguishable from a raw newline here — which is the whole
+ * point, since it is indistinguishable to the grammar too.
+ */
+function restrictedProductionBreaches(code) {
+    const parsed = parseForRestrictedProductions(code);
+    if (!parsed)
+        return null;
+    const { ast, tokens } = parsed;
+    const breaches = [];
+    const record = (production, from, to) => {
+        const gap = code.slice(from, to);
+        if (!hasLineTerminator(gap))
+            return;
+        breaches.push({ production, line: lineAt(code, to), gap });
+    };
+    visit(ast, (node) => {
+        if (node.type === 'ArrowFunctionExpression') {
+            const body = node.body;
+            if (!body)
+                return;
+            /**
+             * The arrow token is the LAST `=>` before the body, never the first: a
+             * default parameter may itself be an arrow, and its `=>` sits inside this
+             * node's range.
+             *
+             * Taking the token immediately before it is also what makes a TypeScript
+             * return annotation fall out correctly. The grammar forbids the break
+             * between the SIGNATURE and `=>`, and the annotation is part of the
+             * signature — `() \n : T => 1` is legal and `(): T \n => 1` is not, which
+             * is exactly the pair this comparison distinguishes.
+             */
+            const end = lastTokenIndexBefore(tokens, body.range[0]);
+            for (let index = end; index >= 0; index--) {
+                if (tokens[index].range[1] <= node.range[0])
+                    break;
+                if (tokens[index].value !== '=>')
+                    continue;
+                if (index > 0) {
+                    record('arrow', tokens[index - 1].range[1], tokens[index].range[0]);
+                }
+                break;
+            }
+            return;
+        }
+        if (node.type === 'ThrowStatement' && node.argument) {
+            // The keyword opens the statement, so it is the token after the last one
+            // that ends at or before the statement's start.
+            const index = lastTokenIndexBefore(tokens, node.range[0]) + 1;
+            const keyword = tokens[index];
+            if (!keyword || keyword.value !== 'throw')
+                return;
+            /**
+             * The parser does not reject the breach, but it does RECOVER from it: it
+             * emits a zero-width token where the argument should have been and hands
+             * back a `ThrowStatement` whose argument is an empty node. Measuring the
+             * gap to that phantom would measure nothing at all, so the width filter
+             * is what makes this arm detect anything.
+             */
+            const next = tokens
+                .slice(index + 1)
+                .find((token) => token.range[1] > token.range[0]);
+            if (!next)
+                return;
+            record('throw', keyword.range[1], next.range[0]);
+        }
+    });
+    return breaches;
+}
+exports.restrictedProductionBreaches = restrictedProductionBreaches;
+/**
+ * The non-comment token stream, used to prove a planted comment changed nothing
+ * but comments. `null` when the text does not parse.
+ */
+function tokenSignatureOf(code) {
+    const parsed = parseForRestrictedProductions(code);
+    if (!parsed)
+        return null;
+    return parsed.tokens.map((token) => `${token.type} ${token.value}`).join(' ');
+}
+exports.tokenSignatureOf = tokenSignatureOf;
+//# sourceMappingURL=restrictedProductions.js.map

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,32 @@
 [
+  {
+    "version": "1.20.144",
+    "date": "2026-08-12T12:16:01.495Z",
+    "rules": [
+      {
+        "name": "no-redundant-annotation-assertion",
+        "changeType": "fix",
+        "issues": [
+          1969
+        ],
+        "summary": "carry a stranded comment past the arrow (closes #1969)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.143",
+    "date": "2026-08-12T07:48:25.970Z",
+    "rules": [
+      {
+        "name": "prefer-sx-prop-over-system-props",
+        "changeType": "fix",
+        "issues": [
+          1966
+        ],
+        "summary": "key the exemption on (component, prop) (closes #1966)"
+      }
+    ]
+  },
   {
     "version": "1.20.142",
     "date": "2026-08-12T07:04:58.677Z",