@hypersolid-dev/eslint-config 5.0.0 → 7.0.0

package/dist/plugins/{rules → react-native/rules}/test-id-from-props.js

@@ -1,6 +1,6 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
-import createRule from '../utils/create-rule.js';
-import { leavesOf } from '../utils/expressions.js';
+import createRule from '../../shared/create-rule.js';
+import { leavesOf } from '../../shared/expressions.js';
 /**
  * A component's `testID` comes from its props, never a string it writes itself.
  *
@@ -23,11 +23,9 @@ import { leavesOf } from '../utils/expressions.js';
  */
 const TEST_ID = 'testID';
 /** A value spelled out where it stands, rather than reached for. */
-function isWritten(node) {
-    return (node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string') || (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0);
-}
+const isWritten = (node) => (node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string') || (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0);
 /** Whether an expression reaches outside itself for its value. */
-function readsAName(context, node) {
+const isReadingAName = (context, node) => {
     switch (node.type) {
         // A local name bound to a written string is that string; anything unresolved is trusted.
         case AST_NODE_TYPES.Identifier:
@@ -41,26 +39,26 @@ function readsAName(context, node) {
         case AST_NODE_TYPES.TemplateLiteral:
             return node.expressions.length > 0 && node.quasis[0]?.value.cooked === '';
         case AST_NODE_TYPES.ConditionalExpression:
-            return readsAName(context, node.consequent) || readsAName(context, node.alternate);
+            return isReadingAName(context, node.consequent) || isReadingAName(context, node.alternate);
         case AST_NODE_TYPES.LogicalExpression:
-            return readsAName(context, node.left) || readsAName(context, node.right);
+            return isReadingAName(context, node.left) || isReadingAName(context, node.right);
         case AST_NODE_TYPES.TSAsExpression:
         case AST_NODE_TYPES.TSSatisfiesExpression:
         case AST_NODE_TYPES.TSNonNullExpression:
-            return readsAName(context, node.expression);
+            return isReadingAName(context, node.expression);
         default:
             return false;
     }
-}
+};
 /** How to name the offending id: a name is followed to the string behind it. */
-function writtenValue(context, node) {
+const writtenValue = (context, node) => {
     if (node?.type === AST_NODE_TYPES.Literal && typeof node.value === 'string')
         return `"${node.value}"`;
     const strings = (node ? leavesOf(context, node) : [])
         .filter(isWritten)
         .map((leaf) => (leaf.type === AST_NODE_TYPES.Literal ? leaf.value : leaf.quasis[0]?.value.cooked));
     return strings.length === 1 ? `"${String(strings[0])}"` : 'a fixed value';
-}
+};
 const testIdFromProps = createRule({
     name: 'test-id-from-props',
     meta: {
@@ -73,22 +71,20 @@ const testIdFromProps = createRule({
             prefixed: 'Start this `testID` from the `testID` prop rather than the written "{{ prefix }}": what follows it may differ per instance, but the prefix spells out a name the prop already carries, so a caller cannot scope or rename it. Write `` `${testID}-…` ``.',
         },
     },
-    create(context) {
-        return {
-            JSXAttribute(node) {
-                if (node.name.type !== AST_NODE_TYPES.JSXIdentifier || node.name.name !== TEST_ID)
-                    return;
-                const { value } = node;
-                const expression = value?.type === AST_NODE_TYPES.JSXExpressionContainer ? value.expression : (value ?? undefined);
-                if (value?.type === AST_NODE_TYPES.JSXExpressionContainer && readsAName(context, value.expression))
-                    return;
-                if (expression?.type === AST_NODE_TYPES.TemplateLiteral && expression.expressions.length > 0) {
-                    context.report({ node, messageId: 'prefixed', data: { prefix: expression.quasis[0]?.value.cooked } });
-                    return;
-                }
-                context.report({ node, messageId: 'static', data: { value: writtenValue(context, expression) } });
-            },
-        };
-    },
+    create: (context) => ({
+        JSXAttribute: (node) => {
+            if (node.name.type !== AST_NODE_TYPES.JSXIdentifier || node.name.name !== TEST_ID)
+                return;
+            const { value } = node;
+            const expression = value?.type === AST_NODE_TYPES.JSXExpressionContainer ? value.expression : (value ?? undefined);
+            if (value?.type === AST_NODE_TYPES.JSXExpressionContainer && isReadingAName(context, value.expression))
+                return;
+            if (expression?.type === AST_NODE_TYPES.TemplateLiteral && expression.expressions.length > 0) {
+                context.report({ node, messageId: 'prefixed', data: { prefix: expression.quasis[0]?.value.cooked } });
+                return;
+            }
+            context.report({ node, messageId: 'static', data: { value: writtenValue(context, expression) } });
+        },
+    }),
 });
 export default testIdFromProps;

package/dist/plugins/{rules → react-native/rules}/webview-allow-list.js

@@ -1,6 +1,6 @@
 import { AST_NODE_TYPES, TSESLint } from '@typescript-eslint/utils';
-import createRule from '../utils/create-rule.js';
-import { unwrap } from '../utils/expressions.js';
+import createRule from '../../shared/create-rule.js';
+import { unwrap } from '../../shared/expressions.js';
 /**
  * A `react-native-webview` `WebView` sends every navigation through its
  * `onShouldStartLoadWithRequest`, so that handler is the allow-list.
@@ -23,7 +23,7 @@ const SOURCE = 'react-native-webview';
 const WEBVIEW = 'WebView';
 const HANDLER = 'onShouldStartLoadWithRequest';
 /** Whether a JSX name resolves to the library's `WebView` import. */
-function isWebView(context, name) {
+const isWebView = (context, name) => {
     const identifier = name.type === AST_NODE_TYPES.JSXMemberExpression ? name.object : name;
     if (identifier.type !== AST_NODE_TYPES.JSXIdentifier)
         return false;
@@ -44,9 +44,9 @@ function isWebView(context, name) {
         return false;
     const imported = node.imported.type === AST_NODE_TYPES.Identifier ? node.imported.name : node.imported.value;
     return imported === WEBVIEW;
-}
+};
 /** `undefined`, `null`, or a branch that can be one: the prop is set and still absent. */
-function canBeAbsent(expression) {
+const canBeAbsent = (expression) => {
     switch (expression.type) {
         case AST_NODE_TYPES.JSXEmptyExpression:
             return true;
@@ -61,18 +61,16 @@ function canBeAbsent(expression) {
         default:
             return false;
     }
-}
-function attribute(opening, name) {
-    return opening.attributes.find((item) => item.type === AST_NODE_TYPES.JSXAttribute && item.name.name === name);
-}
+};
+const attribute = (opening, name) => opening.attributes.find((item) => item.type === AST_NODE_TYPES.JSXAttribute && item.name.name === name);
 /** Whether the prop's value is an inline array literal holding the string `"*"`. */
-function holdsWildcard(property) {
+const isHoldingWildcard = (property) => {
     const expression = unwrap(property.value?.type === AST_NODE_TYPES.JSXExpressionContainer ? property.value.expression : undefined);
     if (expression?.type !== AST_NODE_TYPES.ArrayExpression)
         return false;
     return expression.elements.some((element) => (element?.type === AST_NODE_TYPES.Literal && element.value === '*') ||
         (element?.type === AST_NODE_TYPES.TemplateLiteral && element.expressions.length === 0 && element.quasis[0]?.value.cooked === '*'));
-}
+};
 const webviewAllowList = createRule({
     name: 'webview-allow-list',
     meta: {
@@ -88,22 +86,20 @@ const webviewAllowList = createRule({
             narrowWhitelist: 'Make `originWhitelist` the inline `["*"]`: a URL outside the list skips `{{ handler }}` and the library opens it in another app, so the handler is the only allow-list that holds.',
         },
     },
-    create(context) {
-        return {
-            JSXOpeningElement(node) {
-                if (!isWebView(context, node.name))
-                    return;
-                const handler = attribute(node, HANDLER);
-                if (handler?.value?.type !== AST_NODE_TYPES.JSXExpressionContainer || canBeAbsent(handler.value.expression)) {
-                    context.report({ node, messageId: 'missingHandler', data: { handler: HANDLER } });
-                }
-                const whitelist = attribute(node, 'originWhitelist');
-                if (!whitelist)
-                    context.report({ node, messageId: 'missingWhitelist', data: { handler: HANDLER } });
-                else if (!holdsWildcard(whitelist))
-                    context.report({ node: whitelist, messageId: 'narrowWhitelist', data: { handler: HANDLER } });
-            },
-        };
-    },
+    create: (context) => ({
+        JSXOpeningElement: (node) => {
+            if (!isWebView(context, node.name))
+                return;
+            const handler = attribute(node, HANDLER);
+            if (handler?.value?.type !== AST_NODE_TYPES.JSXExpressionContainer || canBeAbsent(handler.value.expression)) {
+                context.report({ node, messageId: 'missingHandler', data: { handler: HANDLER } });
+            }
+            const whitelist = attribute(node, 'originWhitelist');
+            if (!whitelist)
+                context.report({ node, messageId: 'missingWhitelist', data: { handler: HANDLER } });
+            else if (!isHoldingWildcard(whitelist))
+                context.report({ node: whitelist, messageId: 'narrowWhitelist', data: { handler: HANDLER } });
+        },
+    }),
 });
 export default webviewAllowList;

package/dist/plugins/{utils → shared}/expressions.d.ts

@@ -28,13 +28,13 @@ export type LeavesOptions = {
     seen?: Set<Node>;
 };
 /** Through `as`, `satisfies`, `!` and `?.`. */
-export declare function unwrap(node: Node | null | undefined): Node | undefined;
+export declare const 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;
+export declare const keyOf: (property: Node) => string | null;
 /**
  * Every leaf an expression can produce.
  *
@@ -48,5 +48,5 @@ export declare function keyOf(property: Node): string | null;
  * 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 declare const leavesOf: (context: ScopeContext, node: Node | null | undefined, options?: LeavesOptions) => Node[];
 export {};

package/dist/plugins/{utils → shared}/expressions.js

@@ -8,14 +8,14 @@ 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) {
+export const 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) {
+const 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 &&
@@ -26,29 +26,27 @@ function memoHookName(callee) {
         return callee.property.name;
     }
     return undefined;
-}
-function findVariable(scope, name) {
+};
+const 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);
-}
+};
+const bindingOf = (context, identifier) => 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 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) {
+export const keyOf = (property) => {
     if (property.type !== AST_NODE_TYPES.Property)
         return null;
     const { key } = property;
@@ -57,13 +55,13 @@ export function keyOf(property) {
     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) {
+const 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.
@@ -71,37 +69,44 @@ function picked(pattern, init, name) {
         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;
+        return pickedFromObject(pattern, source, name);
     }
     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 pickedFromArray(pattern, source, name);
+    }
+    return undefined;
+};
+const pickedFromObject = (pattern, source, name) => {
+    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;
+};
+const pickedFromArray = (pattern, source, name) => {
+    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 boundTo = (context, identifier) => {
     const definition = bindingOf(context, identifier)?.defs[0];
     if (definition?.type === DefinitionType.FunctionName)
         return definition.node;
@@ -111,17 +116,17 @@ function boundTo(context, identifier) {
         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 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 returnsIn = (body) => {
     const found = [];
     const visit = (value) => {
         if (Array.isArray(value)) {
@@ -146,7 +151,7 @@ function returnsIn(body) {
     };
     visit(body);
     return found;
-}
+};
 /**
  * Every leaf an expression can produce.
  *
@@ -160,7 +165,7 @@ function returnsIn(body) {
  * 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 = {}) {
+export const 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) => {
@@ -171,31 +176,38 @@ export function leavesOf(context, node, options = {}) {
         for (const argument of returnsIn(fn.body))
             walk(argument);
     };
+    /** Each branch is a value for whatever slot the call sits in. */
+    const walkSelect = (branches) => {
+        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);
+            }
+        }
+    };
+    /** A call to a local function is what it returns (a factory); a method call is never followed. */
+    const factoryOf = (call) => {
+        if (!returns || call.callee.type !== AST_NODE_TYPES.Identifier)
+            return undefined;
+        const bound = boundTo(context, call.callee);
+        return bound && isFunction(bound) ? bound : undefined;
+    };
     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);
-                }
-            }
+            walkSelect(branches);
             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 factory = factoryOf(call);
+        if (factory) {
+            walk(factory);
+            return true;
         }
         const hook = memoHookName(call.callee);
         const callback = call.arguments.at(0);
@@ -208,6 +220,25 @@ export function leavesOf(context, node, options = {}) {
             walkFunction(callback);
         return true;
     };
+    /** `OBJ.key`'s value when `OBJ` is a local `const` object literal. */
+    const memberEntry = (member) => {
+        if (member.computed || member.object.type !== AST_NODE_TYPES.Identifier)
+            return undefined;
+        const declarator = localDeclarator(context, member.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)
+            return undefined;
+        const key = member.property.name;
+        const entry = held.properties.find((property) => keyOf(property) === key);
+        return entry?.type === AST_NODE_TYPES.Property ? entry.value : undefined;
+    };
+    /** What a name or `OBJ.key` stands for, when the options let it be followed. */
+    const referenced = (node) => {
+        if (node.type === AST_NODE_TYPES.Identifier)
+            return names ? boundTo(context, node) : undefined;
+        return members ? memberEntry(node) : undefined;
+    };
     const walk = (current) => {
         if (!current || seen.has(current))
             return;
@@ -229,26 +260,11 @@ export function leavesOf(context, node, options = {}) {
                 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.Identifier:
             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);
+                const target = referenced(current);
+                if (target) {
+                    walk(target);
                     return;
                 }
                 break;
@@ -271,4 +287,4 @@ export function leavesOf(context, node, options = {}) {
     };
     walk(node);
     return out;
-}
+};

package/dist/plugins/{utils → shared}/types.js

@@ -21,6 +21,18 @@ const UNRESOLVED = TypeFlags.TypeParameter |
     TypeFlags.Conditional |
     TypeFlags.Index |
     TypeFlags.Substitution;
+/**
+ * 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`.
+ */
+const isTruthyObject = (type, checker) => {
+    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));
+};
 /**
  * Whether every value of this type is truthy, `undefined` aside.
  *
@@ -50,18 +62,8 @@ export const isSameAsBangBang = (type, checker) => {
     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));
-    }
+    if (type.flags & TypeFlags.Object)
+        return isTruthyObject(type, checker);
     // A literal is as truthy as its value: only `""`, `0` and `0n` are falsy.
     if (type.isStringLiteral())
         return type.value !== "";

package/dist/react-native.js

@@ -1,11 +1,13 @@
 import expo from 'eslint-plugin-expo';
+import reactDoctor from 'eslint-plugin-react-doctor';
 import { createTypeScriptImportResolver } from 'eslint-import-resolver-typescript';
 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 reactNativeA11y from './plugins/react-native/a11y/index.js';
+import reactNativePlugin from './plugins/react-native/index.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';
+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,
@@ -44,7 +46,7 @@ export default function reactNative() {
             name: '@hypersolid-dev/react-native',
             files: CODE_FILES,
             // eslint-plugin-expo is typed with typescript-eslint's RuleModule, which ESLint's Plugin type does not accept.
-            plugins: { expo: expo, 'no-secrets': noSecrets },
+            plugins: { '@hypersolid-dev/react-native': reactNativePlugin, expo: expo, 'no-secrets': noSecrets },
             settings: {
                 'import-x/resolver-next': [
                     createTypeScriptImportResolver({ extensions: RESOLVE_EXTENSIONS }),
@@ -135,9 +137,9 @@ export default function reactNative() {
                     },
                 ],
                 // `testID` is lowercase kebab-case, so test selectors match exactly. Bad: `testID="Header.Title"`.
-                '@hypersolid-dev/test-id-format': 'error',
+                '@hypersolid-dev/react-native/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',
+                '@hypersolid-dev/react-native/webview-allow-list': 'error',
             },
         },
         {
@@ -147,9 +149,36 @@ export default function reactNative() {
             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',
+                '@hypersolid-dev/react-native/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',
+                '@hypersolid-dev/react-native/test-id-default': 'error',
+            },
+        },
+        {
+            // React Doctor's React Native rules, as used in the ESPN Goal pilot.
+            name: '@hypersolid-dev/react-native/react-doctor',
+            files: CODE_FILES,
+            ignores: TEST_FILES,
+            plugins: { 'react-doctor': reactDoctor },
+            rules: {
+                // A state update per scroll event re-renders mid-gesture; track position in a shared value. Bad: `onScroll={(event) => setOffset(event.nativeEvent.contentOffset.y)}`.
+                'react-doctor/rn-no-scroll-state': 'error',
+                // A reaction that only copies one value into another is a `useDerivedValue`. Bad: `useAnimatedReaction(() => x.value, (value) => { y.value = value; })`.
+                'react-doctor/rn-animation-reaction-as-derived': 'error',
+                // A string outside `<Text>` crashes on native. Bad: `<View>Hello</View>`.
+                'react-doctor/rn-no-raw-text': 'error',
+                // A list keys rows from `keyExtractor`; a `key` on the row is ignored. Bad: `renderItem={({ item }) => <Row key={item.id} />}`.
+                'react-doctor/rn-no-renderitem-key': 'error',
+                // A press animation set from `onPressIn` runs on the JS thread. Bad: `onPressIn={() => { scale.value = 0.9; }}`.
+                'react-doctor/rn-pressable-shared-value-mutation': 'error',
+                // `PanResponder` runs on the JS thread; `Gesture.Pan()` runs on the UI thread. Bad: `PanResponder.create({ … })`.
+                'react-doctor/rn-no-panresponder': 'error',
+                // `Dimensions.get()` reads the size once and misses rotation and split screen. Bad: `const { width } = Dimensions.get('window')` (use `useWindowDimensions`).
+                'react-doctor/rn-no-dimensions-get': 'error',
+                // `react-native/Libraries/…` paths are private and move on upgrade. Bad: `import … from 'react-native/Libraries/Image/resolveAssetSource'`.
+                'react-doctor/rn-no-deep-imports': 'error',
+                // Unmaintained Expo-era packages each have a successor. Bad: `import { Audio } from 'expo-av'` (use `expo-audio`).
+                'react-doctor/rn-no-legacy-expo-packages': 'error',
             },
         },
         {
@@ -170,7 +199,7 @@ export default function reactNative() {
             },
         },
         {
-            // React Native accessibility, each rule citing its WCAG criterion. Docs: src/plugins/react-native-a11y/docs.
+            // React Native accessibility, each rule citing its WCAG criterion. Docs: src/plugins/react-native/a11y/docs.
             name: '@hypersolid-dev/react-native/a11y',
             files: CODE_FILES,
             plugins: { [A11Y]: reactNativeA11y },

package/dist/shared.d.ts

@@ -31,6 +31,6 @@ export declare const NAMING_CONVENTION: ({
     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[];
+export declare const raiseWarnings: (configs: Linter.Config[]) => Linter.Config[];
+export declare const scopeToCode: (configs: readonly Linter.Config[]) => Linter.Config[];
+export declare const reactConfigs: () => Linter.Config[];