@hypersolid-dev/eslint-config 4.0.0 → 5.0.0

package/dist/plugins/utils/component-name.js

@@ -0,0 +1,32 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+const WRAPPERS = new Set(["memo", "forwardRef"]);
+const CAPITALISED_PATTERN = /^[A-Z]/;
+/** A `memo(…)`/`forwardRef(…)` call, also as `React.memo(…)`. */
+export const isWrapperCall = (node) => {
+    if (node?.type !== AST_NODE_TYPES.CallExpression)
+        return false;
+    const { callee } = node;
+    if (callee.type === AST_NODE_TYPES.Identifier)
+        return WRAPPERS.has(callee.name);
+    return (callee.type === AST_NODE_TYPES.MemberExpression &&
+        callee.property.type === AST_NODE_TYPES.Identifier &&
+        WRAPPERS.has(callee.property.name));
+};
+const declaredName = (holder) => {
+    let node = holder;
+    while (isWrapperCall(node))
+        node = node.parent;
+    return node?.type === AST_NODE_TYPES.VariableDeclarator && node.id.type === AST_NODE_TYPES.Identifier
+        ? node.id.name
+        : undefined;
+};
+/**
+ * The name a function is a component under, if it is one: a capitalised
+ * function declaration or named function expression (`memo(function Row() {})`),
+ * or a capitalised const holding the function directly or through any nesting
+ * of `memo`/`forwardRef` (`memo(forwardRef(…))`).
+ */
+export const componentName = (fn) => {
+    const name = fn.id?.name ?? declaredName(fn.parent);
+    return name && CAPITALISED_PATTERN.test(name) ? name : undefined;
+};

package/dist/plugins/utils/create-rule.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default createRule;

package/dist/plugins/utils/create-rule.js

@@ -0,0 +1,4 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+// Rules in this package are documented in the README, so a rule name is its own URL.
+const createRule = ESLintUtils.RuleCreator((name) => name);
+export default createRule;

package/dist/plugins/utils/expressions.d.ts

@@ -0,0 +1,52 @@
+import { TSESLint, type TSESTree } from '@typescript-eslint/utils';
+/**
+ * One answer to "what can this expression be", for every rule that has to ask.
+ *
+ * The carriers (the shapes that hold an expression rather than being one) are
+ * flattened away, and what comes back is the list of leaves: the things the
+ * expression can actually turn out to be.
+ */
+type Node = TSESTree.Node;
+type Scope = TSESLint.Scope.Scope;
+export type ScopeContext = {
+    sourceCode: {
+        getScope: (node: Node) => Scope;
+    };
+};
+export type LeavesOptions = {
+    /** Follow an identifier to what it holds (default true). */
+    names?: boolean;
+    /** Follow `OBJ.key` to that entry (default true). */
+    members?: boolean;
+    /** Follow a function, and a call of a local function, to each of its returns (default false). */
+    returns?: boolean;
+    /** The names whose `.select({ … })` is unwrapped like `Platform.select` (default `Platform`). */
+    selectObjects?: ReadonlySet<string>;
+    /** Extra calls whose first argument is the expression. */
+    calls?: (node: TSESTree.CallExpression) => boolean;
+    /** Internal cycle guard, threaded through the `Platform.select` recursion. */
+    seen?: Set<Node>;
+};
+/** Through `as`, `satisfies`, `!` and `?.`. */
+export declare function unwrap(node: Node | null | undefined): Node | undefined;
+/**
+ * A property's key when it is written literally (`a`, `"a"`, `1`, `["a"]`,
+ * `[\`a\`]`), else null: a computed key that is a variable, a call or a
+ * template with expressions, a spread and a pattern have no key to read.
+ */
+export declare function keyOf(property: Node): string | null;
+/**
+ * Every leaf an expression can produce.
+ *
+ * Flattened away: arrays, ternaries, `&&` / `||` / `??`, `as` / `satisfies` /
+ * `!` wrappers, a `Platform.select` call (each branch's values), a `useMemo`
+ * callback (its body or returns, also as `React.useMemo`), a `const` name (its
+ * initialiser, through any number of hops), a destructured `const` name when
+ * the initialiser is a literal, and `OBJ.key` when `OBJ` is a local `const`
+ * object literal. A `useCallback` callback yields the function itself, or its
+ * returns when `returns` is on. What cannot be read is handed back as a leaf
+ * itself: a name from another file, a `let`, a method call, a computed member,
+ * a spread. A cycle yields nothing rather than looping.
+ */
+export declare function leavesOf(context: ScopeContext, node: Node | null | undefined, options?: LeavesOptions): Node[];
+export {};

package/dist/plugins/utils/expressions.js

@@ -0,0 +1,274 @@
+import { AST_NODE_TYPES, TSESLint } from '@typescript-eslint/utils';
+const { DefinitionType } = TSESLint.Scope;
+// A memo hook holds one computed value, so its body is the value.
+const MEMO_HOOKS = new Set(['useMemo', 'useCallback']);
+const FUNCTIONS = new Set(['ArrowFunctionExpression', 'FunctionExpression', 'FunctionDeclaration']);
+const TS_WRAPPERS = new Set(['TSAsExpression', 'TSSatisfiesExpression', 'TSNonNullExpression', 'ChainExpression']);
+const DEFAULT_SELECT_OBJECTS = new Set(['Platform']);
+const isWrapper = (node) => TS_WRAPPERS.has(node.type);
+const isFunction = (node) => FUNCTIONS.has(node.type);
+/** Through `as`, `satisfies`, `!` and `?.`. */
+export function unwrap(node) {
+    let current = node ?? undefined;
+    while (current && isWrapper(current))
+        current = current.expression;
+    return current;
+}
+/** The name of the memo hook a callee calls (`useMemo`, `React.useMemo`), if it is one. */
+function memoHookName(callee) {
+    if (callee.type === AST_NODE_TYPES.Identifier)
+        return MEMO_HOOKS.has(callee.name) ? callee.name : undefined;
+    if (callee.type === AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.object.type === AST_NODE_TYPES.Identifier &&
+        callee.object.name === 'React' &&
+        MEMO_HOOKS.has(callee.property.name)) {
+        return callee.property.name;
+    }
+    return undefined;
+}
+function findVariable(scope, name) {
+    for (let current = scope; current; current = current.upper) {
+        const variable = current.set.get(name);
+        if (variable)
+            return variable;
+    }
+    return undefined;
+}
+function bindingOf(context, identifier) {
+    return findVariable(context.sourceCode.getScope(identifier), identifier.name);
+}
+/** The declarator a name resolves to, when it is a local with an initialiser; `.init` need not be the name's own value. */
+function localDeclarator(context, identifier) {
+    const definition = bindingOf(context, identifier)?.defs[0];
+    return definition?.type === DefinitionType.Variable && definition.node.init ? definition.node : undefined;
+}
+/**
+ * A property's key when it is written literally (`a`, `"a"`, `1`, `["a"]`,
+ * `[\`a\`]`), else null: a computed key that is a variable, a call or a
+ * template with expressions, a spread and a pattern have no key to read.
+ */
+export function keyOf(property) {
+    if (property.type !== AST_NODE_TYPES.Property)
+        return null;
+    const { key } = property;
+    if (!property.computed)
+        return key.type === AST_NODE_TYPES.Identifier ? key.name : String(key.value);
+    if (key.type === AST_NODE_TYPES.Literal)
+        return String(key.value);
+    return key.type === AST_NODE_TYPES.TemplateLiteral && key.expressions.length === 0 ? (key.quasis[0]?.value.cooked ?? null) : null;
+}
+/**
+ * The expression a destructuring pattern hands to `name`, read off a literal
+ * initialiser. A non-literal value, a rest element, a computed key and a spread
+ * before the wanted element all give up, since the value is not in this file.
+ */
+function picked(pattern, init, name) {
+    if (pattern.type === AST_NODE_TYPES.Identifier)
+        return pattern.name === name ? (init ?? undefined) : undefined;
+    // The default only applies when the source has nothing there.
+    if (pattern.type === AST_NODE_TYPES.AssignmentPattern)
+        return picked(pattern.left, init ?? pattern.right, name);
+    const source = unwrap(init);
+    if (pattern.type === AST_NODE_TYPES.ObjectPattern && source?.type === AST_NODE_TYPES.ObjectExpression) {
+        for (const property of pattern.properties) {
+            const wanted = keyOf(property);
+            if (wanted === null || property.type !== AST_NODE_TYPES.Property)
+                continue;
+            const entry = source.properties.find((candidate) => keyOf(candidate) === wanted);
+            const found = picked(property.value, entry?.type === AST_NODE_TYPES.Property ? entry.value : undefined, name);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    if (pattern.type === AST_NODE_TYPES.ArrayPattern && source?.type === AST_NODE_TYPES.ArrayExpression) {
+        for (const [index, element] of pattern.elements.entries()) {
+            if (!element)
+                continue;
+            const before = source.elements.slice(0, index + 1);
+            if (before.some((entry) => entry?.type === AST_NODE_TYPES.SpreadElement))
+                continue;
+            const found = picked(element, source.elements[index], name);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+/**
+ * What a name stands for: a `const`'s own value, or a declared function itself.
+ * A `let` or `var` is not followed, and a destructured `const` resolves only
+ * when its initialiser is a literal holding the matching entry.
+ */
+function boundTo(context, identifier) {
+    const definition = bindingOf(context, identifier)?.defs[0];
+    if (definition?.type === DefinitionType.FunctionName)
+        return definition.node;
+    if (definition?.type !== DefinitionType.Variable)
+        return undefined;
+    if (definition.parent.kind !== 'const' || !definition.node.init)
+        return undefined;
+    const { id, init } = definition.node;
+    return id.type === AST_NODE_TYPES.Identifier ? init : picked(id, init, identifier.name);
+}
+function selectBranches(node, selectObjects) {
+    const { callee } = node;
+    if (callee.type !== AST_NODE_TYPES.MemberExpression || callee.computed)
+        return undefined;
+    if (callee.property.name !== 'select' || callee.object.type !== AST_NODE_TYPES.Identifier)
+        return undefined;
+    return selectObjects.has(callee.object.name) ? node.arguments[0] : undefined;
+}
+/** Every `return` with an argument in a body, including nested blocks but not nested functions. */
+function returnsIn(body) {
+    const found = [];
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                visit(item);
+            return;
+        }
+        if (!value || typeof value.type !== 'string')
+            return;
+        const statement = value;
+        if (statement.type === AST_NODE_TYPES.ReturnStatement) {
+            if (statement.argument)
+                found.push(statement.argument);
+            return;
+        }
+        if (isFunction(statement))
+            return;
+        for (const [key, child] of Object.entries(statement)) {
+            if (key !== 'parent')
+                visit(child);
+        }
+    };
+    visit(body);
+    return found;
+}
+/**
+ * Every leaf an expression can produce.
+ *
+ * Flattened away: arrays, ternaries, `&&` / `||` / `??`, `as` / `satisfies` /
+ * `!` wrappers, a `Platform.select` call (each branch's values), a `useMemo`
+ * callback (its body or returns, also as `React.useMemo`), a `const` name (its
+ * initialiser, through any number of hops), a destructured `const` name when
+ * the initialiser is a literal, and `OBJ.key` when `OBJ` is a local `const`
+ * object literal. A `useCallback` callback yields the function itself, or its
+ * returns when `returns` is on. What cannot be read is handed back as a leaf
+ * itself: a name from another file, a `let`, a method call, a computed member,
+ * a spread. A cycle yields nothing rather than looping.
+ */
+export function leavesOf(context, node, options = {}) {
+    const { names = true, members = true, returns = false, selectObjects = DEFAULT_SELECT_OBJECTS, calls, seen = new Set(), } = options;
+    const out = [];
+    const walkFunction = (fn) => {
+        if (fn.body.type !== AST_NODE_TYPES.BlockStatement) {
+            walk(fn.body);
+            return;
+        }
+        for (const argument of returnsIn(fn.body))
+            walk(argument);
+    };
+    const didWalkCall = (call) => {
+        const branches = selectBranches(call, selectObjects);
+        if (branches) {
+            // Each branch is a value for whatever slot the call sits in.
+            for (const branch of leavesOf(context, branches, { ...options, seen })) {
+                if (branch.type !== AST_NODE_TYPES.ObjectExpression)
+                    continue;
+                for (const property of branch.properties) {
+                    if (property.type === AST_NODE_TYPES.Property)
+                        walk(property.value);
+                }
+            }
+            return true;
+        }
+        if (calls?.(call)) {
+            walk(call.arguments[0]);
+            return true;
+        }
+        // A call to a local function is what it returns (a factory); a method call is never followed.
+        if (returns && call.callee.type === AST_NODE_TYPES.Identifier) {
+            const bound = boundTo(context, call.callee);
+            if (bound && isFunction(bound)) {
+                walk(bound);
+                return true;
+            }
+        }
+        const hook = memoHookName(call.callee);
+        const callback = call.arguments.at(0);
+        if (!hook || !callback || !isFunction(callback))
+            return false;
+        // A callback's value is the function itself; `returns` decides whether the function case follows on.
+        if (hook === 'useCallback')
+            walk(callback);
+        else
+            walkFunction(callback);
+        return true;
+    };
+    const walk = (current) => {
+        if (!current || seen.has(current))
+            return;
+        seen.add(current);
+        if (isWrapper(current)) {
+            walk(current.expression);
+            return;
+        }
+        switch (current.type) {
+            case AST_NODE_TYPES.ArrayExpression:
+                for (const element of current.elements)
+                    walk(element);
+                return;
+            case AST_NODE_TYPES.ConditionalExpression:
+                walk(current.consequent);
+                walk(current.alternate);
+                return;
+            case AST_NODE_TYPES.LogicalExpression:
+                walk(current.left);
+                walk(current.right);
+                return;
+            case AST_NODE_TYPES.Identifier: {
+                const bound = names ? boundTo(context, current) : undefined;
+                if (bound) {
+                    walk(bound);
+                    return;
+                }
+                break;
+            }
+            case AST_NODE_TYPES.MemberExpression: {
+                if (!members || current.computed || current.object.type !== AST_NODE_TYPES.Identifier)
+                    break;
+                const declarator = localDeclarator(context, current.object);
+                // A destructured name is not what the whole initialiser holds.
+                const held = declarator?.id.type === AST_NODE_TYPES.Identifier ? unwrap(declarator.init) : undefined;
+                if (held?.type !== AST_NODE_TYPES.ObjectExpression)
+                    break;
+                const key = current.property.name;
+                const entry = held.properties.find((property) => keyOf(property) === key);
+                if (entry?.type === AST_NODE_TYPES.Property) {
+                    walk(entry.value);
+                    return;
+                }
+                break;
+            }
+            case AST_NODE_TYPES.CallExpression:
+                if (didWalkCall(current))
+                    return;
+                break;
+            case AST_NODE_TYPES.ArrowFunctionExpression:
+            case AST_NODE_TYPES.FunctionExpression:
+            case AST_NODE_TYPES.FunctionDeclaration:
+                if (!returns)
+                    break;
+                walkFunction(current);
+                return;
+            default:
+                break;
+        }
+        out.push(current);
+    };
+    walk(node);
+    return out;
+}

package/dist/plugins/utils/types.d.ts

@@ -0,0 +1,20 @@
+import { type TSESTree } from "@typescript-eslint/utils";
+import ts from "typescript";
+/**
+ * Whether every value of this type is truthy, `undefined` aside.
+ *
+ * Safe: `true`, `symbol`, `object`, a non-falsy literal, `undefined`, `void`,
+ * `never`, and an object type that is callable or to which none of `""`, `0`
+ * and `false` is assignable. Unions and intersections are read part by part,
+ * unresolved types through their constraint. Everything else is not claimed.
+ *
+ * @param checker  Needed to resolve a constraint and to ask whether a falsy
+ *   primitive fits an object type; without one only a callable object is claimed.
+ */
+export declare const isSameAsBangBang: (type: ts.Type, checker?: ts.TypeChecker) => boolean;
+export type UndefinedComparison = {
+    value: TSESTree.Expression | TSESTree.PrivateIdentifier;
+    isPresent: boolean;
+};
+/** `x !== undefined` / `undefined === x`; `present` is what the check wants. */
+export declare const undefinedComparison: (node: TSESTree.Node | undefined) => UndefinedComparison | undefined;

package/dist/plugins/utils/types.js

@@ -0,0 +1,89 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import ts, { TypeFlags } from "typescript";
+/**
+ * The type question two rules ask: is `x !== undefined` the same test as `x`?
+ *
+ * `boolean-guard` asks it of a render guard and `undefined-check` of any
+ * condition, and getting it wrong in either direction is a behaviour change,
+ * so it is answered once, here.
+ *
+ * `undefined` has to be the *only* falsy value the type admits. `null`, `0`,
+ * `""`, `false` and a bare `any` each make the two tests disagree on a value
+ * the code can actually hold.
+ *
+ * Answered by naming what is safe rather than what is not: a type this cannot
+ * resolve (`Items[K]`, a conditional, a `keyof`, `{}`) is unsafe, which costs
+ * a report and never a changed branch.
+ */
+/** Resolved before asking: a parameter, an `Items[K]`, a conditional, a `keyof`. */
+const UNRESOLVED = TypeFlags.TypeParameter |
+    TypeFlags.IndexedAccess |
+    TypeFlags.Conditional |
+    TypeFlags.Index |
+    TypeFlags.Substitution;
+/**
+ * Whether every value of this type is truthy, `undefined` aside.
+ *
+ * Safe: `true`, `symbol`, `object`, a non-falsy literal, `undefined`, `void`,
+ * `never`, and an object type that is callable or to which none of `""`, `0`
+ * and `false` is assignable. Unions and intersections are read part by part,
+ * unresolved types through their constraint. Everything else is not claimed.
+ *
+ * @param checker  Needed to resolve a constraint and to ask whether a falsy
+ *   primitive fits an object type; without one only a callable object is claimed.
+ */
+export const isSameAsBangBang = (type, checker) => {
+    const isEach = (part) => isSameAsBangBang(part, checker);
+    if (type.isUnion() || type.isIntersection())
+        return type.types.every(isEach);
+    if (type.flags & UNRESOLVED) {
+        const constraint = type.isTypeParameter() ? type.getConstraint() : checker?.getBaseConstraintOfType(type);
+        // No constraint means no bound on what it holds.
+        return !!constraint && isEach(constraint);
+    }
+    if (type.flags & (TypeFlags.Undefined | TypeFlags.Void | TypeFlags.Never)) {
+        return true;
+    }
+    if (type.flags & TypeFlags.BooleanLiteral) {
+        return type.intrinsicName === "true";
+    }
+    if (type.flags & (TypeFlags.ESSymbolLike | TypeFlags.NonPrimitive)) {
+        return true;
+    }
+    if (type.flags & TypeFlags.Object) {
+        /**
+         * A callable or constructable type is truthy. Any other object type is only
+         * as good as what the falsy primitives do against it: `{}`, `Object` and
+         * `{ length: number }` all accept `""`, `0` or `false`.
+         */
+        if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0)
+            return true;
+        if (!checker)
+            return false;
+        return [checker.getStringLiteralType(""), checker.getNumberLiteralType(0), checker.getFalseType()].every((falsy) => !checker.isTypeAssignableTo(falsy, type));
+    }
+    // A literal is as truthy as its value: only `""`, `0` and `0n` are falsy.
+    if (type.isStringLiteral())
+        return type.value !== "";
+    if (type.isNumberLiteral())
+        return type.value !== 0;
+    if (type.flags & TypeFlags.BigIntLiteral) {
+        return type.value.base10Value !== "0";
+    }
+    // A primitive, `any`, `unknown`, or a flag not named above.
+    return false;
+};
+const isUndefined = (side) => side.type === AST_NODE_TYPES.Identifier && side.name === "undefined";
+/** `x !== undefined` / `undefined === x`; `present` is what the check wants. */
+export const undefinedComparison = (node) => {
+    if (node?.type !== AST_NODE_TYPES.BinaryExpression)
+        return undefined;
+    if (node.operator !== "!==" && node.operator !== "===")
+        return undefined;
+    const isPresent = node.operator === "!==";
+    if (isUndefined(node.left) && !isUndefined(node.right))
+        return { value: node.right, isPresent };
+    if (isUndefined(node.right) && !isUndefined(node.left))
+        return { value: node.left, isPresent };
+    return undefined;
+};

package/dist/react-native.js

@@ -4,12 +4,14 @@ import { createNodeResolver } from 'eslint-plugin-import-x';
 import globals from 'globals';
 import noSecrets from 'eslint-plugin-no-secrets';
 import reactNativeA11y from './plugins/react-native-a11y/index.js';
-import { CODE_FILES, NUMBER_GLOBAL_RESTRICTIONS, raiseWarnings, REACT_BOOLEAN_NAME_OPTIONS, reactConfigs, TEST_FILES, } from './shared.js';
+import { CODE_FILES, NUMBER_GLOBAL_RESTRICTIONS, raiseWarnings, REACT_BOOLEAN_NAME_OPTIONS, REACT_RESTRICTED_SYNTAX, reactConfigs, TEST_FILES, } from './shared.js';
 const A11Y = '@hypersolid-dev/react-native-a11y';
-// Derived instead of hardcoded: the frozen `confusing-browser-globals` list (last released 2021) misses `document`,
-// `localStorage` and `getComputedStyle`, and bans `self`, which React Native defines. `globals` is maintained,
-// so new browser APIs are picked up without editing this file.
-// Globals Hermes provides that `globals['react-native']` does not list yet; remove a name once `globals` adds it.
+/**
+ * Derived instead of hardcoded: the frozen `confusing-browser-globals` list (last released 2021) misses `document`,
+ * `localStorage` and `getComputedStyle`, and bans `self`, which React Native defines. `globals` is maintained,
+ * so new browser APIs are picked up without editing this file.
+ * Globals Hermes provides that `globals['react-native']` does not list yet; remove a name once `globals` adds it.
+ */
 const HERMES_GLOBALS = new Set(['atob', 'btoa', 'TextEncoder']);
 const BROWSER_GLOBALS = Object.keys(globals.browser).filter((name) => !(name in globals['react-native']) && !HERMES_GLOBALS.has(name));
 // High-entropy strings in Expo and native config that are identifiers, not credentials.
@@ -21,8 +23,10 @@ const NO_SECRETS_IGNORE = [
     '^[A-Z][A-Za-z0-9]*\\/[A-Z][A-Za-z0-9]*$', // i18n `Namespace/Key` paths
     '^data:', // Lottie and embedded images
 ];
-// Metro picks `Button.ios.tsx` for `./Button` on iOS; the resolvers must try the same platform files, or
-// `import-x/no-unresolved` flags every platform-split module. Platform files first, as Metro resolves them.
+/**
+ * Metro picks `Button.ios.tsx` for `./Button` on iOS; the resolvers must try the same platform files, or
+ * `import-x/no-unresolved` flags every platform-split module. Platform files first, as Metro resolves them.
+ */
 const RESOLVE_EXTENSIONS = ['.ios', '.android', '.native', '.web', ''].flatMap((platform) => ['.ts', '.tsx', '.d.ts', '.js', '.jsx', '.mjs', '.cjs', '.json'].map((extension) => `${platform}${extension}`));
 // Metro's default asset extensions plus Expo's additions, and json (source or asset); from eslint-config-expo.
 const METRO_ASSET_EXTENSIONS = [
@@ -70,9 +74,11 @@ export default function reactNative() {
                         message: `\`${name}\` is a browser global, undefined on React Native: a local of that name was meant, or the value comes from a React Native API.`,
                     })),
                 ],
-                // Unicorn rules that push toward APIs the React Native runtime lacks (Hermes in RN 0.85 and RN's fetch/Blob/URL
-                // polyfills); the suggested fix crashes at runtime. Re-check when RN bumps Hermes.
-                // `toSorted` is missing from Hermes. Bad: `values.toSorted(compare)` suggested for `values.sort(compare)`.
+                /**
+                 * Unicorn rules that push toward APIs the React Native runtime lacks (Hermes in RN 0.85 and RN's fetch/Blob/URL
+                 * polyfills); the suggested fix crashes at runtime. Re-check when RN bumps Hermes.
+                 * `toSorted` is missing from Hermes. Bad: `values.toSorted(compare)` suggested for `values.sort(compare)`.
+                 */
                 'unicorn/no-array-sort': 'off',
                 // Iterator helpers are missing from Hermes. Bad: `map.values().map(double).toArray()`.
                 'unicorn/prefer-iterator-helpers': 'off',
@@ -99,6 +105,51 @@ export default function reactNative() {
                 ],
                 // High-entropy strings that look like credentials, minus Expo and native identifiers. Bad: `const token = 'ghp_Zx8kQ2vLm9…'`.
                 'no-secrets/no-secrets': ['error', { ignoreContent: NO_SECRETS_IGNORE }],
+                // The React entries, plus `pointerEvents` as a prop: it belongs in the style. Bad: `<View pointerEvents="none" />`.
+                'no-restricted-syntax': [
+                    'error',
+                    ...REACT_RESTRICTED_SYNTAX,
+                    {
+                        selector: ":matches(JSXAttribute[name.name='pointerEvents'], JSXSpreadAttribute > ObjectExpression > Property[key.name='pointerEvents'])",
+                        message: "Put `pointerEvents` in the style (`pointerEvents: 'none'`); the prop is deprecated.",
+                    },
+                ],
+                // Deprecated or JS-thread APIs from `react-native`. Bad: `InteractionManager.runAfterInteractions(load)`, `import { Animated } from 'react-native'`.
+                '@typescript-eslint/no-restricted-imports': [
+                    'error',
+                    {
+                        paths: [
+                            {
+                                name: 'react-native',
+                                importNames: ['InteractionManager'],
+                                message: 'Deprecated in the New Architecture. Use `requestIdleCallback` or `startTransition`.',
+                                allowTypeImports: true,
+                            },
+                            {
+                                name: 'react-native',
+                                importNames: ['Animated'],
+                                message: 'Use react-native-reanimated, which runs animations on the UI thread; `Animated` runs them on the JS thread and needs `useNativeDriver`.',
+                                allowTypeImports: true,
+                            },
+                        ],
+                    },
+                ],
+                // `testID` is lowercase kebab-case, so test selectors match exactly. Bad: `testID="Header.Title"`.
+                '@hypersolid-dev/test-id-format': 'error',
+                // A WebView allows every origin and filters each navigation in `onShouldStartLoadWithRequest`. Bad: `<WebView source={{ uri }} />`.
+                '@hypersolid-dev/webview-allow-list': 'error',
+            },
+        },
+        {
+            // Reusable components only: a screen is one instance, so a written id is fine there.
+            name: '@hypersolid-dev/react-native/components',
+            files: ['**/components/**/*.tsx'],
+            ignores: TEST_FILES,
+            rules: {
+                // A component's `testID` comes from its props, so two instances stay apart. Bad: `<View testID="card" />` inside `Card`.
+                '@hypersolid-dev/test-id-from-props': 'error',
+                // The `testID` prop defaults to the component's kebab-case name. Bad: `({ testID }: Props)` in `Card` (use `testID = 'card'`).
+                '@hypersolid-dev/test-id-default': 'error',
             },
         },
         {
@@ -160,8 +211,10 @@ export default function reactNative() {
                 [`${A11Y}/no-unnamed-interactive`]: 'error',
                 // Images opt out of iOS Smart Invert or render as a negative. Bad: `<Image source={source} accessibilityLabel="A cat" />`.
                 [`${A11Y}/require-invert-colors-opt-out`]: 'error',
-                // Off: a sheet is whatever a project calls one, so the rule has no defaults. Enable it with the project's sheet components:
-                // `['error', { additionalComponents: ['BottomSheet'] }]`. Bad then: `<BottomSheet><Text>Body</Text></BottomSheet>`.
+                /**
+                 * Off: a sheet is whatever a project calls one, so the rule has no defaults. Enable it with the project's sheet components:
+                 * `['error', { additionalComponents: ['BottomSheet'] }]`. Bad then: `<BottomSheet><Text>Body</Text></BottomSheet>`.
+                 */
                 [`${A11Y}/require-modal-a11y-on-sheets`]: 'off',
             },
         },

package/dist/shared.d.ts

@@ -12,6 +12,25 @@ export declare const NUMBER_GLOBAL_RESTRICTIONS: {
     name: string;
     message: string;
 }[];
+/** `no-restricted-syntax` entries per preset; a later config replaces the options, so each preset spreads the ones before it. */
+export declare const BASE_RESTRICTED_SYNTAX: {
+    selector: string;
+    message: string;
+}[];
+export declare const REACT_RESTRICTED_SYNTAX: {
+    selector: string;
+    message: string;
+}[];
+/** `@typescript-eslint/naming-convention` entries per preset, for the same reason. Destructured names come from elsewhere (`const { user_id } = payload`). */
+export declare const NAMING_CONVENTION: ({
+    selector: string;
+    modifiers: string[];
+    format: null;
+} | {
+    selector: string;
+    format: string[];
+    modifiers?: undefined;
+})[];
 export declare function raiseWarnings(configs: Linter.Config[]): Linter.Config[];
 export declare function scopeToCode(configs: readonly Linter.Config[]): Linter.Config[];
 export declare function reactConfigs(): Linter.Config[];