@hypersolid-dev/eslint-config 4.0.0 → 5.0.0

package/dist/plugins/rules/no-callback-payload.js

@@ -0,0 +1,214 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import createRule from "../utils/create-rule.js";
+import { componentName, isWrapperCall } from "../utils/component-name.js";
+const CALLBACK_PATTERN = /^on[A-Z]/;
+/** The first parameter's bindings: each prop it destructures, and the props object itself or a rest of it. */
+const propertyBindings = (parameter) => {
+    const props = new Set();
+    const objects = new Set();
+    const target = parameter?.type === AST_NODE_TYPES.AssignmentPattern ? parameter.left : parameter;
+    if (target?.type === AST_NODE_TYPES.Identifier) {
+        props.add(target);
+        objects.add(target);
+    }
+    if (target?.type === AST_NODE_TYPES.ObjectPattern) {
+        for (const property of target.properties) {
+            const value = property.type === AST_NODE_TYPES.RestElement ? property.argument : property.value;
+            const binding = value.type === AST_NODE_TYPES.AssignmentPattern ? value.left : value;
+            if (binding.type !== AST_NODE_TYPES.Identifier)
+                continue;
+            props.add(binding);
+            if (property.type === AST_NODE_TYPES.RestElement)
+                objects.add(binding);
+        }
+    }
+    return { props, objects };
+};
+/**
+ * A component forwards an event; the caller builds the payload.
+ *
+ * Reports, in an exported component (a function whose name starts with a
+ * capital, also inside `memo`/`forwardRef`), a call of one of its own `on*`
+ * props when every argument is built only from its props and literals and at
+ * least one prop is handed straight back (`onPress(teamId)`,
+ * `onPlay({ mediaId })`). Left alone: a value the component produced itself
+ * (an index it tracks, input text, `!isOn`), a callback called with different
+ * arguments in different places (the argument says which control was
+ * pressed), and components the file does not export.
+ *
+ * Props are the first parameter's bindings, resolved through scope, so a local
+ * that shadows a prop's name is the component's own value. Limits: a value
+ * derived into a local first (`const id = item.id`) is not followed.
+ */
+const noCallbackPayload = createRule({
+    name: "no-callback-payload",
+    meta: {
+        defaultOptions: [],
+        type: "suggestion",
+        docs: {
+            description: "A component forwards an event; the caller builds the payload from what it passed in.",
+        },
+        schema: [],
+        messages: {
+            payload: "`{{ callback }}` is called with values `{{ component }}` only received from its parent. Let the parent bind them where it passes `{{ callback }}`, and call it with what this component itself knows (or nothing), so the component stays free of the payload's domain shape.",
+        },
+    },
+    create(context) {
+        const { sourceCode } = context;
+        const exported = new Set();
+        const pending = [];
+        const check = (fn) => {
+            const component = componentName(fn);
+            if (!component)
+                return;
+            const { props, objects } = propertyBindings(fn.params[0]);
+            if (props.size === 0)
+                return;
+            /** Whether a name resolves, through scope, to one of these bindings rather than a local that shadows it. */
+            const isBoundTo = (identifier, bindings) => {
+                for (let scope = sourceCode.getScope(identifier); scope; scope = scope.upper) {
+                    const variable = scope.set.get(identifier.name);
+                    if (variable)
+                        return variable.defs.some((definition) => bindings.has(definition.name));
+                }
+                return false;
+            };
+            /** Built only from props and literals: something the parent already holds. */
+            const isKnown = (node) => {
+                switch (node?.type) {
+                    case AST_NODE_TYPES.Literal:
+                        return true;
+                    case AST_NODE_TYPES.Identifier:
+                        return isBoundTo(node, props) || node.name === "undefined";
+                    case AST_NODE_TYPES.TemplateLiteral:
+                        return node.expressions.every(isKnown);
+                    case AST_NODE_TYPES.MemberExpression:
+                        return isKnown(node.object) && (!node.computed || isKnown(node.property));
+                    case AST_NODE_TYPES.ObjectExpression:
+                        return node.properties.every((property) => property.type === AST_NODE_TYPES.SpreadElement
+                            ? isKnown(property.argument)
+                            : (!property.computed || isKnown(property.key)) && isKnown(property.value));
+                    case AST_NODE_TYPES.ArrayExpression:
+                        return node.elements.every((element) => element === null || isKnown(element));
+                    case AST_NODE_TYPES.SpreadElement:
+                        return isKnown(node.argument);
+                    case AST_NODE_TYPES.LogicalExpression:
+                    case AST_NODE_TYPES.BinaryExpression:
+                        return isKnown(node.left) && isKnown(node.right);
+                    case AST_NODE_TYPES.ConditionalExpression:
+                        return isKnown(node.test) && isKnown(node.consequent) && isKnown(node.alternate);
+                    case AST_NODE_TYPES.TSAsExpression:
+                    case AST_NODE_TYPES.TSNonNullExpression:
+                    case AST_NODE_TYPES.ChainExpression:
+                        return isKnown(node.expression);
+                    default:
+                        return false;
+                }
+            };
+            /** A prop passed straight back: `teamId`, `item.id`. */
+            const isPropertyRead = (node) => (node.type === AST_NODE_TYPES.Identifier && isBoundTo(node, props)) ||
+                (node.type === AST_NODE_TYPES.MemberExpression && !node.computed && isPropertyRead(node.object));
+            /** A prop handed back as an argument, or as a value in an object or array argument. */
+            const isPassingPropertyUp = (node) => {
+                if (isPropertyRead(node))
+                    return true;
+                if (node.type === AST_NODE_TYPES.ObjectExpression) {
+                    return node.properties.some((property) => property.type === AST_NODE_TYPES.Property && isPropertyRead(property.value));
+                }
+                if (node.type === AST_NODE_TYPES.ArrayExpression) {
+                    return node.elements.some((element) => element !== null && isPropertyRead(element));
+                }
+                return false;
+            };
+            const callbackName = (callee) => {
+                if (callee.type === AST_NODE_TYPES.Identifier && isBoundTo(callee, props) && CALLBACK_PATTERN.test(callee.name)) {
+                    return callee.name;
+                }
+                if (callee.type === AST_NODE_TYPES.MemberExpression &&
+                    !callee.computed &&
+                    callee.object.type === AST_NODE_TYPES.Identifier &&
+                    callee.property.type === AST_NODE_TYPES.Identifier &&
+                    isBoundTo(callee.object, objects) &&
+                    CALLBACK_PATTERN.test(callee.property.name)) {
+                    return callee.property.name;
+                }
+                return undefined;
+            };
+            /** Every call of each callback prop, so one called two ways can be told apart. */
+            const calls = new Map();
+            const visit = (node) => {
+                if (!node || typeof node !== "object")
+                    return;
+                const typed = node;
+                if (typed.type === AST_NODE_TYPES.CallExpression) {
+                    const callback = callbackName(typed.callee);
+                    if (callback)
+                        calls.set(callback, [...(calls.get(callback) ?? []), typed]);
+                }
+                for (const [key, value] of Object.entries(node)) {
+                    if (key === "parent")
+                        continue;
+                    if (Array.isArray(value)) {
+                        for (const item of value)
+                            visit(item);
+                    }
+                    else if (value && typeof value.type === "string")
+                        visit(value);
+                }
+            };
+            visit(fn.body);
+            for (const [callback, nodes] of calls) {
+                const payloads = new Set(nodes.map((node) => node.arguments.map((argument) => sourceCode.getText(argument)).join(",")));
+                if (payloads.size > 1)
+                    continue;
+                for (const node of nodes) {
+                    const args = node.arguments;
+                    if (args.every(isKnown) && args.some(isPassingPropertyUp)) {
+                        pending.push({ node, data: { callback, component } });
+                    }
+                }
+            }
+        };
+        return {
+            ArrowFunctionExpression: check,
+            FunctionDeclaration: check,
+            FunctionExpression: check,
+            ExportDefaultDeclaration(node) {
+                // `export default memo(Row)` exports `Row`, however many wrappers it is under.
+                let declaration = node.declaration;
+                while (isWrapperCall(declaration))
+                    declaration = declaration.arguments.at(0);
+                if (declaration?.type === AST_NODE_TYPES.Identifier)
+                    exported.add(declaration.name);
+                if ((declaration?.type === AST_NODE_TYPES.FunctionDeclaration ||
+                    declaration?.type === AST_NODE_TYPES.FunctionExpression ||
+                    declaration?.type === AST_NODE_TYPES.ClassDeclaration) &&
+                    declaration.id) {
+                    exported.add(declaration.id.name);
+                }
+            },
+            ExportNamedDeclaration(node) {
+                for (const specifier of node.specifiers) {
+                    if (specifier.local.type === AST_NODE_TYPES.Identifier)
+                        exported.add(specifier.local.name);
+                }
+                const { declaration } = node;
+                if (declaration?.type === AST_NODE_TYPES.FunctionDeclaration && declaration.id)
+                    exported.add(declaration.id.name);
+                if (declaration?.type === AST_NODE_TYPES.VariableDeclaration) {
+                    for (const declarator of declaration.declarations) {
+                        if (declarator.id.type === AST_NODE_TYPES.Identifier)
+                            exported.add(declarator.id.name);
+                    }
+                }
+            },
+            "Program:exit"() {
+                for (const { node, data } of pending) {
+                    if (exported.has(data.component))
+                        context.report({ node, messageId: "payload", data });
+                }
+            },
+        };
+    },
+});
+export default noCallbackPayload;

package/dist/plugins/rules/no-markup-variable.d.ts

@@ -0,0 +1,22 @@
+type MessageIds = "extract" | "inline";
+/**
+ * Styled markup built in a component's body is a component of its own.
+ *
+ * Reports a `const`/`let` declared directly in a component's body (a function
+ * whose name starts with a capital, also inside `memo`/`forwardRef`) whose
+ * value is JSX, or a ternary or `&&` yielding JSX, when that JSX contains an
+ * element with a `style` prop anywhere. A variable that only arranges
+ * components is left alone.
+ *
+ * A const holding unstyled JSX that is read once, as a child of the JSX it
+ * renders into, is reported too. Left alone: one read two or more times, one
+ * handed to a slot (`bar={bar}`), and a `let` reassigned per branch.
+ *
+ * Limits: markup returned from a helper function or a render prop is not
+ * followed, and markup styled only through a wrapper component's own props is
+ * not markup by this rule.
+ */
+declare const noMarkupVariable: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default noMarkupVariable;

package/dist/plugins/rules/no-markup-variable.js

@@ -0,0 +1,117 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import createRule from "../utils/create-rule.js";
+import { componentName } from "../utils/component-name.js";
+/** The JSX a declarator's value draws: itself, or a branch of a ternary or `&&`. */
+const drawnJsx = (init) => {
+    if (!init)
+        return [];
+    if (init.type === AST_NODE_TYPES.JSXElement || init.type === AST_NODE_TYPES.JSXFragment)
+        return [init];
+    if (init.type === AST_NODE_TYPES.ConditionalExpression) {
+        return [...drawnJsx(init.consequent), ...drawnJsx(init.alternate)];
+    }
+    if (init.type === AST_NODE_TYPES.LogicalExpression)
+        return drawnJsx(init.right);
+    return [];
+};
+/** Whether any element in the tree takes a `style` prop. */
+const hasStyledElement = (node) => {
+    if (!node || typeof node !== "object")
+        return false;
+    const { type, name } = node;
+    if (type === AST_NODE_TYPES.JSXAttribute) {
+        return name?.type === AST_NODE_TYPES.JSXIdentifier && name.name === "style";
+    }
+    for (const [key, value] of Object.entries(node)) {
+        if (key === "parent")
+            continue;
+        if (Array.isArray(value) ? value.some(hasStyledElement) : hasStyledElement(value)) {
+            return true;
+        }
+    }
+    return false;
+};
+const toComponentName = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+/**
+ * Styled markup built in a component's body is a component of its own.
+ *
+ * Reports a `const`/`let` declared directly in a component's body (a function
+ * whose name starts with a capital, also inside `memo`/`forwardRef`) whose
+ * value is JSX, or a ternary or `&&` yielding JSX, when that JSX contains an
+ * element with a `style` prop anywhere. A variable that only arranges
+ * components is left alone.
+ *
+ * A const holding unstyled JSX that is read once, as a child of the JSX it
+ * renders into, is reported too. Left alone: one read two or more times, one
+ * handed to a slot (`bar={bar}`), and a `let` reassigned per branch.
+ *
+ * Limits: markup returned from a helper function or a render prop is not
+ * followed, and markup styled only through a wrapper component's own props is
+ * not markup by this rule.
+ */
+const noMarkupVariable = createRule({
+    name: "no-markup-variable",
+    meta: {
+        defaultOptions: [],
+        type: "suggestion",
+        docs: {
+            description: "Styled markup built in a component's body is a module-level component of its own.",
+        },
+        schema: [],
+        messages: {
+            extract: "`{{ name }}` holds styled markup built while `{{ component }}` renders. Make it a component above this one (for example `{{ suggestion }}`) and render that instead: a named unit with its own props can be memoised, tested and read on its own.",
+            inline: "`{{ name }}` holds JSX that `{{ component }}` reads only once. Write it where it is rendered.",
+        },
+    },
+    create(context) {
+        const check = (fn) => {
+            const component = componentName(fn);
+            if (!component || fn.body.type !== AST_NODE_TYPES.BlockStatement)
+                return;
+            for (const statement of fn.body.body) {
+                if (statement.type !== AST_NODE_TYPES.VariableDeclaration)
+                    continue;
+                for (const declarator of statement.declarations) {
+                    if (declarator.id.type !== AST_NODE_TYPES.Identifier)
+                        continue;
+                    const jsx = drawnJsx(declarator.init);
+                    if (jsx.length === 0)
+                        continue;
+                    if (!jsx.some(hasStyledElement)) {
+                        const variable = context.sourceCode.getDeclaredVariables(declarator).at(0);
+                        const references = variable?.references ?? [];
+                        const reads = references.filter((ref) => ref.isRead());
+                        const isReassigned = references.some((ref) => ref.isWrite() && ref.identifier !== declarator.id);
+                        const container = reads.at(0)?.identifier.parent;
+                        if (reads.length === 1 &&
+                            !isReassigned &&
+                            container?.type === AST_NODE_TYPES.JSXExpressionContainer &&
+                            container.parent.type !== AST_NODE_TYPES.JSXAttribute) {
+                            context.report({
+                                node: declarator.id,
+                                messageId: "inline",
+                                data: { name: declarator.id.name, component },
+                            });
+                        }
+                        continue;
+                    }
+                    context.report({
+                        node: declarator.id,
+                        messageId: "extract",
+                        data: {
+                            name: declarator.id.name,
+                            component,
+                            suggestion: `${component}${toComponentName(declarator.id.name)}`,
+                        },
+                    });
+                }
+            }
+        };
+        return {
+            ArrowFunctionExpression: check,
+            FunctionDeclaration: check,
+            FunctionExpression: check,
+        };
+    },
+});
+export default noMarkupVariable;

package/dist/plugins/rules/no-unnecessary-use-callback.d.ts

@@ -0,0 +1,24 @@
+import { TSESLint } from "@typescript-eslint/utils";
+/**
+ * A `useCallback` that captures nothing from the render is a module-level
+ * function written the slow way.
+ *
+ * Reports a call to React's `useCallback` (imported by name under any local
+ * name, or as `React.useCallback`/`React["useCallback"]` through a default or
+ * namespace import) with exactly a function expression and an empty dependency
+ * array literal, where the function references nothing declared inside a
+ * component or hook. Module-level values, imports and globals are not captures.
+ * There is no fixer: where the function should go is the author's call.
+ *
+ * Leaves alone a non-empty or variable dependency list, a `useCallback` not
+ * imported from `react`, a callback passed by reference, and a callback using
+ * `this`, `super`, `arguments`, `new.target` or `eval`. A consumer that needs
+ * one identity per instance (a `Set` subscriber) states it in a scoped
+ * suppression.
+ *
+ * Limits: only the empty-array form is judged; `useMemo(() => fn, [])` is not.
+ */
+declare const noUnnecessaryUseCallback: TSESLint.RuleModule<"unnecessary", [], unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export default noUnnecessaryUseCallback;

package/dist/plugins/rules/no-unnecessary-use-callback.js

@@ -0,0 +1,117 @@
+import { AST_NODE_TYPES, TSESLint } from "@typescript-eslint/utils";
+import createRule from "../utils/create-rule.js";
+const HAZARD_NAMES = new Set(["arguments", "eval"]);
+/** The import specifier a name resolves to, when it is a value import from `react`. */
+const reactImport = (sourceCode, identifier) => {
+    for (let scope = sourceCode.getScope(identifier); scope; scope = scope.upper) {
+        const variable = scope.set.get(identifier.name);
+        if (!variable)
+            continue;
+        const definition = variable.defs.at(0);
+        if (definition?.type !== TSESLint.Scope.DefinitionType.ImportBinding || definition.parent.type !== AST_NODE_TYPES.ImportDeclaration)
+            return;
+        const declaration = definition.parent;
+        const specifier = definition.node;
+        const isTypeOnly = declaration.importKind === "type" ||
+            (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.importKind === "type");
+        return declaration.source.value === "react" && !isTypeOnly ? specifier : undefined;
+    }
+    return;
+};
+const isUseCallback = (sourceCode, callee) => {
+    if (callee.type === AST_NODE_TYPES.Identifier) {
+        const imported = reactImport(sourceCode, callee);
+        if (imported?.type !== AST_NODE_TYPES.ImportSpecifier)
+            return false;
+        const name = imported.imported.type === AST_NODE_TYPES.Identifier ? imported.imported.name : imported.imported.value;
+        return name === "useCallback";
+    }
+    if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.object.type !== AST_NODE_TYPES.Identifier)
+        return false;
+    const { property } = callee;
+    const isNamed = callee.computed
+        ? property.type === AST_NODE_TYPES.Literal && property.value === "useCallback"
+        : property.type === AST_NODE_TYPES.Identifier && property.name === "useCallback";
+    if (!isNamed)
+        return false;
+    const imported = reactImport(sourceCode, callee.object);
+    return imported?.type === AST_NODE_TYPES.ImportDefaultSpecifier || imported?.type === AST_NODE_TYPES.ImportNamespaceSpecifier;
+};
+/** Whether moving the function out would change what `this`, `super`, `arguments`, `new.target` or `eval` mean. */
+const hasLexicalHazard = (sourceCode, node) => {
+    if (node.type === AST_NODE_TYPES.ThisExpression ||
+        node.type === AST_NODE_TYPES.Super ||
+        node.type === AST_NODE_TYPES.MetaProperty ||
+        (node.type === AST_NODE_TYPES.Identifier && HAZARD_NAMES.has(node.name))) {
+        return true;
+    }
+    const record = node;
+    return (sourceCode.visitorKeys[node.type] ?? []).some((key) => {
+        const value = record[key];
+        const children = Array.isArray(value) ? value : [value];
+        return children.some((child) => Boolean(child) && hasLexicalHazard(sourceCode, child));
+    });
+};
+/**
+ * A `useCallback` that captures nothing from the render is a module-level
+ * function written the slow way.
+ *
+ * Reports a call to React's `useCallback` (imported by name under any local
+ * name, or as `React.useCallback`/`React["useCallback"]` through a default or
+ * namespace import) with exactly a function expression and an empty dependency
+ * array literal, where the function references nothing declared inside a
+ * component or hook. Module-level values, imports and globals are not captures.
+ * There is no fixer: where the function should go is the author's call.
+ *
+ * Leaves alone a non-empty or variable dependency list, a `useCallback` not
+ * imported from `react`, a callback passed by reference, and a callback using
+ * `this`, `super`, `arguments`, `new.target` or `eval`. A consumer that needs
+ * one identity per instance (a `Set` subscriber) states it in a scoped
+ * suppression.
+ *
+ * Limits: only the empty-array form is judged; `useMemo(() => fn, [])` is not.
+ */
+const noUnnecessaryUseCallback = createRule({
+    name: "no-unnecessary-use-callback",
+    meta: {
+        defaultOptions: [],
+        type: "suggestion",
+        docs: {
+            description: "A `useCallback` with an empty dependency array that captures no render-local value is a module-level function written the slow way.",
+        },
+        schema: [],
+        messages: {
+            unnecessary: "This callback captures no render-local values. Use an existing function or define it at module scope, unless a proven per-instance identity contract requires memoization; explain that contract in a scoped suppression.",
+        },
+    },
+    create(context) {
+        const { sourceCode } = context;
+        return {
+            CallExpression(node) {
+                if (!isUseCallback(sourceCode, node.callee))
+                    return;
+                const [callback, dependencies] = [node.arguments.at(0), node.arguments.at(1)];
+                if (node.arguments.length !== 2 ||
+                    !callback ||
+                    (callback.type !== AST_NODE_TYPES.ArrowFunctionExpression && callback.type !== AST_NODE_TYPES.FunctionExpression) ||
+                    dependencies?.type !== AST_NODE_TYPES.ArrayExpression ||
+                    dependencies.elements.length > 0 ||
+                    hasLexicalHazard(sourceCode, callback)) {
+                    return;
+                }
+                const [start, end] = callback.range;
+                const hasCapture = sourceCode.getScope(callback).through.some((reference) => {
+                    const resolved = reference.resolved;
+                    if (!resolved)
+                        return false;
+                    const { type, block } = resolved.scope;
+                    const isOwn = block.range[0] >= start && block.range[1] <= end;
+                    return type !== TSESLint.Scope.ScopeType.module && type !== TSESLint.Scope.ScopeType.global && !isOwn;
+                });
+                if (!hasCapture)
+                    context.report({ node, messageId: "unnecessary" });
+            },
+        };
+    },
+});
+export default noUnnecessaryUseCallback;

package/dist/plugins/rules/regex-pattern-const.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A regular expression lives in a module-level `const <NAME>_PATTERN`, so its name says what it matches and it is built once.
+ *
+ * Reports a regex literal, or a `RegExp(...)` / `new RegExp(...)` whose
+ * arguments are all static (string literals, templates or `String.raw` with
+ * nothing interpolated). Anywhere but the initialiser of a module-level `const`
+ * it is `hoist`; there, with a name not SCREAMING_SNAKE_CASE ending in
+ * `_PATTERN`, it is `rename`. A cast or `satisfies` around it is looked through.
+ *
+ * Accepts a `RegExp` built from a runtime value, `RegExp()` with no argument,
+ * and a string that merely looks like a regex.
+ *
+ * Limits: `RegExp` is matched by its global name, so an alias or a pattern
+ * built from concatenated strings is not seen.
+ */
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"hoist" | "rename", never[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/plugins/rules/regex-pattern-const.js

@@ -0,0 +1,82 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import createRule from "../utils/create-rule.js";
+const NAME_PATTERN = /^[A-Z][A-Z0-9_]*_PATTERN$/;
+/** A string literal, or a template (plain or `String.raw`) with nothing interpolated. */
+const isStatic = (node) => (node.type === AST_NODE_TYPES.Literal && typeof node.value === "string") ||
+    (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) ||
+    (node.type === AST_NODE_TYPES.TaggedTemplateExpression &&
+        node.tag.type === AST_NODE_TYPES.MemberExpression &&
+        !node.tag.computed &&
+        node.tag.object.type === AST_NODE_TYPES.Identifier &&
+        node.tag.object.name === "String" &&
+        node.tag.property.type === AST_NODE_TYPES.Identifier &&
+        node.tag.property.name === "raw" &&
+        node.quasi.expressions.length === 0);
+const isRegex = (node) => node.type === AST_NODE_TYPES.Literal
+    ? "regex" in node
+    : node.callee.type === AST_NODE_TYPES.Identifier &&
+        node.callee.name === "RegExp" &&
+        node.arguments.length > 0 &&
+        node.arguments.every(isStatic);
+/** The `const X = …` holding this regex at module level, if that is where it sits. */
+const moduleConst = (node) => {
+    let held = node;
+    while ((held.parent?.type === AST_NODE_TYPES.TSAsExpression ||
+        held.parent?.type === AST_NODE_TYPES.TSSatisfiesExpression ||
+        held.parent?.type === AST_NODE_TYPES.TSNonNullExpression) &&
+        held.parent.expression === held) {
+        held = held.parent;
+    }
+    const declarator = held.parent;
+    if (declarator?.type !== AST_NODE_TYPES.VariableDeclarator || declarator.init !== held)
+        return undefined;
+    if (declarator.id.type !== AST_NODE_TYPES.Identifier)
+        return undefined;
+    const declaration = declarator.parent;
+    const holder = declaration.parent;
+    const isAtTop = holder.type === AST_NODE_TYPES.Program || holder.type === AST_NODE_TYPES.ExportNamedDeclaration;
+    return declaration.kind === "const" && isAtTop ? declarator.id : undefined;
+};
+/**
+ * A regular expression lives in a module-level `const <NAME>_PATTERN`, so its name says what it matches and it is built once.
+ *
+ * Reports a regex literal, or a `RegExp(...)` / `new RegExp(...)` whose
+ * arguments are all static (string literals, templates or `String.raw` with
+ * nothing interpolated). Anywhere but the initialiser of a module-level `const`
+ * it is `hoist`; there, with a name not SCREAMING_SNAKE_CASE ending in
+ * `_PATTERN`, it is `rename`. A cast or `satisfies` around it is looked through.
+ *
+ * Accepts a `RegExp` built from a runtime value, `RegExp()` with no argument,
+ * and a string that merely looks like a regex.
+ *
+ * Limits: `RegExp` is matched by its global name, so an alias or a pattern
+ * built from concatenated strings is not seen.
+ */
+export default createRule({
+    name: "regex-pattern-const",
+    meta: {
+        defaultOptions: [],
+        type: "suggestion",
+        docs: { description: "Declare regular expressions as module-level `const <NAME>_PATTERN`." },
+        schema: [],
+        messages: {
+            hoist: "Move this regular expression to a module-level `const <NAME>_PATTERN` named for what it matches.",
+            rename: "Rename `{{name}}` to end in `_PATTERN` (SCREAMING_SNAKE_CASE), so the name says it is a regular expression.",
+        },
+    },
+    create(context) {
+        const check = (node) => {
+            if (!isRegex(node))
+                return;
+            const id = moduleConst(node);
+            if (!id) {
+                context.report({ node, messageId: "hoist" });
+                return;
+            }
+            if (!NAME_PATTERN.test(id.name)) {
+                context.report({ node: id, messageId: "rename", data: { name: id.name } });
+            }
+        };
+        return { Literal: check, NewExpression: check, CallExpression: check };
+    },
+});

package/dist/plugins/rules/test-id-default.d.ts

@@ -0,0 +1,4 @@
+declare const testIdDefault: import("@typescript-eslint/utils/ts-eslint").RuleModule<"missing" | "readsProp" | "wrong", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default testIdDefault;