@ashstack/lint 0.1.0

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

@@ -0,0 +1,62 @@
+import { componentName, problem, tagIdentifier } from "../../../lib/ast.js";
+const TOUCHABLES = new Set(["Pressable", "PressableScale", "TouchableOpacity", "TouchableHighlight"]);
+const MESSAGES = {
+    touchable: "Add an `accessibilityLabel` (plus an `accessibilityHint` when the outcome is not obvious), or render a visible `<Text>` child, so this icon-only touchable has an accessible name.",
+    expoButton: "Add a `label`, or an `accessibilityLabel(...)` modifier, so this icon-only Expo UI `<Button>` has an accessible name.",
+};
+/** A plain (non-namespaced) attribute's name; anything else reads as `undefined`. */
+const plainAttributeName = (attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" ? attribute.name.name : undefined;
+const hasAccessibleName = (attributes) => attributes.some(attribute => {
+    const name = plainAttributeName(attribute);
+    return name === "accessibilityLabel" || name === "accessibilityHint";
+});
+const childKinds = (children) => {
+    const kinds = { hasIcon: false, hasText: false, hasExpression: false };
+    for (const child of children) {
+        if (child.type === "JSXExpressionContainer")
+            kinds.hasExpression = true;
+        if (child.type === "JSXText" && child.value.trim() !== "")
+            kinds.hasText = true;
+        if (child.type !== "JSXElement")
+            continue;
+        const childTag = tagIdentifier(child.openingElement.name);
+        if (childTag === "Text")
+            kinds.hasText = true;
+        if (childTag.endsWith("Icon"))
+            kinds.hasIcon = true;
+    }
+    return kinds;
+};
+export const noUnlabeledIconPressable = problem("Require an accessible name on an icon-only touchable or an icon-only Expo UI `<Button>`. Without a label, hint or visible text, a screen reader cannot reach the control.", {
+    createOnce(context) {
+        return {
+            JSXElement(node) {
+                const opening = node.openingElement;
+                if (!TOUCHABLES.has(componentName(opening.name)))
+                    return;
+                if (hasAccessibleName(opening.attributes))
+                    return;
+                const { hasIcon, hasText, hasExpression } = childKinds(node.children);
+                if (!hasIcon || hasText || hasExpression)
+                    return;
+                context.report({ node: opening.name, message: MESSAGES.touchable });
+            },
+            JSXOpeningElement(node) {
+                if (!node.selfClosing)
+                    return;
+                if (componentName(node.name) !== "Button")
+                    return;
+                const names = new Set(node.attributes.map(plainAttributeName).filter(Boolean));
+                if (!names.has("systemImage"))
+                    return;
+                if (names.has("label") ||
+                    names.has("accessibilityLabel") ||
+                    names.has("accessibilityHint") ||
+                    names.has("modifiers")) {
+                    return;
+                }
+                context.report({ node: node.name, message: MESSAGES.expoButton });
+            },
+        };
+    },
+});

package/dist/react-native/rules/reanimated/animated-reaction-safety.d.ts

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

package/dist/react-native/rules/reanimated/animated-reaction-safety.js

@@ -0,0 +1,110 @@
+import { calleeName, gate, hasAncestor, isMemberCall, isWithin, problem, receiverName, subtreeHas, } from "../../../lib/ast.js";
+const MESSAGES = {
+    hotBridgeUnguarded: "Guard this `scheduleOnRN` by comparing the current and previous prepared results, so high-frequency input does not bridge to RN every frame.",
+    hotBridgeNoPrevious: "Take the previous prepared result as the callback's second parameter and guard `scheduleOnRN` on it differing from the current one, so high-frequency input does not bridge to RN every frame.",
+};
+const REACTION_HOOKS = new Set(["useAnimatedReaction"]);
+const NOT_EQUAL_OPERATORS = new Set(["!==", "!="]);
+const identifierName = (node) => (node?.type === "Identifier" ? node.name : null);
+const comparesWithNotEqual = (test, first, second) => {
+    if (test.type !== "BinaryExpression" || !NOT_EQUAL_OPERATORS.has(test.operator))
+        return false;
+    const left = identifierName(test.left);
+    const right = identifierName(test.right);
+    return (left === first && right === second) || (left === second && right === first);
+};
+const comparesWithNegatedIs = (test, first, second) => {
+    if (test.type !== "UnaryExpression" || test.operator !== "!")
+        return false;
+    const { argument } = test;
+    if (argument.type !== "CallExpression" || calleeName(argument) !== "is")
+        return false;
+    const compared = argument.arguments;
+    return (compared.some(entry => identifierName(entry) === first) && compared.some(entry => identifierName(entry) === second));
+};
+/** True when an enclosing `if` tests the two callback parameters against each other. */
+const guardsComparison = (node, first, second) => {
+    if (!first || !second)
+        return false;
+    return hasAncestor(node, current => {
+        if (current.type !== "IfStatement")
+            return false;
+        const { test } = current;
+        return comparesWithNotEqual(test, first, second) || comparesWithNegatedIs(test, first, second);
+    });
+};
+/** True when a `.set()`/`.modify()` in the result callback writes what the prepare callback reads. */
+const feedsOwnInput = (node, reaction) => {
+    if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression")
+        return false;
+    const shared = receiverName(node);
+    if (!shared)
+        return false;
+    if (reaction.type !== "CallExpression")
+        return false;
+    const [prepare, react] = reaction.arguments;
+    if (!prepare || !react || !isWithin(node, react))
+        return false;
+    return subtreeHas(prepare, current => isMemberCall(current, "get") && receiverName(current) === shared);
+};
+/** The parameters of the reaction's result callback, or null when the second argument is not a function. */
+const resultCallbackParams = (reaction) => {
+    if (reaction.type !== "CallExpression")
+        return null;
+    const callback = reaction.arguments[1];
+    if (callback?.type !== "FunctionDeclaration" &&
+        callback?.type !== "FunctionExpression" &&
+        callback?.type !== "ArrowFunctionExpression") {
+        return null;
+    }
+    return callback.params;
+};
+/** What is wrong with a `scheduleOnRN` inside a reaction, or null when it is guarded. */
+const hotBridgeProblem = (node, reaction) => {
+    const params = resultCallbackParams(reaction);
+    if (!params)
+        return null;
+    const previous = identifierName(params[1]);
+    if (!previous)
+        return MESSAGES.hotBridgeNoPrevious;
+    return guardsComparison(node, identifierName(params[0]), previous) ? null : MESSAGES.hotBridgeUnguarded;
+};
+export const animatedReactionSafety = problem("A `useAnimatedReaction` result callback loops forever if it writes a shared value the prepare callback reads. Guard `scheduleOnRN` there on the current result differing from the previous one.", {
+    createOnce(context) {
+        let stack = [];
+        return {
+            before() {
+                stack = [];
+                return gate(context, "useAnimatedReaction");
+            },
+            CallExpression(node) {
+                const name = calleeName(node);
+                if (REACTION_HOOKS.has(name)) {
+                    stack.push(node);
+                    return;
+                }
+                const reaction = stack.at(-1);
+                if (!reaction)
+                    return;
+                if (name === "set" || name === "modify") {
+                    if (!feedsOwnInput(node, reaction))
+                        return;
+                    context.report({
+                        node,
+                        message: `Have this result callback ${name === "set" ? "write" : "modify"} a shared value its prepare callback does not read, or gate the call on a comparison; feeding its own input loops forever.`,
+                    });
+                    return;
+                }
+                if (name !== "scheduleOnRN")
+                    return;
+                const problemMessage = hotBridgeProblem(node, reaction);
+                if (problemMessage !== null)
+                    context.report({ node, message: problemMessage });
+            },
+            "CallExpression:exit"(node) {
+                if (REACTION_HOOKS.has(calleeName(node)))
+                    stack.pop();
+            },
+        };
+    },
+});

package/dist/react-native/rules/reanimated/animated-style-needs-animated-component.d.ts

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

package/dist/react-native/rules/reanimated/animated-style-needs-animated-component.js

@@ -0,0 +1,72 @@
+import { attributeName, calleeName, gate, problem, tagPath } from "../../../lib/ast.js";
+import { ANIMATED_STYLE_HOOKS } from "./shared.js";
+const NEEDS_ANIMATED_COMPONENT = "Render this with the matching `Animated.*` component so the animated style takes effect. On a plain element the style is applied once at mount and never updates, and nothing errors.";
+const ANIMATED_COMPONENT_FACTORIES = new Set(["createAnimatedComponent", "withUnistyles", "withAnimated"]);
+/** The tag name node of an element, whether handed the element or its opening tag. */
+const elementName = (node) => {
+    if (node.type === "JSXElement")
+        return node.openingElement.name;
+    if (node.type === "JSXOpeningElement")
+        return node.name;
+    return null;
+};
+/** The identifiers a `style` prop value names, whether it holds one style or an array of them. */
+const referencedStyleNames = (value) => {
+    if (value?.type !== "JSXExpressionContainer")
+        return [];
+    const { expression } = value;
+    if (expression.type === "Identifier")
+        return [expression.name];
+    if (expression.type !== "ArrayExpression")
+        return [];
+    return expression.elements.flatMap(element => (element?.type === "Identifier" ? [element.name] : []));
+};
+export const animatedStyleNeedsAnimatedComponent = problem("An animated style only takes effect on an `Animated.*` component. A plain element applies it once at mount and then never updates.", {
+    createOnce(context) {
+        let animatedStyles = new Set();
+        let animatedComponents = new Set();
+        let candidates = [];
+        return {
+            before() {
+                animatedStyles = new Set();
+                animatedComponents = new Set();
+                candidates = [];
+                return gate(context, "useAnimatedStyle", "useAnimatedProps");
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type !== "Identifier")
+                    return;
+                if (init?.type !== "CallExpression")
+                    return;
+                const callee = calleeName(init);
+                if (ANIMATED_STYLE_HOOKS.has(callee))
+                    animatedStyles.add(id.name);
+                else if (ANIMATED_COMPONENT_FACTORIES.has(callee))
+                    animatedComponents.add(id.name);
+            },
+            "Program:exit"() {
+                if (animatedStyles.size === 0)
+                    return;
+                for (const { node, tag, referenced } of candidates) {
+                    if (animatedComponents.has(tag))
+                        continue;
+                    if (!referenced.some(name => animatedStyles.has(name)))
+                        continue;
+                    context.report({ node, message: NEEDS_ANIMATED_COMPONENT });
+                }
+            },
+            JSXAttribute(node) {
+                if (attributeName(node) !== "style")
+                    return;
+                const tag = tagPath(elementName(node.parent));
+                if (tag === "" || tag.startsWith("Animated"))
+                    return;
+                const referenced = referencedStyleNames(node.value);
+                if (referenced.length === 0)
+                    return;
+                candidates.push({ node, tag, referenced });
+            },
+        };
+    },
+});

package/dist/react-native/rules/reanimated/animated-updater-purity.d.ts

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

package/dist/react-native/rules/reanimated/animated-updater-purity.js

@@ -0,0 +1,38 @@
+import { calleeName, problem } from "../../../lib/ast.js";
+import { ANIMATED_STYLE_HOOKS } from "./shared.js";
+const UPDATER_SIDE_EFFECT = "Schedule this RN side effect from an animation completion callback or `useAnimatedReaction` instead; `useAnimatedStyle`/`useAnimatedProps` updaters must stay pure.";
+export const animatedUpdaterPurity = problem("An updater passed to `useAnimatedStyle` or `useAnimatedProps` must stay pure, so it may not write a shared value or call `scheduleOnRN`.", {
+    createOnce(context) {
+        let depth = 0;
+        return {
+            before() {
+                depth = 0;
+            },
+            CallExpression(node) {
+                const name = calleeName(node);
+                if (ANIMATED_STYLE_HOOKS.has(name)) {
+                    depth += 1;
+                    return;
+                }
+                if (depth === 0)
+                    return;
+                if (name === "set" || name === "modify") {
+                    if (node.callee.type !== "MemberExpression")
+                        return;
+                    context.report({
+                        node,
+                        message: `Move this \`.${name}()\` write out to an event handler, an effect, a derived value, or \`useAnimatedReaction\`; \`useAnimatedStyle\`/\`useAnimatedProps\` updaters must stay pure.`,
+                    });
+                    return;
+                }
+                if (name !== "scheduleOnRN")
+                    return;
+                context.report({ node, message: UPDATER_SIDE_EFFECT });
+            },
+            "CallExpression:exit"(node) {
+                if (ANIMATED_STYLE_HOOKS.has(calleeName(node)))
+                    depth -= 1;
+            },
+        };
+    },
+});

package/dist/react-native/rules/reanimated/gpu-properties-only.d.ts

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

package/dist/react-native/rules/reanimated/gpu-properties-only.js

@@ -0,0 +1,80 @@
+import { calleeName, gate, problem } from "../../../lib/ast.js";
+import { ANIMATED_STYLE_HOOKS } from "./shared.js";
+const GPU_PROPERTIES_ONLY = "Animate `transform` and `opacity` instead: a panel that grows is `scaleY` with `transformOrigin`, a thing that slides is `translateY`. This property recalculates layout on every frame.";
+/** Style properties whose animation forces a layout pass. */
+const LAYOUT_PROPS = new Set([
+    "width",
+    "height",
+    "minWidth",
+    "minHeight",
+    "maxWidth",
+    "maxHeight",
+    "top",
+    "left",
+    "right",
+    "bottom",
+    "start",
+    "end",
+    "flex",
+    "flexBasis",
+    "padding",
+    "paddingTop",
+    "paddingBottom",
+    "paddingLeft",
+    "paddingRight",
+    "paddingStart",
+    "paddingEnd",
+    "paddingHorizontal",
+    "paddingVertical",
+    "margin",
+    "marginTop",
+    "marginBottom",
+    "marginLeft",
+    "marginRight",
+    "marginStart",
+    "marginEnd",
+    "marginHorizontal",
+    "marginVertical",
+    "gap",
+    "rowGap",
+    "columnGap",
+]);
+const styleKeyName = (property) => {
+    if (property.type !== "Property")
+        return null;
+    const { key } = property;
+    if (key.type === "Identifier")
+        return key.name;
+    if (key.type === "Literal")
+        return String(key.value);
+    return null;
+};
+export const gpuPropertiesOnly = problem("Animate `transform` and `opacity` in `useAnimatedStyle` and `useAnimatedProps`. Layout properties such as `width` or `margin` recalculate layout every frame.", {
+    createOnce(context) {
+        let depth = 0;
+        return {
+            before() {
+                depth = 0;
+                return gate(context, "useAnimatedStyle", "useAnimatedProps");
+            },
+            CallExpression(node) {
+                if (ANIMATED_STYLE_HOOKS.has(calleeName(node)))
+                    depth += 1;
+            },
+            "CallExpression:exit"(node) {
+                if (ANIMATED_STYLE_HOOKS.has(calleeName(node)))
+                    depth -= 1;
+            },
+            Property(node) {
+                if (depth === 0)
+                    return;
+                if (node.parent.type !== "ObjectExpression")
+                    return;
+                const name = styleKeyName(node);
+                if (name !== null && LAYOUT_PROPS.has(name)) {
+                    context.report({ node, message: GPU_PROPERTIES_ONLY });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/reanimated/hoist-layout-animation-builder.d.ts

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

package/dist/react-native/rules/reanimated/hoist-layout-animation-builder.js

@@ -0,0 +1,43 @@
+import { calleeName, findInSubtree, FUNCTION_TYPES, hasAncestor, problem } from "../../../lib/ast.js";
+const LAYOUT_BUILDER = "Build this layout animation at module scope when it is static, or memoize it when it depends on component values.";
+const LAYOUT_ATTRIBUTES = new Set(["entering", "exiting", "layout"]);
+const LAYOUT_BUILDER_METHODS = new Set([
+    "duration",
+    "delay",
+    "springify",
+    "damping",
+    "stiffness",
+    "mass",
+    "easing",
+    "withCallback",
+    "withInitialValues",
+    "withTargetValues",
+]);
+/** The builder call inside a layout-animation prop value, if there is one. */
+const findBuilderCall = (value) => findInSubtree(value, current => {
+    if (current.type !== "CallExpression" || current.callee.type !== "MemberExpression")
+        return false;
+    const { property } = current.callee;
+    return property.type === "Identifier" && LAYOUT_BUILDER_METHODS.has(property.name);
+});
+const MEMO_HOOKS = new Set(["useMemo", "useCallback"]);
+export const hoistLayoutAnimationBuilder = problem("A layout animation belongs at module scope, or inside a memo when it depends on component values. The `entering`/`exiting`/`layout` props otherwise rebuild it on every render.", {
+    createOnce(context) {
+        return {
+            JSXAttribute(node) {
+                if (node.name.type !== "JSXIdentifier")
+                    return;
+                if (!LAYOUT_ATTRIBUTES.has(node.name.name))
+                    return;
+                if (!hasAncestor(node, current => FUNCTION_TYPES.has(current.type)))
+                    return;
+                const builderCall = findBuilderCall(node.value);
+                if (!builderCall)
+                    return;
+                if (hasAncestor(builderCall, current => MEMO_HOOKS.has(calleeName(current))))
+                    return;
+                context.report({ node: builderCall, message: LAYOUT_BUILDER });
+            },
+        };
+    },
+});

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

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

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

@@ -0,0 +1,51 @@
+import { defineModule } from "../../../lib/module.js";
+import { animatedReactionSafety } from "./animated-reaction-safety.js";
+import { animatedStyleNeedsAnimatedComponent } from "./animated-style-needs-animated-component.js";
+import { animatedUpdaterPurity } from "./animated-updater-purity.js";
+import { gpuPropertiesOnly } from "./gpu-properties-only.js";
+import { hoistLayoutAnimationBuilder } from "./hoist-layout-animation-builder.js";
+import { interpolateNeedsClamp } from "./interpolate-needs-clamp.js";
+import { noReactStateFromContinuousWorklet } from "./no-react-state-from-continuous-worklet.js";
+import { noSharedValueDotValue } from "./no-shared-value-dot-value.js";
+import { preferLazySharedValueInitializer } from "./prefer-lazy-shared-value-initializer.js";
+import { scheduleOnRnScope } from "./schedule-on-rn-scope.js";
+import { sharedValueUsage } from "./shared-value-usage.js";
+export default defineModule({
+    meta: { name: "@ashstack/reanimated" },
+    url: import.meta.url,
+    packages: ["react-native-reanimated"],
+    option: "reanimated",
+    docsWhen: "auto-enabled when `react-native-reanimated` is a dependency",
+    rules: {
+        "animated-reaction-safety": animatedReactionSafety,
+        "animated-style-needs-animated-component": animatedStyleNeedsAnimatedComponent,
+        "animated-updater-purity": animatedUpdaterPurity,
+        "gpu-properties-only": gpuPropertiesOnly,
+        "hoist-layout-animation-builder": hoistLayoutAnimationBuilder,
+        "interpolate-needs-clamp": interpolateNeedsClamp,
+        "no-shared-value-dot-value": noSharedValueDotValue,
+        "no-react-state-from-continuous-worklet": noReactStateFromContinuousWorklet,
+        "prefer-lazy-shared-value-initializer": preferLazySharedValueInitializer,
+        "schedule-on-rn-scope": scheduleOnRnScope,
+        "shared-value-usage": sharedValueUsage,
+    },
+    restrictedImports: {
+        paths: [
+            {
+                name: "react-native",
+                importNames: ["Animated"],
+                message: "Use `react-native-reanimated` instead of React Native's `Animated` API.",
+            },
+            {
+                name: "react-native-reanimated",
+                importNames: ["runOnJS", "runOnUI"],
+                message: "Use `scheduleOnRN` and `scheduleOnUI` from `react-native-worklets`; `runOnJS` and `runOnUI` are deprecated.",
+            },
+            {
+                name: "react-native-worklets",
+                importNames: ["runOnJS", "runOnUI"],
+                message: "Use `scheduleOnRN` and `scheduleOnUI` from `react-native-worklets`; `runOnJS` and `runOnUI` are deprecated.",
+            },
+        ],
+    },
+});

package/dist/react-native/rules/reanimated/interpolate-needs-clamp.d.ts

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

package/dist/react-native/rules/reanimated/interpolate-needs-clamp.js

@@ -0,0 +1,41 @@
+import { gate, problem } from "../../../lib/ast.js";
+const MISSING = "Pass `Extrapolation.CLAMP` as the fourth argument to `interpolate`. Without it the output keeps extrapolating past the input range, so a scroll offset of 400 against `[0, 100]` runs well past where it should stop.";
+const NOT_CLAMPING = "Change this fourth argument to `Extrapolation.CLAMP`. `EXTEND` and `IDENTITY` both keep extrapolating past the input range, so a scroll offset of 400 against `[0, 100]` runs well past where it should stop.";
+const NON_CLAMPING = new Set(["EXTEND", "IDENTITY", "extend", "identity"]);
+/** An extrapolation this rule can see is not clamping. An opaque one — a variable, a call — reports nothing. */
+const isNonClamping = (node) => {
+    if (node.type === "Literal")
+        return typeof node.value === "string" && NON_CLAMPING.has(node.value);
+    if (node.type === "Identifier")
+        return NON_CLAMPING.has(node.name);
+    if (node.type === "MemberExpression") {
+        return node.property.type === "Identifier" && NON_CLAMPING.has(node.property.name);
+    }
+    if (node.type === "ObjectExpression") {
+        return node.properties.some(property => property.type === "Property" && isNonClamping(property.value));
+    }
+    return false;
+};
+export const interpolateNeedsClamp = problem("Give `interpolate()` a fourth argument that clamps. Without one, or with `EXTEND` or `IDENTITY`, the output keeps going past the ends of the input range.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "interpolate");
+            },
+            CallExpression(node) {
+                const { callee, arguments: args } = node;
+                if (callee.type !== "Identifier" || callee.name !== "interpolate")
+                    return;
+                if (args.length < 3 || args.length > 4)
+                    return;
+                if (args.some(argument => argument.type === "SpreadElement"))
+                    return;
+                const extrapolation = args[3];
+                if (extrapolation === undefined)
+                    context.report({ node, message: MISSING });
+                else if (isNonClamping(extrapolation))
+                    context.report({ node: extrapolation, message: NOT_CLAMPING });
+            },
+        };
+    },
+});

package/dist/react-native/rules/reanimated/no-react-state-from-continuous-worklet.d.ts

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

package/dist/react-native/rules/reanimated/no-react-state-from-continuous-worklet.js

@@ -0,0 +1,86 @@
+import { calleeName, enclosingCall, gate, importedSpecifiers, isFunction, problem, subtreeHas, } from "../../../lib/ast.js";
+const CONTINUOUS_WORKLET_STATE = "Keep this gate in shared or native state, or apply it through an imperative ref. A continuously evaluated worklet that schedules React state can land a Fabric commit or a Skia re-recording on an animation frame.";
+/** Hooks whose callback is re-evaluated as the animation runs. */
+const CONTINUOUS_HOOKS = new Set([
+    "useAnimatedReaction",
+    "useFrameCallback",
+    "useDerivedValue",
+    "useAnimatedStyle",
+    "useAnimatedProps",
+    "useAnimatedScrollHandler",
+]);
+/** True for `import { name } from ...` — a named import, not a default or namespace one. */
+const importsName = (specifier, name) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === name;
+/** The setters this argument names, whether handed over directly or called inside an inline callback. */
+const settersReached = (target) => {
+    if (target.type === "Identifier")
+        return [target.name];
+    if (!isFunction(target))
+        return [];
+    const called = [];
+    subtreeHas(target, current => {
+        if (current.type === "CallExpression" && current.callee.type === "Identifier")
+            called.push(current.callee.name);
+        return false;
+    });
+    return called;
+};
+export const noReactStateFromContinuousWorklet = problem("A worklet that runs every frame must not send a React state setter through `scheduleOnRN`. That puts a Fabric commit on an animation frame.", {
+    createOnce(context) {
+        const setters = new Set();
+        const pending = [];
+        let useStateFromReact = false;
+        let scheduleFromWorklets = false;
+        return {
+            before() {
+                setters.clear();
+                pending.length = 0;
+                useStateFromReact = false;
+                scheduleFromWorklets = false;
+                return gate(context, "scheduleOnRN");
+            },
+            ImportDeclaration(node) {
+                for (const specifier of importedSpecifiers(node, "react")) {
+                    if (importsName(specifier, "useState"))
+                        useStateFromReact = true;
+                }
+                for (const specifier of importedSpecifiers(node, "react-native-worklets")) {
+                    if (importsName(specifier, "scheduleOnRN"))
+                        scheduleFromWorklets = true;
+                }
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type !== "ArrayPattern")
+                    return;
+                if (init?.type !== "CallExpression")
+                    return;
+                if (init.callee.type !== "Identifier" || init.callee.name !== "useState")
+                    return;
+                const setter = id.elements[1];
+                if (setter?.type === "Identifier")
+                    setters.add(setter.name);
+            },
+            CallExpression(node) {
+                if (calleeName(node) !== "scheduleOnRN")
+                    return;
+                const target = node.arguments[0];
+                if (target === undefined)
+                    return;
+                if (!enclosingCall(node, CONTINUOUS_HOOKS))
+                    return;
+                for (const name of settersReached(target))
+                    pending.push({ node, name });
+            },
+            "Program:exit"() {
+                if (!useStateFromReact || !scheduleFromWorklets)
+                    return;
+                for (const entry of pending) {
+                    if (!setters.has(entry.name))
+                        continue;
+                    context.report({ node: entry.node, message: CONTINUOUS_WORKLET_STATE });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/reanimated/no-shared-value-dot-value.d.ts

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