@blumintinc/eslint-plugin-blumint 1.16.2 → 1.17.1

package/lib/rules/no-satisfies-in-frontend-bundle.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSatisfiesInFrontendBundle = void 0;
+const minimatch_1 = require("minimatch");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_EXCLUDE_PATHS = [
+    'functions/src/firestore/**',
+    'functions/src/callable/**',
+    'functions/src/pubsub/**',
+    'functions/src/webhooks/**',
+    'functions/src/queues/**',
+    'functions/src/realtime/**',
+];
+const DEFAULT_INCLUDE_PATHS = ['src/**', 'functions/src/**'];
+/**
+ * Normalizes a filesystem path to forward slashes for consistent
+ * glob matching on all platforms.
+ */
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+/**
+ * Returns the portion of the normalized path starting from a recognized
+ * root segment (`src/` or `functions/`), so that absolute paths from
+ * the RuleTester (e.g. `/project/src/components/Foo.tsx`) are matched
+ * against the configured include/exclude globs as if they were relative
+ * to the project root.
+ *
+ * Check `functions/` before `src/` because `functions/src/` paths contain
+ * `/src/` as a substring; matching `/src/` first would incorrectly strip
+ * the `functions/` prefix and break exclude-glob matching.
+ */
+function toRelativeLike(normalizedFilename) {
+    const functionsIdx = normalizedFilename.indexOf('/functions/');
+    if (functionsIdx !== -1) {
+        return normalizedFilename.slice(functionsIdx + 1); // "functions/..."
+    }
+    const srcIdx = normalizedFilename.indexOf('/src/');
+    if (srcIdx !== -1) {
+        return normalizedFilename.slice(srcIdx + 1); // "src/..."
+    }
+    return normalizedFilename;
+}
+exports.noSatisfiesInFrontendBundle = (0, createRule_1.createRule)({
+    name: 'no-satisfies-in-frontend-bundle',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow the `satisfies` operator in files that reach the frontend webpack bundle (Next.js 12 SWC cannot parse it)',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    excludePaths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: DEFAULT_EXCLUDE_PATHS,
+                    },
+                    includePaths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: DEFAULT_INCLUDE_PATHS,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noSatisfiesOperator: 'SWC in Next.js 12 cannot parse `satisfies`; this file is bundled by webpack and will fail the production build. Use an explicit type annotation, or a constrained identity helper when literal keys must be preserved.',
+        },
+    },
+    defaultOptions: [
+        {
+            excludePaths: DEFAULT_EXCLUDE_PATHS,
+            includePaths: DEFAULT_INCLUDE_PATHS,
+        },
+    ],
+    create(context, [options]) {
+        const excludePaths = options.excludePaths ?? DEFAULT_EXCLUDE_PATHS;
+        const includePaths = options.includePaths ?? DEFAULT_INCLUDE_PATHS;
+        const filename = context.getFilename();
+        // Skip synthetic filenames used by RuleTester when no filename is provided.
+        if (filename === '<input>' || filename === '<text>') {
+            return {};
+        }
+        const normalizedFilename = normalizePath(filename);
+        // Exempt declaration files — they are never bundled.
+        if (normalizedFilename.endsWith('.d.ts')) {
+            return {};
+        }
+        // Exempt test and spec files — they are never bundled.
+        if (/\.(test|spec)\.[jt]sx?$/.test(normalizedFilename)) {
+            return {};
+        }
+        // Derive a path relative to the project root for glob matching.
+        const relPath = toRelativeLike(normalizedFilename);
+        // Only enforce within the configured include paths.
+        const includeMatchers = includePaths.map((pattern) => new minimatch_1.Minimatch(pattern, { dot: true }));
+        const isIncluded = includeMatchers.some((mm) => mm.match(normalizedFilename) || mm.match(relPath));
+        if (!isIncluded) {
+            return {};
+        }
+        // Skip files that match any exclude path.
+        const excludeMatchers = excludePaths.map((pattern) => new minimatch_1.Minimatch(pattern, { dot: true }));
+        const isExcluded = excludeMatchers.some((mm) => mm.match(normalizedFilename) || mm.match(relPath));
+        if (isExcluded) {
+            return {};
+        }
+        return {
+            // Every TSSatisfiesExpression is reported regardless of wrapping context.
+            // "x as const satisfies T" is a TSSatisfiesExpression (wrapping a
+            // TSAsExpression), so it is caught. Bare "as const" (TSAsExpression
+            // only) is NOT caught — correct.
+            TSSatisfiesExpression(node) {
+                context.report({
+                    node,
+                    messageId: 'noSatisfiesOperator',
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-satisfies-in-frontend-bundle.js.map

package/lib/rules/no-single-dismiss-dialog-button.d.ts

@@ -0,0 +1,7 @@
+type Options = [
+    {
+        dismissLabels?: string[];
+    }
+];
+export declare const noSingleDismissDialogButton: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noSingleDismissDialogButton", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/no-single-dismiss-dialog-button.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSingleDismissDialogButton = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_DISMISS_LABELS = [
+    'Cancel',
+    'Close',
+    'Dismiss',
+    'Not now',
+    'Never mind',
+];
+/**
+ * Extracts the string value from a node that is either a string Literal or a
+ * TemplateLiteral with no expressions (i.e. a plain template string). Returns
+ * null for anything more dynamic.
+ */
+function getStaticStringValue(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+        return node.value;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1) {
+        return node.quasis[0].value.cooked ?? node.quasis[0].value.raw;
+    }
+    return null;
+}
+/**
+ * Returns true when the value (after trimming) matches one of the dismiss
+ * labels, case-insensitively.
+ */
+function isDismissLabel(value, dismissLabels) {
+    const normalized = value.trim().toLowerCase();
+    return dismissLabels.some((label) => label.toLowerCase() === normalized);
+}
+/**
+ * Searches the properties of an ObjectExpression for a property named
+ * `children` whose value is a static string matching a dismiss label.
+ * Returns the button ObjectExpression node if found, null otherwise.
+ */
+function findDismissChildrenProp(element, dismissLabels) {
+    for (const prop of element.properties) {
+        if (prop.type !== utils_1.AST_NODE_TYPES.Property)
+            continue;
+        if (prop.computed)
+            continue;
+        const key = prop.key;
+        const isChildrenKey = (key.type === utils_1.AST_NODE_TYPES.Identifier && key.name === 'children') ||
+            (key.type === utils_1.AST_NODE_TYPES.Literal && key.value === 'children');
+        if (!isChildrenKey)
+            continue;
+        const staticVal = getStaticStringValue(prop.value);
+        if (staticVal !== null && isDismissLabel(staticVal, dismissLabels)) {
+            return prop;
+        }
+    }
+    return null;
+}
+exports.noSingleDismissDialogButton = (0, createRule_1.createRule)({
+    name: 'no-single-dismiss-dialog-button',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow a single dialog button whose label is a dismiss action (Cancel, Close, Dismiss, Not now, Never mind). Use navigation.onClose for dismissal; the buttons array should only contain affirmative actions.',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    dismissLabels: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: DEFAULT_DISMISS_LABELS,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            noSingleDismissDialogButton: 'A single dialog button with label "{{label}}" is a dismiss action. Use navigation.onClose to handle dismissal via the X close button instead; the buttons array should only contain affirmative actions.',
+        },
+    },
+    defaultOptions: [{ dismissLabels: DEFAULT_DISMISS_LABELS }],
+    create(context) {
+        const options = context.options[0] ?? {};
+        const dismissLabels = options.dismissLabels ?? DEFAULT_DISMISS_LABELS;
+        return {
+            Property(node) {
+                // Only care about properties named `buttons`
+                if (node.computed)
+                    return;
+                const key = node.key;
+                const isButtonsKey = (key.type === utils_1.AST_NODE_TYPES.Identifier && key.name === 'buttons') ||
+                    (key.type === utils_1.AST_NODE_TYPES.Literal && key.value === 'buttons');
+                if (!isButtonsKey)
+                    return;
+                // The value must be an array literal
+                if (node.value.type !== utils_1.AST_NODE_TYPES.ArrayExpression)
+                    return;
+                const arrayExpr = node.value;
+                // Only flag exactly one element
+                if (arrayExpr.elements.length !== 1)
+                    return;
+                const element = arrayExpr.elements[0];
+                if (!element || element.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                    return;
+                const dismissProp = findDismissChildrenProp(element, dismissLabels);
+                if (!dismissProp)
+                    return;
+                // Retrieve the label text for the error message
+                const labelNode = dismissProp.value;
+                const labelText = getStaticStringValue(labelNode) ?? '';
+                context.report({
+                    node: element,
+                    messageId: 'noSingleDismissDialogButton',
+                    data: {
+                        label: labelText.trim(),
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-single-dismiss-dialog-button.js.map

package/lib/rules/no-stablehash-react-nodes.d.ts

@@ -0,0 +1 @@
+export declare const noStablehashReactNodes: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noStableHashReactNode", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-stablehash-react-nodes.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noStablehashReactNodes = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+/**
+ * Module path suffix that identifies the stableHash family of utilities.
+ * Matches both absolute and relative import paths that end in util/hash/stableHash.
+ */
+const HASH_MODULE_SUFFIX = 'util/hash/stableHash';
+/**
+ * Named exports from the hash module that we care about. sortedHash is included
+ * because it wraps stableHash and has the same stringification danger.
+ */
+const HASH_EXPORT_NAMES = new Set(['stableHash', 'sortedHash']);
+/**
+ * Type names that unambiguously denote React render trees or BluMint node
+ * wrappers. When a variable/parameter carries one of these annotations we know
+ * it is a ReactNode and must not be hashed.
+ */
+const REACT_NODE_TYPE_NAMES = new Set([
+    'ReactNode',
+    'ReactElement',
+    'JSX',
+    'KeyedNode',
+    'OrNode',
+]);
+/**
+ * Object-literal property names whose presence signals the object contains a
+ * React render tree (either a children prop or a BluMint "Node" field).
+ */
+const NODE_PROP_NAMES = new Set(['children', 'Node']);
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Return true when the import source path ends with the known hash module
+ * suffix, handling both absolute paths (functions/src/util/hash/stableHash)
+ * and relative variants (../../../util/hash/stableHash).
+ */
+function isHashModulePath(source) {
+    return source.endsWith(HASH_MODULE_SUFFIX);
+}
+/**
+ * Resolve the TSTypeAnnotation / TSTypeReference down to a base type name so
+ * we can match against REACT_NODE_TYPE_NAMES without depending on the type
+ * checker.
+ *
+ * Handles:
+ *   ReactNode                        → 'ReactNode'
+ *   React.ReactNode                  → 'ReactNode'  (qualified reference)
+ *   JSX.Element                      → 'JSX'
+ *   OrNode<T>                        → 'OrNode'
+ *   KeyedNode[]  / readonly KeyedNode[] → 'KeyedNode' (array element)
+ */
+function extractBaseTypeName(typeNode) {
+    switch (typeNode.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeReference: {
+            const name = typeNode.typeName;
+            if (name.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return name.name;
+            }
+            // Qualified name: React.ReactNode → take the right-hand part
+            if (name.type === utils_1.AST_NODE_TYPES.TSQualifiedName &&
+                name.right.type === utils_1.AST_NODE_TYPES.Identifier) {
+                // For JSX.Element we want "JSX" (the left) so we can match the set
+                if (name.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    name.left.name === 'JSX') {
+                    return 'JSX';
+                }
+                return name.right.name;
+            }
+            return null;
+        }
+        case utils_1.AST_NODE_TYPES.TSArrayType:
+            return extractBaseTypeName(typeNode.elementType);
+        case utils_1.AST_NODE_TYPES.TSTypeOperator:
+            // readonly T[]
+            if (typeNode.typeAnnotation) {
+                return extractBaseTypeName(typeNode.typeAnnotation);
+            }
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Return true when a TS type annotation (already unwrapped to the inner type
+ * node) indicates a ReactNode / ReactElement / KeyedNode / OrNode / JSX.Element.
+ */
+function isReactNodeTypeAnnotation(typeNode) {
+    const base = extractBaseTypeName(typeNode);
+    if (base === null)
+        return false;
+    return REACT_NODE_TYPE_NAMES.has(base);
+}
+/**
+ * Walk the program body's import declarations to build a mapping from local
+ * binding name → { isNamespace: boolean }.
+ *
+ * isNamespace = true  → `import * as Hash from '...'` — we flag Hash.stableHash(...)
+ * isNamespace = false → `import { stableHash } from '...'` (possibly aliased)
+ */
+function collectHashBindings(program) {
+    const bindings = new Map();
+    for (const node of program.body) {
+        if (node.type !== utils_1.AST_NODE_TYPES.ImportDeclaration)
+            continue;
+        if (!isHashModulePath(String(node.source.value)))
+            continue;
+        for (const spec of node.specifiers) {
+            if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                // import * as Hash from '...'
+                bindings.set(spec.local.name, { isNamespace: true });
+            }
+            else if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                // import { stableHash } or import { stableHash as hash }
+                const importedName = spec.imported.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? spec.imported.name
+                    : spec.imported.value;
+                if (HASH_EXPORT_NAMES.has(importedName)) {
+                    bindings.set(spec.local.name, { isNamespace: false });
+                }
+            }
+        }
+    }
+    return bindings;
+}
+/**
+ * Return true when the argument to a stableHash call is a JSX element or
+ * JSX fragment.
+ */
+function isJsxNode(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
+        node.type === utils_1.AST_NODE_TYPES.JSXFragment);
+}
+/**
+ * Return true when the argument is an object literal that contains a property
+ * named `children` or `Node` (shorthand or keyed), signalling it wraps a
+ * render-tree value.
+ */
+function objectLiteralContainsNodeProp(node) {
+    for (const prop of node.properties) {
+        if (prop.type !== utils_1.AST_NODE_TYPES.Property)
+            continue;
+        const key = prop.key;
+        let propName = null;
+        if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
+            propName = key.name;
+        }
+        else if (key.type === utils_1.AST_NODE_TYPES.Literal &&
+            typeof key.value === 'string') {
+            propName = key.value;
+        }
+        if (propName !== null && NODE_PROP_NAMES.has(propName)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Attempt to resolve the type annotation of an identifier from the local
+ * scope without the type checker.
+ *
+ * Strategy (in order):
+ * 1. The identifier is a parameter of the immediately enclosing function with
+ *    a TSTypeAnnotation — read it directly.
+ * 2. The identifier is declared as a variable with a type annotation
+ *    (`const x: ReactNode = ...`).
+ *
+ * Returns the TSTypeAnnotation typeAnnotation node or null if not found.
+ */
+function resolveAnnotationForIdentifier(identNode) {
+    // Walk parents looking for a parameter list or variable declarator that
+    // matches the identifier's name.
+    let current = identNode.parent;
+    while (current) {
+        // Function or arrow-function parameter
+        if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+            current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+            const fn = current;
+            for (const param of fn.params) {
+                if (param.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    param.name === identNode.name &&
+                    param.typeAnnotation?.typeAnnotation) {
+                    return param.typeAnnotation.typeAnnotation;
+                }
+                // Handle default param: (node: KeyedNode = ...)
+                if (param.type === utils_1.AST_NODE_TYPES.AssignmentPattern &&
+                    param.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    param.left.name === identNode.name &&
+                    param.left.typeAnnotation?.typeAnnotation) {
+                    const annotation = param.left.typeAnnotation;
+                    if (annotation) {
+                        return annotation.typeAnnotation;
+                    }
+                }
+            }
+        }
+        // Variable declaration in the same scope
+        if (current.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+            for (const decl of current.declarations) {
+                if (decl.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    decl.id.name === identNode.name &&
+                    decl.id.typeAnnotation?.typeAnnotation) {
+                    return decl.id.typeAnnotation.typeAnnotation;
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return null;
+}
+/**
+ * Return true when the argument expression is, or contains, a ReactNode based
+ * on purely syntactic (AST-level) evidence:
+ *
+ * 1. Literal JSX element/fragment.
+ * 2. Object literal with a `children` or `Node` property.
+ * 3. Identifier whose nearest resolvable TS type annotation names a ReactNode.
+ */
+function argIsReactNode(arg) {
+    // Strip as/type-assertion wrappers
+    let expr = arg;
+    while (expr.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        expr.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+        expr.type === utils_1.AST_NODE_TYPES.TSNonNullExpression) {
+        expr = expr.expression;
+    }
+    // Case 1: direct JSX
+    if (isJsxNode(expr)) {
+        return true;
+    }
+    // Case 2: object literal with node-shaped prop
+    if (expr.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+        objectLiteralContainsNodeProp(expr)) {
+        return true;
+    }
+    // Case 3: identifier with resolvable ReactNode annotation
+    if (expr.type === utils_1.AST_NODE_TYPES.Identifier) {
+        const typeNode = resolveAnnotationForIdentifier(expr);
+        if (typeNode && isReactNodeTypeAnnotation(typeNode)) {
+            return true;
+        }
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Rule
+// ---------------------------------------------------------------------------
+exports.noStablehashReactNodes = (0, createRule_1.createRule)({
+    name: 'no-stablehash-react-nodes',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent passing ReactNodes or render-tree values to stableHash(), which deep-stringifies its argument and can freeze the browser.',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [],
+        messages: {
+            noStableHashReactNode: 'Do not stableHash ReactNodes / KeyedNodes — stableHash() stringifies the full render tree and can freeze the browser. Hash stable keys/ids instead (e.g. stableHash(nodes.map((n) => n.key))).',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Collect hash-function bindings lazily on first CallExpression visit.
+        let bindings = null;
+        function getBindings() {
+            if (bindings === null) {
+                const sourceCode = context
+                    .sourceCode ?? context.getSourceCode();
+                bindings = collectHashBindings(sourceCode.ast);
+            }
+            return bindings;
+        }
+        /**
+         * Determine whether a CallExpression's callee is a tracked stableHash /
+         * sortedHash binding and return the first argument if so.
+         */
+        function getTrackedCallArg(node) {
+            if (node.arguments.length === 0)
+                return null;
+            const map = getBindings();
+            if (map.size === 0)
+                return null;
+            const callee = node.callee;
+            // Direct call: stableHash(arg) or hash(arg) (aliased)
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const info = map.get(callee.name);
+                if (info && !info.isNamespace) {
+                    return node.arguments[0];
+                }
+            }
+            // Member expression: Hash.stableHash(arg)
+            if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !callee.computed &&
+                callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const objectName = callee.object.name;
+                const methodName = callee.property.name;
+                const info = map.get(objectName);
+                if (info && info.isNamespace && HASH_EXPORT_NAMES.has(methodName)) {
+                    return node.arguments[0];
+                }
+            }
+            return null;
+        }
+        return {
+            CallExpression(node) {
+                const arg = getTrackedCallArg(node);
+                if (arg === null)
+                    return;
+                if (argIsReactNode(arg)) {
+                    context.report({
+                        node,
+                        messageId: 'noStableHashReactNode',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-stablehash-react-nodes.js.map

package/lib/rules/parallelize-loop-awaits.d.ts

@@ -0,0 +1,8 @@
+type Options = [
+    {
+        coordinatorPatterns?: string[];
+        rateLimitedPatterns?: string[];
+    }
+];
+export declare const parallelizeLoopAwaits: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"parallelizeLoopAwaits", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};