@ashstack/lint 0.1.0

package/dist/react-native/rules/legend-state/no-untracked-get-in-jsx.js

@@ -0,0 +1,52 @@
+import { gate, problem } from "../../../lib/ast.js";
+import { isObservableRef, textOf } from "./shared.js";
+export const noUntrackedGetInJsx = problem("A `get()` placed directly in a JSX expression container is a plain read. The value renders once and never updates.", {
+    createOnce(context) {
+        let functionDepth = 0;
+        let functionDepthAtContainerStart = [];
+        const enterFunction = () => {
+            functionDepth++;
+        };
+        const exitFunction = () => {
+            functionDepth--;
+        };
+        const directlyInJsxContainer = () => functionDepthAtContainerStart.length > 0 &&
+            functionDepthAtContainerStart[functionDepthAtContainerStart.length - 1] === functionDepth;
+        return {
+            before() {
+                functionDepth = 0;
+                functionDepthAtContainerStart = [];
+                return gate(context, ".get()");
+            },
+            FunctionDeclaration: enterFunction,
+            "FunctionDeclaration:exit": exitFunction,
+            FunctionExpression: enterFunction,
+            "FunctionExpression:exit": exitFunction,
+            ArrowFunctionExpression: enterFunction,
+            "ArrowFunctionExpression:exit": exitFunction,
+            JSXExpressionContainer() {
+                functionDepthAtContainerStart.push(functionDepth);
+            },
+            "JSXExpressionContainer:exit"() {
+                functionDepthAtContainerStart.pop();
+            },
+            CallExpression(node) {
+                if (!directlyInJsxContainer())
+                    return;
+                const { callee } = node;
+                if (callee.type !== "MemberExpression" || callee.computed)
+                    return;
+                if (callee.property.type !== "Identifier" || callee.property.name !== "get")
+                    return;
+                const { object } = callee;
+                if (!isObservableRef(object))
+                    return;
+                const target = textOf(context, object);
+                context.report({
+                    node,
+                    message: `Read it with \`useValue(${target})\` at the top of the component, or wrap this fragment in \`<Memo>\` so the read happens inside a tracking context. A \`get()\` here is a plain read, so it renders the first value and never updates.`,
+                });
+            },
+        };
+    },
+});

package/dist/react-native/rules/legend-state/shared.d.ts

@@ -0,0 +1,9 @@
+import type { AstNode, RuleContext } from "../../../lib/types.js";
+export declare const OBSERVABLE_FACTORIES: Set<string>;
+/** The trailing `$` that marks an observable binding. */
+export declare const OBS: RegExp;
+export declare const isObservableRef: (node: AstNode | null | undefined) => boolean;
+/** The factory name when this call is `observable(...)` or `useObservable(...)`. */
+export declare const factoryCalled: (node: AstNode | null | undefined) => string | null;
+/** Source text for a node, for quoting it back in a message. */
+export declare const textOf: (context: RuleContext, node: AstNode) => string;

package/dist/react-native/rules/legend-state/shared.js

@@ -0,0 +1,23 @@
+export const OBSERVABLE_FACTORIES = new Set(["observable", "useObservable"]);
+/** The trailing `$` that marks an observable binding. */
+export const OBS = /\$$/;
+/** The identifier a member chain is rooted at: `count$`, or the `settings$` of `settings$.theme.color`. */
+const rootName = (node) => {
+    let current = node;
+    while (current?.type === "MemberExpression")
+        current = current.object;
+    return current?.type === "Identifier" ? current.name : null;
+};
+export const isObservableRef = (node) => {
+    const root = rootName(node);
+    return root != null && OBS.test(root);
+};
+/** The factory name when this call is `observable(...)` or `useObservable(...)`. */
+export const factoryCalled = (node) => {
+    if (node?.type !== "CallExpression")
+        return null;
+    const { callee } = node;
+    return callee.type === "Identifier" && OBSERVABLE_FACTORIES.has(callee.name) ? callee.name : null;
+};
+/** Source text for a node, for quoting it back in a message. */
+export const textOf = (context, node) => context.sourceCode.getText(node);

package/dist/react-native/rules/react-native/hoist-stateless-function.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const hoistStatelessFunction: Rule;

package/dist/react-native/rules/react-native/hoist-stateless-function.js

@@ -0,0 +1,59 @@
+import { ancestors, COMPONENT_OR_HOOK, isFunction, problem } from "../../../lib/ast.js";
+const COMPONENT_NAME = /^[A-Z]/;
+const boundFunctionName = (node) => {
+    if (node.type === "FunctionDeclaration")
+        return node.id?.name ?? null;
+    const { parent } = node;
+    if (parent === null || parent.type !== "VariableDeclarator" || parent.id.type !== "Identifier")
+        return null;
+    return parent.id.name;
+};
+const enclosingReactFunction = (node) => {
+    for (const current of ancestors(node)) {
+        if (!isFunction(current))
+            continue;
+        const name = boundFunctionName(current);
+        if (name !== null && COMPONENT_OR_HOOK.test(name))
+            return current;
+    }
+    return null;
+};
+const scopeContains = (scope, ancestor) => {
+    for (let current = scope; current !== null && current !== undefined; current = current.upper) {
+        if (current === ancestor)
+            return true;
+    }
+    return false;
+};
+const readsComponentScope = (scope, componentScope) => {
+    for (const reference of scope.through) {
+        if (scopeContains(reference.resolved?.scope, componentScope))
+            return true;
+    }
+    return false;
+};
+export const hoistStatelessFunction = problem("Require module scope for a non-component function that reads nothing from the component around it. Out there it is created once, keeps a stable identity, and can be tested without rendering.", {
+    createOnce(context) {
+        const check = (node) => {
+            const name = boundFunctionName(node);
+            if (name === null || COMPONENT_NAME.test(name))
+                return;
+            const component = enclosingReactFunction(node);
+            if (component === null)
+                return;
+            const scope = context.sourceCode.getScope(node);
+            const componentScope = context.sourceCode.getScope(component);
+            if (readsComponentScope(scope, componentScope))
+                return;
+            context.report({
+                node,
+                message: `Move \`${name}\` to module scope: it reads nothing from the component, so out there it is created once and keeps a stable identity without memoising. If it was meant to read a prop or a piece of state, wire that read up instead.`,
+            });
+        };
+        return {
+            FunctionDeclaration: check,
+            FunctionExpression: check,
+            ArrowFunctionExpression: check,
+        };
+    },
+});

package/dist/react-native/rules/react-native/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../../index.js").ModuleManifest;
+export default _default;

package/dist/react-native/rules/react-native/index.js

@@ -0,0 +1,50 @@
+import { defineModule } from "../../../lib/module.js";
+import { hoistStatelessFunction } from "./hoist-stateless-function.js";
+import { noConditionalStyleArray } from "./no-conditional-style-array.js";
+import { noDynamicImport } from "./no-dynamic-import.js";
+import { noKeyboardWillEvents } from "./no-keyboard-will-events.js";
+import { noLeakedRender } from "./no-leaked-render.js";
+import { noManualMemo } from "./no-manual-memo.js";
+import { noRedundantViewNesting } from "./no-redundant-view-nesting.js";
+import { noRnImageNetworkSource } from "./no-rn-image-network-source.js";
+import { noRnNamespaceImport } from "./no-rn-namespace-import.js";
+import { noScrollPositionState } from "./no-scroll-position-state.js";
+import { noUnlabeledIconPressable } from "./no-unlabeled-icon-pressable.js";
+export default defineModule({
+    meta: { name: "@ashstack/react-native" },
+    url: import.meta.url,
+    docsWhen: "always on via `reactNative()`",
+    rules: {
+        "no-keyboard-will-events": noKeyboardWillEvents,
+        "no-scroll-position-state": noScrollPositionState,
+        "no-conditional-style-array": noConditionalStyleArray,
+        "no-leaked-render": noLeakedRender,
+        "no-rn-image-network-source": noRnImageNetworkSource,
+        "no-redundant-view-nesting": noRedundantViewNesting,
+        "no-rn-namespace-import": noRnNamespaceImport,
+        "no-unlabeled-icon-pressable": noUnlabeledIconPressable,
+        "hoist-stateless-function": hoistStatelessFunction,
+        "no-manual-memo": noManualMemo,
+        "no-dynamic-import": noDynamicImport,
+    },
+    restrictedImports: {
+        paths: [
+            {
+                name: "react",
+                importNames: ["forwardRef"],
+                message: "Accept `ref` as a regular prop and delete the `forwardRef` wrapper — React 19 passes `ref` like any other prop.",
+            },
+            {
+                name: "react",
+                importNames: ["useContext"],
+                message: "Call `use(Context)` instead of `useContext(Context)`; React 19 replaces the hook with it.",
+            },
+        ],
+        patterns: [
+            {
+                group: ["expo-linear-gradient", "react-native-linear-gradient"],
+                message: "Apply the gradient through the `experimental_backgroundImage` style property instead of a gradient component.",
+            },
+        ],
+    },
+});

package/dist/react-native/rules/react-native/no-conditional-style-array.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noConditionalStyleArray: Rule;

package/dist/react-native/rules/react-native/no-conditional-style-array.js

@@ -0,0 +1,23 @@
+import { problem } from "../../../lib/ast.js";
+const MESSAGE = "Move the condition into a Unistyles dynamic style function: `card: (active: boolean) => ({ ... })`, then `style={styles.card(active)}`. A conditional entry can evaluate to a falsy hole, which shifts the array indices and breaks the Unistyles C++ proxy.";
+export const noConditionalStyleArray = problem("Disallow conditional and logical entries inside a JSX `style` array. A falsy entry leaves a hole that breaks the Unistyles C++ proxy.", {
+    createOnce(context) {
+        return {
+            JSXAttribute(node) {
+                if (node.name.type !== "JSXIdentifier" || node.name.name !== "style")
+                    return;
+                const { value } = node;
+                if (value?.type !== "JSXExpressionContainer")
+                    return;
+                const array = value.expression;
+                if (array.type !== "ArrayExpression")
+                    return;
+                for (const element of array.elements) {
+                    if (element?.type !== "ConditionalExpression" && element?.type !== "LogicalExpression")
+                        continue;
+                    context.report({ node: element, message: MESSAGE });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/react-native/no-dynamic-import.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noDynamicImport: Rule;

package/dist/react-native/rules/react-native/no-dynamic-import.js

@@ -0,0 +1,18 @@
+import { calleeName, gate, hasAncestor, problem } from "../../../lib/ast.js";
+const LAZY_WRAPPERS = new Set(["lazy", "dynamic"]);
+const MESSAGE = "Turn this into a static `import` at the top of the file. Metro inlines `import()` into the same bundle, so it buys no laziness and only hides the module from the typechecker; wrapping it in `React.lazy(() => import(...))` or `dynamic(() => import(...))` stays allowed.";
+export const noDynamicImport = problem("Disallow dynamic `import()` outside a `React.lazy` or `dynamic` wrapper. Metro inlines it into the same bundle, so nothing is deferred and the module is hidden from the typechecker.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "import(");
+            },
+            ImportExpression(node) {
+                if (hasAncestor(node, current => current.type === "CallExpression" && LAZY_WRAPPERS.has(calleeName(current)))) {
+                    return;
+                }
+                context.report({ node, message: MESSAGE });
+            },
+        };
+    },
+});

package/dist/react-native/rules/react-native/no-keyboard-will-events.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noKeyboardWillEvents: Rule;

package/dist/react-native/rules/react-native/no-keyboard-will-events.js

@@ -0,0 +1,18 @@
+import { gate, problem } from "../../../lib/ast.js";
+const IOS_ONLY_EVENT_NAMES = new Set(["keyboardWillShow", "keyboardWillHide", "keyboardWillChangeFrame"]);
+const MESSAGE = "Drive this from `rt.insets.ime`, which updates per frame on both platforms, or from a `react-native-keyboard-controller` component. `keyboardWill*` events are iOS-only, so on Android the listener registers and never fires.";
+const isIosOnlyEventName = (node) => node.type === "Literal" && typeof node.value === "string" && IOS_ONLY_EVENT_NAMES.has(node.value);
+export const noKeyboardWillEvents = problem("Disallow the `keyboardWill*` event names. They are iOS-only, so on Android the listener registers and never fires.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "keyboardWill");
+            },
+            Literal(node) {
+                if (!isIosOnlyEventName(node))
+                    return;
+                context.report({ node, message: MESSAGE });
+            },
+        };
+    },
+});

package/dist/react-native/rules/react-native/no-leaked-render.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noLeakedRender: Rule;

package/dist/react-native/rules/react-native/no-leaked-render.js

@@ -0,0 +1,43 @@
+import { problem } from "../../../lib/ast.js";
+const MESSAGE = 'Compare explicitly (`list.length > 0 &&`), coerce with `!!`, or use a ternary ending in `null`. A falsy number or string leaks into the tree: `0` renders a bare zero, which crashes React Native with "Text strings must be rendered within a <Text> component".';
+const COUNT_PROPERTIES = new Set(["length", "size"]);
+const ARITHMETIC = new Set(["+", "-", "*", "/", "%", "**"]);
+/**
+ * A guard this rule can see is a number or a string, rather than one it merely
+ * cannot prove is a boolean. `{isOpen && …}` stays quiet; `{count - 1 && …}`
+ * does not. Only the right side of an `&&` chain decides, since that is the
+ * value that reaches the tree.
+ */
+const leaksAValue = (node) => {
+    if (node === undefined)
+        return false;
+    if (node.type === "MemberExpression") {
+        return node.property.type === "Identifier" && COUNT_PROPERTIES.has(node.property.name);
+    }
+    if (node.type === "Literal")
+        return typeof node.value === "number" || typeof node.value === "string";
+    if (node.type === "BinaryExpression")
+        return ARITHMETIC.has(node.operator);
+    if (node.type === "TemplateLiteral")
+        return true;
+    if (node.type === "LogicalExpression" && node.operator === "&&")
+        return leaksAValue(node.right);
+    return false;
+};
+export const noLeakedRender = problem('Disallow a `&&` guard in JSX on a value this rule can see is a number or a string — a `.length`, a `.size`, arithmetic, a literal. The falsy left operand leaks into the output, and a bare `0` crashes React Native with "Text strings must be rendered within a <Text> component".', {
+    createOnce(context) {
+        return {
+            JSXExpressionContainer(node) {
+                const parentType = node.parent.type;
+                if (parentType !== "JSXElement" && parentType !== "JSXFragment")
+                    return;
+                const expression = node.expression;
+                if (expression.type !== "LogicalExpression" || expression.operator !== "&&")
+                    return;
+                if (!leaksAValue(expression.left))
+                    return;
+                context.report({ node: expression, message: MESSAGE });
+            },
+        };
+    },
+});

package/dist/react-native/rules/react-native/no-manual-memo.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noManualMemo: Rule;

package/dist/react-native/rules/react-native/no-manual-memo.js

@@ -0,0 +1,87 @@
+import { gate, problem } from "../../../lib/ast.js";
+const MEMO_APIS = new Set(["useMemo", "useCallback", "memo"]);
+const REACT_COMPILER_PACKAGES = ["babel-plugin-react-compiler", "react-compiler-runtime", "react-compiler-marker"];
+const WHY_COMMENT = /^why:/i;
+const NEWLINE = 10;
+const bareMemoName = (callee) => callee.type === "Identifier" && MEMO_APIS.has(callee.name) ? callee.name : null;
+const reactNamespacedMemoName = (callee) => {
+    if (callee.type !== "MemberExpression" || callee.computed)
+        return null;
+    if (callee.object.type !== "Identifier" || callee.object.name !== "React")
+        return null;
+    const property = callee.property.name;
+    return MEMO_APIS.has(property) ? property : null;
+};
+const memoCalleeName = (node) => {
+    if (node.type !== "CallExpression")
+        return null;
+    const { callee } = node;
+    if (callee.type === "Identifier")
+        return bareMemoName(callee);
+    if (callee.type === "MemberExpression")
+        return reactNamespacedMemoName(callee);
+    return null;
+};
+const lineStartOffsets = (text) => {
+    const starts = [0];
+    for (let index = 0; index < text.length; index++) {
+        if (text.charCodeAt(index) === NEWLINE)
+            starts.push(index + 1);
+    }
+    return starts;
+};
+const lineContaining = (starts, offset) => {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+        const middle = Math.floor((low + high + 1) / 2);
+        if ((starts[middle] ?? 0) <= offset)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return low;
+};
+const linesCoveredByWhyComments = (comments, lineOf) => {
+    const covered = new Set();
+    for (const comment of comments) {
+        if (!WHY_COMMENT.test(comment.value.trim()))
+            continue;
+        for (let line = lineOf(comment.start); line <= lineOf(comment.end); line++)
+            covered.add(line);
+    }
+    return covered;
+};
+export const noManualMemo = problem("Disallow `useMemo`, `useCallback` and `memo` unless a `why:` comment on the line above states the case the React Compiler cannot see: something rendered per list row, or a cost that was measured.", {
+    meta: { packages: REACT_COMPILER_PACKAGES },
+    createOnce(context) {
+        let calls = [];
+        return {
+            before() {
+                calls = [];
+                return gate(context, "useMemo", "useCallback", "memo");
+            },
+            CallExpression(node) {
+                const name = memoCalleeName(node);
+                if (name !== null)
+                    calls.push({ node, name });
+            },
+            "Program:exit"() {
+                if (calls.length === 0)
+                    return;
+                const lineStarts = lineStartOffsets(context.sourceCode.getText());
+                const lineOf = (offset) => lineContaining(lineStarts, offset);
+                const justified = linesCoveredByWhyComments(context.sourceCode.getAllComments(), lineOf);
+                for (const { node, name } of calls) {
+                    const line = lineOf(node.start);
+                    if (justified.has(line) || justified.has(line - 1))
+                        continue;
+                    context.report({
+                        node,
+                        message: `Drop this \`${name}\` and let the React Compiler memoise it. Keep it only for what the compiler cannot see — something rendered per row in a list, or a computation you measured as heavy — and write a \`why:\` comment on the line above saying which of the two it is.`,
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/react-native/no-redundant-view-nesting.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noRedundantViewNesting: Rule;

package/dist/react-native/rules/react-native/no-redundant-view-nesting.js

@@ -0,0 +1,36 @@
+import { problem, tagPath } from "../../../lib/ast.js";
+const LAYOUT_ONLY_PROPS = new Set(["style"]);
+const MERGEABLE_WRAPPERS = new Set(["View", "Animated.View"]);
+const elementChildren = (children) => children.filter(child => child.type !== "JSXText" || child.value.trim() !== "");
+const onlyLayoutProps = (attributes) => attributes.every(attribute => attribute.type === "JSXAttribute" &&
+    attribute.name.type === "JSXIdentifier" &&
+    LAYOUT_ONLY_PROPS.has(attribute.name.name));
+export const noRedundantViewNesting = problem("Disallow a View or Animated.View that wraps an identical view when neither carries anything but a style. Every extra host view is a real node in the native tree.", {
+    createOnce(context) {
+        return {
+            JSXElement(node) {
+                const opening = node.openingElement;
+                const tag = tagPath(opening.name);
+                if (!MERGEABLE_WRAPPERS.has(tag))
+                    return;
+                if (!onlyLayoutProps(opening.attributes))
+                    return;
+                const children = elementChildren(node.children);
+                if (children.length !== 1)
+                    return;
+                const child = children[0];
+                if (child?.type !== "JSXElement")
+                    return;
+                const childOpening = child.openingElement;
+                if (tagPath(childOpening.name) !== tag)
+                    return;
+                if (!onlyLayoutProps(childOpening.attributes))
+                    return;
+                context.report({
+                    node: opening.name,
+                    message: `Merge these two <${tag}> style objects into the inner one and delete the outer wrapper — each carries nothing but a style, and every extra host view is a real node in the native tree.`,
+                });
+            },
+        };
+    },
+});

package/dist/react-native/rules/react-native/no-rn-image-network-source.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noRnImageNetworkSource: Rule;

package/dist/react-native/rules/react-native/no-rn-image-network-source.js

@@ -0,0 +1,58 @@
+import { componentName, gate, importedSpecifiers, problem } from "../../../lib/ast.js";
+const MESSAGE = "Render this network image with `TurboImage` (react-native-turbo-image), passing `resize` and `cachePolicy`; keep react-native `<Image>` for local `require(...)` assets. RN `<Image>` has no disk cache and no decode sizing, so it re-downloads and decodes at full size on every cold start.";
+/** A property key reads by name (`{ uri }`) or, for a string key, by value (`{ "uri" }`). */
+const keyName = (key) => {
+    if (key.type === "Identifier")
+        return key.name;
+    return key.type === "Literal" && typeof key.value === "string" ? key.value : undefined;
+};
+const hasUriProperty = (attribute) => {
+    if (attribute.type !== "JSXAttribute")
+        return false;
+    const { value } = attribute;
+    const expression = value?.type === "JSXExpressionContainer" ? value.expression : undefined;
+    if (expression?.type !== "ObjectExpression")
+        return false;
+    return expression.properties.some(property => property.type === "Property" && keyName(property.key) === "uri");
+};
+export const noRnImageNetworkSource = problem("Disallow a react-native `<Image>` with a network `{ uri }` source. It has no disk cache and no decode sizing, so the image re-downloads at full size on every cold start.", {
+    createOnce(context) {
+        const imageBindings = new Set();
+        const candidates = [];
+        return {
+            before() {
+                imageBindings.clear();
+                candidates.length = 0;
+                return gate(context, "source");
+            },
+            ImportDeclaration(node) {
+                for (const specifier of importedSpecifiers(node, "react-native")) {
+                    if (specifier.type !== "ImportSpecifier")
+                        continue;
+                    const { imported } = specifier;
+                    if (imported.type === "Identifier" && imported.name === "Image") {
+                        imageBindings.add(specifier.local.name);
+                    }
+                }
+            },
+            JSXOpeningElement(node) {
+                const tag = componentName(node.name);
+                if (tag === "")
+                    return;
+                const source = node.attributes.find(attribute => attribute.type === "JSXAttribute" &&
+                    attribute.name.type === "JSXIdentifier" &&
+                    attribute.name.name === "source");
+                if (!source || !hasUriProperty(source))
+                    return;
+                candidates.push({ node: node.name, tag });
+            },
+            "Program:exit"() {
+                for (const candidate of candidates) {
+                    if (!imageBindings.has(candidate.tag))
+                        continue;
+                    context.report({ node: candidate.node, message: MESSAGE });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/react-native/no-rn-namespace-import.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noRnNamespaceImport: Rule;

package/dist/react-native/rules/react-native/no-rn-namespace-import.js

@@ -0,0 +1,38 @@
+import { gate, problem } from "../../../lib/ast.js";
+const MESSAGES = {
+    namespaceImport: 'Import the react-native APIs by name instead: `import { View, Platform } from "react-native"`. A namespace import defeats Metro platform shaking, so dead `Platform.OS` branches ship in both bundles.',
+    platformReExport: "Drop this re-export and have each consumer import `Platform` straight from react-native; re-exporting it defeats Metro platform shaking.",
+};
+export const noRnNamespaceImport = problem("Disallow a namespace import of react-native and a re-export of its `Platform`. Both defeat Metro's platform shaking, so dead `Platform.OS` branches ship in both bundles.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "react-native");
+            },
+            ImportDeclaration(node) {
+                if (node.source.value !== "react-native")
+                    return;
+                for (const specifier of node.specifiers) {
+                    if (specifier.type !== "ImportNamespaceSpecifier")
+                        continue;
+                    context.report({ node: specifier, message: MESSAGES.namespaceImport });
+                }
+            },
+            ExportAllDeclaration(node) {
+                if (node.source.value !== "react-native")
+                    return;
+                context.report({ node, message: MESSAGES.namespaceImport });
+            },
+            ExportNamedDeclaration(node) {
+                if (node.source?.value !== "react-native")
+                    return;
+                for (const specifier of node.specifiers) {
+                    const { local } = specifier;
+                    if (local.type !== "Identifier" || local.name !== "Platform")
+                        continue;
+                    context.report({ node: specifier, message: MESSAGES.platformReExport });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/react-native/no-scroll-position-state.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noScrollPositionState: Rule;

package/dist/react-native/rules/react-native/no-scroll-position-state.js

@@ -0,0 +1,26 @@
+import { attributeName, gate, problem, subtreeHas } from "../../../lib/ast.js";
+const SCROLL_HANDLERS = new Set(["onScroll", "onScrollBeginDrag", "onScrollEndDrag", "onMomentumScrollEnd"]);
+const STATE_SETTER = /^set[A-Z]/;
+const MESSAGE = "Use `useAnimatedScrollHandler` with a shared value when this drives an animation, or a ref when nothing renders from it. Scroll fires every frame, so a state setter here re-renders the screen every frame.";
+export const noScrollPositionState = problem("Disallow a React state setter inside a scroll handler prop. Scroll fires every frame, and so would the re-render.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, ...SCROLL_HANDLERS);
+            },
+            JSXAttribute(node) {
+                if (!SCROLL_HANDLERS.has(attributeName(node)))
+                    return;
+                const { value } = node;
+                const expression = value?.type === "JSXExpressionContainer" ? value.expression : undefined;
+                if (expression?.type !== "ArrowFunctionExpression" && expression?.type !== "FunctionExpression")
+                    return;
+                const setsState = subtreeHas(expression.body, current => current.type === "CallExpression" &&
+                    current.callee.type === "Identifier" &&
+                    STATE_SETTER.test(current.callee.name));
+                if (setsState)
+                    context.report({ node, message: MESSAGE });
+            },
+        };
+    },
+});

package/dist/react-native/rules/react-native/no-unlabeled-icon-pressable.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noUnlabeledIconPressable: Rule;