@ashstack/lint 0.1.0 → 0.2.0

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

@@ -1,80 +1 @@
-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 });
-                }
-            },
-        };
-    },
-});
+import{calleeName as i,gate as o,problem as s}from"../../../lib/ast.js";import{ANIMATED_STYLE_HOOKS as n}from"./shared.js";const p="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.",m=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"]),l=(a)=>{if(a.type!=="Property")return null;const{key:t}=a;if(t.type==="Identifier")return t.name;if(t.type==="Literal")return String(t.value);return null};export const gpuPropertiesOnly=s("Animate `transform` and `opacity` in `useAnimatedStyle` and `useAnimatedProps`. Layout properties such as `width` or `margin` recalculate layout every frame.",{createOnce(a){let t=0;return{before(){t=0;return o(a,"useAnimatedStyle","useAnimatedProps")},CallExpression(e){if(n.has(i(e)))t+=1},"CallExpression:exit"(e){if(n.has(i(e)))t-=1},Property(e){if(t===0)return;if(e.parent.type!=="ObjectExpression")return;const r=l(e);if(r!==null&&m.has(r))a.report({node:e,message:p})}}}});

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

@@ -1,43 +1 @@
-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 });
-            },
-        };
-    },
-});
+import{calleeName as s,findInSubtree as r,FUNCTION_TYPES as o,hasAncestor as a,problem as l}from"../../../lib/ast.js";const u="Build this layout animation at module scope when it is static, or memoize it when it depends on component values.",m=new Set(["entering","exiting","layout"]),p=new Set(["duration","delay","springify","damping","stiffness","mass","easing","withCallback","withInitialValues","withTargetValues"]),c=(n)=>r(n,(e)=>{if(e.type!=="CallExpression"||e.callee.type!=="MemberExpression")return!1;const{property:t}=e.callee;return t.type==="Identifier"&&p.has(t.name)}),d=new Set(["useMemo","useCallback"]);export const hoistLayoutAnimationBuilder=l("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(n){return{JSXAttribute(e){if(e.name.type!=="JSXIdentifier")return;if(!m.has(e.name.name))return;if(!a(e,(i)=>o.has(i.type)))return;const t=c(e.value);if(!t)return;if(a(t,(i)=>d.has(s(i))))return;n.report({node:t,message:u})}}}});

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

@@ -1,51 +1 @@
-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.",
-            },
-        ],
-    },
-});
+import{defineModule as e}from"../../../lib/module.js";import{animatedReactionSafety as a}from"./animated-reaction-safety.js";import{animatedStyleNeedsAnimatedComponent as t}from"./animated-style-needs-animated-component.js";import{animatedUpdaterPurity as r}from"./animated-updater-purity.js";import{gpuPropertiesOnly as n}from"./gpu-properties-only.js";import{hoistLayoutAnimationBuilder as o}from"./hoist-layout-animation-builder.js";import{interpolateNeedsClamp as i}from"./interpolate-needs-clamp.js";import{noReactStateFromContinuousWorklet as m}from"./no-react-state-from-continuous-worklet.js";import{noSharedValueDotValue as d}from"./no-shared-value-dot-value.js";import{preferLazySharedValueInitializer as s}from"./prefer-lazy-shared-value-initializer.js";import{scheduleOnRnScope as p}from"./schedule-on-rn-scope.js";import{sharedValueUsage as u}from"./shared-value-usage.js";export default e({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":a,"animated-style-needs-animated-component":t,"animated-updater-purity":r,"gpu-properties-only":n,"hoist-layout-animation-builder":o,"interpolate-needs-clamp":i,"no-shared-value-dot-value":d,"no-react-state-from-continuous-worklet":m,"prefer-lazy-shared-value-initializer":s,"schedule-on-rn-scope":p,"shared-value-usage":u},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.js

@@ -1,41 +1 @@
-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 });
-            },
-        };
-    },
-});
+import{gate as p,problem as l}from"../../../lib/ast.js";const u="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.",f="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.",s=new Set(["EXTEND","IDENTITY","extend","identity"]),o=(e)=>{if(e.type==="Literal")return typeof e.value==="string"&&s.has(e.value);if(e.type==="Identifier")return s.has(e.name);if(e.type==="MemberExpression")return e.property.type==="Identifier"&&s.has(e.property.name);if(e.type==="ObjectExpression")return e.properties.some((t)=>t.type==="Property"&&o(t.value));return!1};export const interpolateNeedsClamp=l("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(e){return{before(){return p(e,"interpolate")},CallExpression(t){const{callee:n,arguments:r}=t;if(n.type!=="Identifier"||n.name!=="interpolate")return;if(r.length<3||r.length>4)return;if(r.some((i)=>i.type==="SpreadElement"))return;const a=r[3];if(a===void 0)e.report({node:t,message:u});else if(o(a))e.report({node:a,message:f})}}}});

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

@@ -1,86 +1 @@
-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 });
-                }
-            },
-        };
-    },
-});
+import{calleeName as f,enclosingCall as m,gate as p,importedSpecifiers as c,isFunction as d,problem as h,subtreeHas as y}from"../../../lib/ast.js";const S="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.",O=new Set(["useAnimatedReaction","useFrameCallback","useDerivedValue","useAnimatedStyle","useAnimatedProps","useAnimatedScrollHandler"]),u=(t,a)=>t.type==="ImportSpecifier"&&t.imported.type==="Identifier"&&t.imported.name===a,R=(t)=>{if(t.type==="Identifier")return[t.name];if(!d(t))return[];const a=[];y(t,(n)=>{if(n.type==="CallExpression"&&n.callee.type==="Identifier")a.push(n.callee.name);return!1});return a};export const noReactStateFromContinuousWorklet=h("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(t){const a=new Set,n=[];let i=!1,o=!1;return{before(){a.clear();n.length=0;i=!1;o=!1;return p(t,"scheduleOnRN")},ImportDeclaration(e){for(const r of c(e,"react"))if(u(r,"useState"))i=!0;for(const r of c(e,"react-native-worklets"))if(u(r,"scheduleOnRN"))o=!0},VariableDeclarator(e){const{id:r,init:s}=e;if(r.type!=="ArrayPattern")return;if(s?.type!=="CallExpression")return;if(s.callee.type!=="Identifier"||s.callee.name!=="useState")return;const l=r.elements[1];if(l?.type==="Identifier")a.add(l.name)},CallExpression(e){if(f(e)!=="scheduleOnRN")return;const r=e.arguments[0];if(r===void 0)return;if(!m(e,O))return;for(const s of R(r))n.push({node:e,name:s})},"Program:exit"(){if(!i||!o)return;for(const e of n){if(!a.has(e.name))continue;t.report({node:e.node,message:S})}}}}});

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

@@ -1,112 +1 @@
-import { isProducerCall } from "./shared.js";
-const MESSAGES = {
-    read: "Read this shared value with `.get()` so the React Compiler can track the read.",
-    write: "Write this shared value with `.set(...)` so the React Compiler can track the mutation.",
-    compound: "Write this shared value with `.set(v => ...)`, or `.set(x.get() ...)`, so the React Compiler can track the mutation.",
-};
-const COMPOUND_OPERATORS = new Map([
-    ["+=", "+"],
-    ["-=", "-"],
-    ["*=", "*"],
-    ["/=", "/"],
-]);
-/** The identifier a plain `x.value` reads from, or null when the node is not one. */
-const dotValueOwner = (node) => {
-    if (node?.type !== "MemberExpression" || node.optional || node.computed)
-        return null;
-    const { object, property } = node;
-    if (object.type !== "Identifier")
-        return null;
-    if (property.type !== "Identifier" || property.name !== "value")
-        return null;
-    return object.name;
-};
-/** A parent that makes `x.value` a write target no `.get()` rewrite can stand in for. */
-const WRITE_TARGET_PARENTS = new Set([
-    "UpdateExpression",
-    "ArrayPattern",
-    "ObjectPattern",
-    "RestElement",
-    "AssignmentPattern",
-]);
-export const noSharedValueDotValue = {
-    meta: {
-        type: "problem",
-        docs: {
-            description: "Shared values are read with `.get()` and written with `.set(...)`, never through `.value`. React Compiler cannot track a `.value` access.",
-        },
-        hasSuggestions: true,
-    },
-    createOnce(context) {
-        const names = new Set();
-        const candidates = [];
-        return {
-            before() {
-                names.clear();
-                candidates.length = 0;
-            },
-            VariableDeclarator(node) {
-                if (node.id.type === "Identifier" && isProducerCall(node.init)) {
-                    names.add(node.id.name);
-                }
-            },
-            AssignmentExpression(node) {
-                const name = dotValueOwner(node.left);
-                if (name === null)
-                    return;
-                const operator = COMPOUND_OPERATORS.get(node.operator);
-                if (operator) {
-                    candidates.push({ kind: "compound", node, name, operator, right: node.right });
-                    return;
-                }
-                if (node.operator !== "=")
-                    return;
-                candidates.push({ kind: "write", node, name, right: node.right });
-            },
-            UpdateExpression(node) {
-                const name = dotValueOwner(node.argument);
-                if (name === null)
-                    return;
-                candidates.push({ kind: "update", node, name });
-            },
-            MemberExpression(node) {
-                const name = dotValueOwner(node);
-                if (name === null)
-                    return;
-                if (node.parent.type === "AssignmentExpression" && node.parent.left === node)
-                    return;
-                if (WRITE_TARGET_PARENTS.has(node.parent.type))
-                    return;
-                candidates.push({ kind: "read", node, name });
-            },
-            "Program:exit"() {
-                for (const candidate of candidates) {
-                    const { node, name } = candidate;
-                    if (!names.has(name))
-                        continue;
-                    if (candidate.kind === "update") {
-                        context.report({ node, message: MESSAGES.compound });
-                        continue;
-                    }
-                    if (candidate.kind === "read") {
-                        context.report({
-                            node,
-                            message: MESSAGES.read,
-                            suggest: [{ desc: `Rewrite as ${name}.get()`, fix: fixer => fixer.replaceText(node, `${name}.get()`) }],
-                        });
-                        continue;
-                    }
-                    const right = context.sourceCode.getText(candidate.right);
-                    const replacement = candidate.kind === "compound"
-                        ? `${name}.set(${name}.get() ${candidate.operator} (${right}))`
-                        : `${name}.set(${right})`;
-                    context.report({
-                        node,
-                        message: candidate.kind === "compound" ? MESSAGES.compound : MESSAGES.write,
-                        suggest: [{ desc: `Rewrite as ${name}.set(...)`, fix: fixer => fixer.replaceText(node, replacement) }],
-                    });
-                }
-            },
-        };
-    },
-};
+import{isProducerCall as l}from"./shared.js";const s={read:"Read this shared value with `.get()` so the React Compiler can track the read.",write:"Write this shared value with `.set(...)` so the React Compiler can track the mutation.",compound:"Write this shared value with `.set(v => ...)`, or `.set(x.get() ...)`, so the React Compiler can track the mutation."},m=new Map([["+=","+"],["-=","-"],["*=","*"],["/=","/"]]),c=(a)=>{if(a?.type!=="MemberExpression"||a.optional||a.computed)return null;const{object:i,property:n}=a;if(i.type!=="Identifier")return null;if(n.type!=="Identifier"||n.name!=="value")return null;return i.name},h=new Set(["UpdateExpression","ArrayPattern","ObjectPattern","RestElement","AssignmentPattern"]);export const noSharedValueDotValue={meta:{type:"problem",docs:{description:"Shared values are read with `.get()` and written with `.set(...)`, never through `.value`. React Compiler cannot track a `.value` access."},hasSuggestions:!0},createOnce(a){const i=new Set,n=[];return{before(){i.clear();n.length=0},VariableDeclarator(e){if(e.id.type==="Identifier"&&l(e.init))i.add(e.id.name)},AssignmentExpression(e){const t=c(e.left);if(t===null)return;const r=m.get(e.operator);if(r){n.push({kind:"compound",node:e,name:t,operator:r,right:e.right});return}if(e.operator!=="=")return;n.push({kind:"write",node:e,name:t,right:e.right})},UpdateExpression(e){const t=c(e.argument);if(t===null)return;n.push({kind:"update",node:e,name:t})},MemberExpression(e){const t=c(e);if(t===null)return;if(e.parent.type==="AssignmentExpression"&&e.parent.left===e)return;if(h.has(e.parent.type))return;n.push({kind:"read",node:e,name:t})},"Program:exit"(){for(const e of n){const{node:t,name:r}=e;if(!i.has(r))continue;if(e.kind==="update"){a.report({node:t,message:s.compound});continue}if(e.kind==="read"){a.report({node:t,message:s.read,suggest:[{desc:`Rewrite as ${r}.get()`,fix:(o)=>o.replaceText(t,`${r}.get()`)}]});continue}const u=a.sourceCode.getText(e.right),p=e.kind==="compound"?`${r}.set(${r}.get() ${e.operator} (${u}))`:`${r}.set(${u})`;a.report({node:t,message:e.kind==="compound"?s.compound:s.write,suggest:[{desc:`Rewrite as ${r}.set(...)`,fix:(o)=>o.replaceText(t,p)}]})}}}}};

package/dist/react-native/rules/reanimated/prefer-lazy-shared-value-initializer.js

@@ -1,24 +1 @@
-import { gate, problem } from "../../../lib/ast.js";
-const EAGER_INITIALIZER = "Wrap this in a lazy initializer: `useSharedValue(() => compute())`, since the eager call runs on every React render.";
-export const preferLazySharedValueInitializer = problem("Pass a computed `useSharedValue` initial value as a function. An eager call runs on every render while only the first result is kept.", {
-    createOnce(context) {
-        return {
-            before() {
-                return gate(context, "useSharedValue");
-            },
-            CallExpression(node) {
-                const { callee } = node;
-                if (callee.type !== "Identifier" || callee.name !== "useSharedValue")
-                    return;
-                const argument = node.arguments[0];
-                if (!argument)
-                    return;
-                const eager = (argument.type === "CallExpression" && argument.callee.type === "Identifier") ||
-                    argument.type === "NewExpression";
-                if (!eager)
-                    return;
-                context.report({ node, message: EAGER_INITIALIZER });
-            },
-        };
-    },
-});
+import{gate as n,problem as i}from"../../../lib/ast.js";const s="Wrap this in a lazy initializer: `useSharedValue(() => compute())`, since the eager call runs on every React render.";export const preferLazySharedValueInitializer=i("Pass a computed `useSharedValue` initial value as a function. An eager call runs on every render while only the first result is kept.",{createOnce(a){return{before(){return n(a,"useSharedValue")},CallExpression(r){const{callee:t}=r;if(t.type!=="Identifier"||t.name!=="useSharedValue")return;const e=r.arguments[0];if(!e)return;if(!(e.type==="CallExpression"&&e.callee.type==="Identifier"||e.type==="NewExpression"))return;a.report({node:r,message:s})}}}});

package/dist/react-native/rules/reanimated/schedule-on-rn-scope.js

@@ -1,21 +1 @@
-import { calleeName, gate, isFunction, problem } from "../../../lib/ast.js";
-const INLINE_CALLBACK = "Pass a function declared in RN Runtime scope to `scheduleOnRN`; an inline callback has ambiguous runtime ownership and can be created on the wrong runtime.";
-export const scheduleOnRnScope = problem("`scheduleOnRN` takes a function declared in RN Runtime scope. An inline callback can end up created on the wrong runtime.", {
-    createOnce(context) {
-        return {
-            before() {
-                return gate(context, "scheduleOnRN");
-            },
-            CallExpression(node) {
-                if (calleeName(node) !== "scheduleOnRN")
-                    return;
-                const [callback] = node.arguments;
-                if (callback === undefined)
-                    return;
-                if (isFunction(callback) && callback.type !== "FunctionDeclaration") {
-                    context.report({ node: callback, message: INLINE_CALLBACK });
-                }
-            },
-        };
-    },
-});
+import{calleeName as a,gate as r,isFunction as t,problem as i}from"../../../lib/ast.js";const o="Pass a function declared in RN Runtime scope to `scheduleOnRN`; an inline callback has ambiguous runtime ownership and can be created on the wrong runtime.";export const scheduleOnRnScope=i("`scheduleOnRN` takes a function declared in RN Runtime scope. An inline callback can end up created on the wrong runtime.",{createOnce(n){return{before(){return r(n,"scheduleOnRN")},CallExpression(c){if(a(c)!=="scheduleOnRN")return;const[e]=c.arguments;if(e===void 0)return;if(t(e)&&e.type!=="FunctionDeclaration")n.report({node:e,message:o})}}}});

package/dist/react-native/rules/reanimated/shared-value-usage.js

@@ -1,105 +1 @@
-import { closestAncestor, crossesFunctionBefore, FUNCTION_TYPES, isMemberCall, problem, receiverName, subtreeHas, } from "../../../lib/ast.js";
-import { isProducerCall } from "./shared.js";
-const MESSAGES = {
-    renderRead: "Read this inside `useAnimatedStyle`/`useAnimatedProps`, or mirror non-visual state through an explicit callback. A `.get()` while JSX is evaluated is untracked, so the rendered value never updates.",
-    renderWrite: "Move this write into an event handler, an effect, or an animation callback — render must stay pure.",
-    destructure: "Keep the SharedValue object itself and read or write it with `.get()` / `.set(...)`; destructuring detaches the value from Reanimated reactivity.",
-    nestedProperty: "Assign a new value with `.set(...)`, or use `.modify()` for a large object; mutating a property returned by `.get()` bypasses shared-value reactivity.",
-    nestedCollection: "Assign a new collection with `.set(...)`, or mutate inside `.modify()`; mutating the collection returned by `.get()` bypasses shared-value reactivity.",
-};
-const MUTATING_METHODS = new Set([
-    "push",
-    "pop",
-    "shift",
-    "unshift",
-    "splice",
-    "sort",
-    "reverse",
-    "copyWithin",
-    "fill",
-    "set",
-    "add",
-    "delete",
-    "clear",
-]);
-const JSX_HOSTS = new Set(["JSXExpressionContainer", "JSXAttribute"]);
-/** True for `sv.get().push(...)` and friends — a mutation of the collection `get()` handed back. */
-const mutatesWhatGetReturned = (node) => {
-    if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression")
-        return false;
-    const { object, property } = node.callee;
-    return property.type === "Identifier" && MUTATING_METHODS.has(property.name) && isMemberCall(object, "get");
-};
-/** True when the call is evaluated as JSX is built, rather than inside a callback JSX only passes along. */
-const runsWhileJsxEvaluates = (node) => {
-    const host = closestAncestor(node, JSX_HOSTS);
-    if (!host)
-        return false;
-    if (crossesFunctionBefore(node, host, FUNCTION_TYPES))
-        return false;
-    return !subtreeHas(host, current => FUNCTION_TYPES.has(current.type));
-};
-export const sharedValueUsage = problem("Destructuring a shared value or mutating what its `get()` returned detaches it from Reanimated reactivity. Reading or writing one while JSX evaluates also makes render impure.", {
-    createOnce(context) {
-        const names = new Set();
-        const candidates = [];
-        return {
-            before() {
-                names.clear();
-                candidates.length = 0;
-            },
-            VariableDeclarator(node) {
-                const { id, init } = node;
-                if (id.type === "Identifier" && isProducerCall(init)) {
-                    names.add(id.name);
-                    return;
-                }
-                if (id.type !== "ObjectPattern")
-                    return;
-                if (init?.type !== "CallExpression")
-                    return;
-                if (init.callee.type !== "Identifier" || init.callee.name !== "useSharedValue")
-                    return;
-                const destructuresValue = id.properties.some(property => {
-                    if (property.type !== "Property")
-                        return false;
-                    const { key } = property;
-                    return key.type === "Identifier" && key.name === "value";
-                });
-                if (destructuresValue)
-                    context.report({ node, message: MESSAGES.destructure });
-            },
-            AssignmentExpression(node) {
-                if (node.left.type !== "MemberExpression")
-                    return;
-                if (!isMemberCall(node.left.object, "get"))
-                    return;
-                const shared = receiverName(node.left.object);
-                if (!shared)
-                    return;
-                candidates.push({ node, shared, message: MESSAGES.nestedProperty });
-            },
-            CallExpression(node) {
-                if (mutatesWhatGetReturned(node)) {
-                    context.report({ node, message: MESSAGES.nestedCollection });
-                    return;
-                }
-                const isGet = isMemberCall(node, "get") && node.arguments.length === 0;
-                if (!isGet && !isMemberCall(node, "set"))
-                    return;
-                const shared = receiverName(node);
-                if (!shared)
-                    return;
-                if (!runsWhileJsxEvaluates(node))
-                    return;
-                candidates.push({ node, shared, message: isGet ? MESSAGES.renderRead : MESSAGES.renderWrite });
-            },
-            "Program:exit"() {
-                for (const { node, shared, message } of candidates) {
-                    if (names.has(shared))
-                        context.report({ node, message });
-                }
-            },
-        };
-    },
-});
+import{closestAncestor as p,crossesFunctionBefore as f,FUNCTION_TYPES as c,isMemberCall as u,problem as m,receiverName as d,subtreeHas as h}from"../../../lib/ast.js";import{isProducerCall as g}from"./shared.js";const n={renderRead:"Read this inside `useAnimatedStyle`/`useAnimatedProps`, or mirror non-visual state through an explicit callback. A `.get()` while JSX is evaluated is untracked, so the rendered value never updates.",renderWrite:"Move this write into an event handler, an effect, or an animation callback — render must stay pure.",destructure:"Keep the SharedValue object itself and read or write it with `.get()` / `.set(...)`; destructuring detaches the value from Reanimated reactivity.",nestedProperty:"Assign a new value with `.set(...)`, or use `.modify()` for a large object; mutating a property returned by `.get()` bypasses shared-value reactivity.",nestedCollection:"Assign a new collection with `.set(...)`, or mutate inside `.modify()`; mutating the collection returned by `.get()` bypasses shared-value reactivity."},y=new Set(["push","pop","shift","unshift","splice","sort","reverse","copyWithin","fill","set","add","delete","clear"]),b=new Set(["JSXExpressionContainer","JSXAttribute"]),v=(r)=>{if(r.type!=="CallExpression"||r.callee.type!=="MemberExpression")return!1;const{object:s,property:a}=r.callee;return a.type==="Identifier"&&y.has(a.name)&&u(s,"get")},S=(r)=>{const s=p(r,b);if(!s)return!1;if(f(r,s,c))return!1;return!h(s,(a)=>c.has(a.type))};export const sharedValueUsage=m("Destructuring a shared value or mutating what its `get()` returned detaches it from Reanimated reactivity. Reading or writing one while JSX evaluates also makes render impure.",{createOnce(r){const s=new Set,a=[];return{before(){s.clear();a.length=0},VariableDeclarator(e){const{id:t,init:i}=e;if(t.type==="Identifier"&&g(i)){s.add(t.name);return}if(t.type!=="ObjectPattern")return;if(i?.type!=="CallExpression")return;if(i.callee.type!=="Identifier"||i.callee.name!=="useSharedValue")return;if(t.properties.some((o)=>{if(o.type!=="Property")return!1;const{key:l}=o;return l.type==="Identifier"&&l.name==="value"}))r.report({node:e,message:n.destructure})},AssignmentExpression(e){if(e.left.type!=="MemberExpression")return;if(!u(e.left.object,"get"))return;const t=d(e.left.object);if(!t)return;a.push({node:e,shared:t,message:n.nestedProperty})},CallExpression(e){if(v(e)){r.report({node:e,message:n.nestedCollection});return}const t=u(e,"get")&&e.arguments.length===0;if(!t&&!u(e,"set"))return;const i=d(e);if(!i)return;if(!S(e))return;a.push({node:e,shared:i,message:t?n.renderRead:n.renderWrite})},"Program:exit"(){for(const{node:e,shared:t,message:i}of a)if(s.has(t))r.report({node:e,message:i})}}}});

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

@@ -1,13 +1 @@
-import { calleeName } from "../../../lib/ast.js";
-/** Calls that hand back a SharedValue. */
-const PRODUCERS = new Set([
-    "useSharedValue",
-    "useDerivedValue",
-    "useScrollOffset",
-    "useScrollViewOffset",
-    "makeMutable",
-]);
-/** `useSharedValue(...)` and friends, under a namespace or not — decides which locals hold a shared value. */
-export const isProducerCall = (node) => node?.type === "CallExpression" && PRODUCERS.has(calleeName(node));
-/** The hooks whose callback is an animated updater. */
-export const ANIMATED_STYLE_HOOKS = new Set(["useAnimatedStyle", "useAnimatedProps"]);
+import{calleeName as s}from"../../../lib/ast.js";const t=new Set(["useSharedValue","useDerivedValue","useScrollOffset","useScrollViewOffset","makeMutable"]);export const isProducerCall=(e)=>e?.type==="CallExpression"&&t.has(s(e)),ANIMATED_STYLE_HOOKS=new Set(["useAnimatedStyle","useAnimatedProps"]);