@ashstack/lint 0.1.0

package/dist/react-native/rules/legend-list/no-inline-render-item-props.js

@@ -0,0 +1,35 @@
+import { attributeName, gate, problem } from "../../../lib/ast.js";
+import { literalKind } from "./shared.js";
+export const noInlineRenderItemProps = problem("Disallow inline object and array literals on props nested inside `renderItem`. A row whose props take a new identity every render can never be skipped.", {
+    createOnce(context) {
+        let depth = 0;
+        return {
+            before() {
+                depth = 0;
+                return gate(context, "renderItem");
+            },
+            JSXAttribute(node) {
+                if (attributeName(node) === "renderItem") {
+                    depth++;
+                    return;
+                }
+                if (depth === 0)
+                    return;
+                const { value } = node;
+                if (value?.type !== "JSXExpressionContainer")
+                    return;
+                const kind = literalKind(value.expression);
+                if (kind === null)
+                    return;
+                context.report({
+                    node: value,
+                    message: `Pass \`item\` or its primitive fields and build this ${kind} inside the row, or hoist it to module scope when it is static. A fresh ${kind} each render means the row can never be skipped, so typing anywhere re-renders every visible row.`,
+                });
+            },
+            "JSXAttribute:exit"(node) {
+                if (attributeName(node) === "renderItem")
+                    depth--;
+            },
+        };
+    },
+});

package/dist/react-native/rules/legend-list/no-mixed-children.d.ts

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

package/dist/react-native/rules/legend-list/no-mixed-children.js

@@ -0,0 +1,24 @@
+import { gate, problem } from "../../../lib/ast.js";
+import { attributeNamed, isListElement, LIST } from "./shared.js";
+const rendersRealChild = (node) => node.type === "JSXElement" &&
+    node.children.some(child => child.type === "JSXElement" ||
+        child.type === "JSXFragment" ||
+        (child.type === "JSXText" && child.value.trim() !== "") ||
+        (child.type === "JSXExpressionContainer" && child.expression.type !== "JSXEmptyExpression"));
+export const noMixedChildren = problem("Disallow passing both `data` and real children to a Legend List. The combination is unsupported and one of the two is dropped without a warning.", {
+    createOnce: context => ({
+        before: () => gate(context, LIST),
+        JSXElement(node) {
+            if (!isListElement(node))
+                return;
+            if (!attributeNamed(node, "data"))
+                return;
+            if (!rendersRealChild(node))
+                return;
+            context.report({
+                node: node.openingElement,
+                message: "Keep either `data` with `renderItem` or children mode here, and remove the other. Passing both fails silently, with no guarantee about which one is ignored.",
+            });
+        },
+    }),
+});

package/dist/react-native/rules/legend-list/no-remount-key.d.ts

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

package/dist/react-native/rules/legend-list/no-remount-key.js

@@ -0,0 +1,18 @@
+import { gate, problem } from "../../../lib/ast.js";
+import { attributeNamed, isListElement, LIST } from "./shared.js";
+export const noRemountKey = problem("Disallow `key` on a Legend List, which remounts on any key change and loses its measurements and scroll position. Pass `dataKey` instead.", {
+    createOnce: context => ({
+        before: () => gate(context, LIST),
+        JSXElement(node) {
+            if (!isListElement(node))
+                return;
+            const key = attributeNamed(node, "key");
+            if (!key)
+                return;
+            context.report({
+                node: key,
+                message: "Pass `dataKey` instead of `key` here: it re-initialises the list for a different dataset from the inside, without the remount that discards every measurement, cached size and scroll position.",
+            });
+        },
+    }),
+});

package/dist/react-native/rules/legend-list/no-scrollview-map.d.ts

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

package/dist/react-native/rules/legend-list/no-scrollview-map.js

@@ -0,0 +1,27 @@
+import { componentName, gate, problem } from "../../../lib/ast.js";
+export const noScrollviewMap = problem("A `ScrollView` mounts every child up front, so a mapped collection does not belong in its children.", {
+    createOnce: context => ({
+        before: () => gate(context, "ScrollView"),
+        JSXElement(node) {
+            if (componentName(node.openingElement.name) !== "ScrollView")
+                return;
+            for (const child of node.children) {
+                if (child.type !== "JSXExpressionContainer")
+                    continue;
+                const call = child.expression;
+                if (call.type !== "CallExpression")
+                    continue;
+                const { callee } = call;
+                if (callee.type !== "MemberExpression")
+                    continue;
+                if (callee.property.type !== "Identifier" || callee.property.name !== "map")
+                    continue;
+                context.report({
+                    node: child,
+                    message: "Render this collection with `LegendList` from '@legendapp/list/react-native', passing the array as `data` and the mapped body as `renderItem`. A ScrollView mounts every child up front, so 200 rows cost 200 mounts to show ten.",
+                });
+                return;
+            }
+        },
+    }),
+});

package/dist/react-native/rules/legend-list/no-unsupported-props.d.ts

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

package/dist/react-native/rules/legend-list/no-unsupported-props.js

@@ -0,0 +1,29 @@
+import { attributeName, gate, problem } from "../../../lib/ast.js";
+import { attributesOf, isListElement, LIST } from "./shared.js";
+const UNSUPPORTED_PROPS = new Set([
+    "masonry",
+    "optimizeItemArrangement",
+    "inverted",
+    "onBlankArea",
+    "disableAutoLayout",
+    "CellRendererComponent",
+]);
+export const noUnsupportedProps = problem("Disallow FlashList and FlatList props that Legend List v3 does not have. It ignores them rather than rejecting them, so the feature looks broken.", {
+    createOnce: context => ({
+        before: () => gate(context, LIST),
+        JSXElement(node) {
+            if (!isListElement(node))
+                return;
+            for (const attribute of attributesOf(node)) {
+                if (attribute.type !== "JSXAttribute")
+                    continue;
+                if (!UNSUPPORTED_PROPS.has(attributeName(attribute)))
+                    continue;
+                context.report({
+                    node: attribute,
+                    message: "Remove this prop: Legend List v3 has no such prop and ignores it silently rather than rejecting it. Build inverted chat lists from `maintainScrollAtEnd` / `initialScrollAtEnd` / `maintainVisibleContentPosition` instead.",
+                });
+            }
+        },
+    }),
+});

package/dist/react-native/rules/legend-list/required-props.d.ts

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

package/dist/react-native/rules/legend-list/required-props.js

@@ -0,0 +1,23 @@
+import { gate, problem } from "../../../lib/ast.js";
+import { attributeNamed, hasSpread, isListElement, LIST } from "./shared.js";
+export const requiredProps = problem("Require `keyExtractor` and an explicit `recycleItems` on a Legend List. Without a key extractor the list keys its rows by index.", {
+    createOnce: context => ({
+        before: () => gate(context, LIST),
+        JSXElement(node) {
+            if (!isListElement(node) || hasSpread(node))
+                return;
+            if (!attributeNamed(node, "keyExtractor")) {
+                context.report({
+                    node: node.openingElement,
+                    message: "Add `keyExtractor={item => item.id}` returning a stable per-item identity. The index fallback pins cached measurements and recycled row state to a position, so a prepend leaves rows showing the previous row's data.",
+                });
+            }
+            if (!attributeNamed(node, "recycleItems")) {
+                context.report({
+                    node: node.openingElement,
+                    message: "Add `recycleItems={true}` — recycling is where most of the list's native speed comes from. If a row genuinely cannot be recycled, pass `recycleItems={false}` and state which part of the row required it.",
+                });
+            }
+        },
+    }),
+});

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

@@ -0,0 +1,19 @@
+import type { AstNode } from "../../../lib/types.js";
+/** A JSX element node, the only shape the list rules look at. */
+export type ListElement = Extract<AstNode, {
+    type: "JSXElement";
+}>;
+type Attribute = Extract<AstNode, {
+    type: "JSXAttribute";
+}>;
+type AttributeItem = Extract<AstNode, {
+    type: "JSXAttribute" | "JSXSpreadAttribute";
+}>;
+export declare const LIST = "LegendList";
+export declare const isListElement: (node: AstNode | null | undefined) => boolean;
+export declare const attributesOf: (node: AstNode) => AttributeItem[];
+export declare const attributeNamed: (node: AstNode, wanted: string) => Attribute | undefined;
+export declare const hasSpread: (node: AstNode) => boolean;
+export declare const expressionOf: (attribute: AstNode | null | undefined) => AstNode | null;
+export declare const literalKind: (node: AstNode | null | undefined) => "object" | "array" | null;
+export {};

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

@@ -0,0 +1,25 @@
+import { attributeName, componentName } from "../../../lib/ast.js";
+export const LIST = "LegendList";
+export const isListElement = (node) => node?.type === "JSXElement" && componentName(node.openingElement.name) === LIST;
+export const attributesOf = (node) => node.type === "JSXElement" ? node.openingElement.attributes : [];
+export const attributeNamed = (node, wanted) => {
+    for (const attribute of attributesOf(node)) {
+        if (attribute.type === "JSXAttribute" && attributeName(attribute) === wanted)
+            return attribute;
+    }
+    return undefined;
+};
+export const hasSpread = (node) => attributesOf(node).some(attribute => attribute.type === "JSXSpreadAttribute");
+export const expressionOf = (attribute) => {
+    if (attribute?.type !== "JSXAttribute")
+        return null;
+    const { value } = attribute;
+    return value?.type === "JSXExpressionContainer" ? value.expression : null;
+};
+export const literalKind = (node) => {
+    if (node?.type === "ObjectExpression")
+        return "object";
+    if (node?.type === "ArrayExpression")
+        return "array";
+    return null;
+};

package/dist/react-native/rules/legend-list/typed-items-need-item-type.d.ts

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

package/dist/react-native/rules/legend-list/typed-items-need-item-type.js

@@ -0,0 +1,49 @@
+import { gate, problem, subtreeHas } from "../../../lib/ast.js";
+import { attributeNamed, expressionOf, hasSpread, isListElement, LIST } from "./shared.js";
+const branchesOnItemType = (node) => subtreeHas(node, current => current.type === "MemberExpression" && current.property.type === "Identifier" && current.property.name === "type");
+export const typedItemsNeedItemType = problem("Require `getItemType` when a row branches on `item.type`. Without it every layout shares one recycling pool and one size average.", {
+    createOnce(context) {
+        let rowRenderersByName;
+        let listsWithoutItemType;
+        const reportMissingItemTypeAtEndOfFile = () => {
+            for (const { node, renderItem } of listsWithoutItemType) {
+                const expression = expressionOf(renderItem);
+                const body = expression?.type === "Identifier" ? rowRenderersByName.get(expression.name) : expression;
+                if (body === undefined || body === null || !branchesOnItemType(body))
+                    continue;
+                context.report({
+                    node: node.openingElement,
+                    message: "Add `getItemType={item => item.type}` to match the branch this row makes on `item.type`. It gives each layout its own recycling pool and its own measured-size average, instead of handing a header's view to a photo row.",
+                });
+            }
+        };
+        return {
+            before() {
+                rowRenderersByName = new Map();
+                listsWithoutItemType = [];
+                return gate(context, LIST);
+            },
+            FunctionDeclaration(node) {
+                if (node.id?.type === "Identifier")
+                    rowRenderersByName.set(node.id.name, node);
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type !== "Identifier" || init === null)
+                    return;
+                rowRenderersByName.set(id.name, init);
+            },
+            JSXElement(node) {
+                if (!isListElement(node) || hasSpread(node))
+                    return;
+                if (attributeNamed(node, "getItemType"))
+                    return;
+                const renderItem = attributeNamed(node, "renderItem");
+                if (!renderItem)
+                    return;
+                listsWithoutItemType.push({ node, renderItem });
+            },
+            "Program:exit": reportMissingItemTypeAtEndOfFile,
+        };
+    },
+});

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

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

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

@@ -0,0 +1,35 @@
+import { defineModule } from "../../../lib/module.js";
+import { naming } from "./naming.js";
+import { noAssignment } from "./no-assignment.js";
+import { noNestedObservable } from "./no-nested-observable.js";
+import { noObjectSelector } from "./no-object-selector.js";
+import { noObservableInComponent } from "./no-observable-in-component.js";
+import { noPeekInSelector } from "./no-peek-in-selector.js";
+import { noReactMirror } from "./no-react-mirror.js";
+import { noUntrackedGetInJsx } from "./no-untracked-get-in-jsx.js";
+export default defineModule({
+    meta: { name: "@ashstack/legend-state" },
+    url: import.meta.url,
+    packages: ["@legendapp/state"],
+    option: "legendState",
+    docsWhen: "auto-enabled when `@legendapp/state` is a dependency",
+    rules: {
+        "no-assignment": noAssignment,
+        naming: naming,
+        "no-nested-observable": noNestedObservable,
+        "no-react-mirror": noReactMirror,
+        "no-untracked-get-in-jsx": noUntrackedGetInJsx,
+        "no-peek-in-selector": noPeekInSelector,
+        "no-object-selector": noObjectSelector,
+        "no-observable-in-component": noObservableInComponent,
+    },
+    restrictedImports: {
+        paths: [
+            {
+                name: "@legendapp/state/react",
+                importNames: ["use$", "useSelector"],
+                message: "Use `useValue` from `@legendapp/state/react`; `use$` and `useSelector` are deprecated.",
+            },
+        ],
+    },
+});

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

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

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

@@ -0,0 +1,26 @@
+import { gate, problem } from "../../../lib/ast.js";
+import { factoryCalled, OBS } from "./shared.js";
+export const naming = problem("A variable initialized from `observable()` or `useObservable()` needs a trailing `$`. The other rules in this module key off that suffix.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "observable", "useObservable");
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                const factory = factoryCalled(init);
+                if (!factory || id.type !== "Identifier")
+                    return;
+                const { name } = id;
+                if (OBS.test(name))
+                    return;
+                context.report({
+                    node: id,
+                    message: name.includes("$")
+                        ? `Give this observable a trailing \`$\` and no other. The suffix is how a reader tells an observable from a plain value, and every other observable rule keys off it.`
+                        : `Rename this to \`${name}$\`. The trailing \`$\` is how a reader tells an observable from a plain value, and every other observable rule keys off it.`,
+                });
+            },
+        };
+    },
+});

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

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

package/dist/react-native/rules/legend-state/no-assignment.js

@@ -0,0 +1,31 @@
+import { gate, problem } from "../../../lib/ast.js";
+import { isObservableRef, textOf } from "./shared.js";
+export const noAssignment = problem("Write an observable with `.set(...)` or `.assign({...})`. Assigning or incrementing it with an operator is a silent no-op.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "$");
+            },
+            AssignmentExpression(node) {
+                const { left } = node;
+                if (!isObservableRef(left))
+                    return;
+                const target = textOf(context, left);
+                context.report({
+                    node,
+                    message: `Write through \`${target}.set(...)\`, or \`.assign({...})\` to merge several fields. Assigning to an observable with \`${node.operator}\` replaces the observable in place of its value, so nothing downstream ever updates.`,
+                });
+            },
+            UpdateExpression(node) {
+                const { argument, operator } = node;
+                if (!isObservableRef(argument))
+                    return;
+                const target = textOf(context, argument);
+                context.report({
+                    node,
+                    message: `Use \`${target}.set(v => v ${operator[0]} 1)\` — \`${operator}\` on an observable is a silent no-op.`,
+                });
+            },
+        };
+    },
+});

package/dist/react-native/rules/legend-state/no-nested-observable.d.ts

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

package/dist/react-native/rules/legend-state/no-nested-observable.js

@@ -0,0 +1,23 @@
+import { gate, problem } from "../../../lib/ast.js";
+import { factoryCalled, isObservableRef } from "./shared.js";
+export const noNestedObservable = problem("Never pass an observable to `observable()` or `useObservable()`. The wrapper is a second node, and reads and writes on it never reach the original.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "observable", "useObservable");
+            },
+            CallExpression(node) {
+                const factory = factoryCalled(node);
+                if (!factory)
+                    return;
+                const argument = node.arguments[0];
+                if (!argument || !isObservableRef(argument))
+                    return;
+                context.report({
+                    node: argument,
+                    message: `Use the existing observable reference directly instead of passing it to \`${factory}()\`; wrapping it creates a second node whose reads and writes never reach the original.`,
+                });
+            },
+        };
+    },
+});

package/dist/react-native/rules/legend-state/no-object-selector.d.ts

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

package/dist/react-native/rules/legend-state/no-object-selector.js

@@ -0,0 +1,47 @@
+import { FUNCTION_TYPES, crossesFunctionBefore, findInSubtree, gate, problem } from "../../../lib/ast.js";
+const literalKind = (node) => {
+    if (node.type === "ObjectExpression")
+        return "object";
+    if (node.type === "ArrayExpression")
+        return "array";
+    return null;
+};
+/** What a selector hands back, whether written as an expression body or as a `return`. */
+const returnedValue = (fn) => {
+    const { body } = fn.type === "ArrowFunctionExpression" || fn.type === "FunctionExpression" ? fn : { body: null };
+    if (body === null)
+        return null;
+    if (body.type !== "BlockStatement")
+        return body;
+    const found = findInSubtree(body, (current) => current.type === "ReturnStatement");
+    if (found?.type !== "ReturnStatement" || crossesFunctionBefore(found, body, FUNCTION_TYPES))
+        return null;
+    return found.argument;
+};
+export const noObjectSelector = problem("A `useValue` selector that builds a new object or array returns a fresh identity every run. The component then re-renders on every store change.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "useValue");
+            },
+            CallExpression(node) {
+                const { callee } = node;
+                if (callee.type !== "Identifier" || callee.name !== "useValue")
+                    return;
+                const argument = node.arguments[0];
+                if (argument?.type !== "ArrowFunctionExpression" && argument?.type !== "FunctionExpression")
+                    return;
+                const returned = returnedValue(argument);
+                if (returned === null)
+                    return;
+                const kind = literalKind(returned);
+                if (kind === null)
+                    return;
+                context.report({
+                    node: returned,
+                    message: `Return the primitive that decides the render from this selector, or call \`useValue\` once per field. A new ${kind} each run has a new identity, so the component re-renders on every store change.`,
+                });
+            },
+        };
+    },
+});

package/dist/react-native/rules/legend-state/no-observable-in-component.d.ts

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

package/dist/react-native/rules/legend-state/no-observable-in-component.js

@@ -0,0 +1,46 @@
+import { COMPONENT_OR_HOOK, gate, isFunction, problem } from "../../../lib/ast.js";
+export const noObservableInComponent = problem("Calling `observable()` inside a component or hook makes a new observable on every render. Use `useObservable()` or a module-level store instead.", {
+    createOnce(context) {
+        let componentDepth = 0;
+        const enter = (name) => {
+            if (name !== undefined && COMPONENT_OR_HOOK.test(name))
+                componentDepth++;
+        };
+        const exit = (name) => {
+            if (name !== undefined && COMPONENT_OR_HOOK.test(name))
+                componentDepth--;
+        };
+        const declaredName = (id) => id?.type === "Identifier" ? id.name : undefined;
+        return {
+            before() {
+                componentDepth = 0;
+                return gate(context, "observable");
+            },
+            FunctionDeclaration(node) {
+                enter(declaredName(node.id));
+            },
+            "FunctionDeclaration:exit"(node) {
+                exit(declaredName(node.id));
+            },
+            VariableDeclarator(node) {
+                if (isFunction(node.init))
+                    enter(declaredName(node.id));
+            },
+            "VariableDeclarator:exit"(node) {
+                if (isFunction(node.init))
+                    exit(declaredName(node.id));
+            },
+            CallExpression(node) {
+                if (componentDepth === 0)
+                    return;
+                const { callee } = node;
+                if (callee.type !== "Identifier" || callee.name !== "observable")
+                    return;
+                context.report({
+                    node,
+                    message: "Use `useObservable()` for component-lifetime state, or move this observable into a store in `src/stores` and import it. `observable()` inside a component makes a new observable every render, so nothing that read the previous one is listening.",
+                });
+            },
+        };
+    },
+});

package/dist/react-native/rules/legend-state/no-peek-in-selector.d.ts

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

package/dist/react-native/rules/legend-state/no-peek-in-selector.js

@@ -0,0 +1,67 @@
+import { gate, isFunction, problem } from "../../../lib/ast.js";
+import { isObservableRef, textOf } from "./shared.js";
+const TRACKING_CONTEXT_CALLEES = new Set([
+    "useValue",
+    "observe",
+    "useObserve",
+    "useObserveEffect",
+    "when",
+    "whenReady",
+]);
+const trackingCallbackOf = (node) => {
+    const { callee } = node;
+    if (callee.type !== "Identifier")
+        return null;
+    if (!TRACKING_CONTEXT_CALLEES.has(callee.name))
+        return null;
+    const argument = node.arguments[0];
+    return argument && isFunction(argument) ? argument : null;
+};
+const peekedObservable = (callee) => {
+    if (callee.type !== "MemberExpression" || callee.computed)
+        return null;
+    if (callee.property.type !== "Identifier" || callee.property.name !== "peek")
+        return null;
+    const { object } = callee;
+    return isObservableRef(object) ? object : null;
+};
+export const noPeekInSelector = problem("`peek()` never subscribes, so a selector or tracking callback that uses it never re-runs. Call `get()` there and keep `peek()` for handlers.", {
+    createOnce(context) {
+        let trackingCallbacks = new WeakSet();
+        let depth = 0;
+        const enterIfTracking = (node) => {
+            if (trackingCallbacks.has(node))
+                depth++;
+        };
+        const exitIfTracking = (node) => {
+            if (trackingCallbacks.has(node))
+                depth--;
+        };
+        return {
+            before() {
+                trackingCallbacks = new WeakSet();
+                depth = 0;
+                return gate(context, ".peek()");
+            },
+            CallExpression(node) {
+                const callback = trackingCallbackOf(node);
+                if (callback)
+                    trackingCallbacks.add(callback);
+                if (depth === 0)
+                    return;
+                const observable = peekedObservable(node.callee);
+                if (!observable)
+                    return;
+                const target = textOf(context, observable);
+                context.report({
+                    node,
+                    message: `Use \`${target}.get()\` inside this selector and keep \`peek()\` for handlers and async work. \`peek()\` never subscribes, so nothing re-runs when the value changes and the first read is the only one.`,
+                });
+            },
+            ArrowFunctionExpression: enterIfTracking,
+            "ArrowFunctionExpression:exit": exitIfTracking,
+            FunctionExpression: enterIfTracking,
+            "FunctionExpression:exit": exitIfTracking,
+        };
+    },
+});

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

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

package/dist/react-native/rules/legend-state/no-react-mirror.js

@@ -0,0 +1,33 @@
+import { gate, problem } from "../../../lib/ast.js";
+import { isObservableRef } from "./shared.js";
+const OBSERVABLE_READS = new Set(["get", "peek"]);
+const readsObservable = (node) => {
+    if (node?.type !== "CallExpression")
+        return false;
+    const { callee } = node;
+    if (callee.type !== "MemberExpression" || callee.computed)
+        return false;
+    if (callee.property.type !== "Identifier" || !OBSERVABLE_READS.has(callee.property.name))
+        return false;
+    return isObservableRef(callee.object);
+};
+export const noReactMirror = problem("Seeding `useState` from an observable's `get()` or `peek()` gives the value two owners. Read it with `useValue(...)` where it renders.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "useState");
+            },
+            CallExpression(node) {
+                const { callee } = node;
+                if (callee.type !== "Identifier" || callee.name !== "useState")
+                    return;
+                if (!readsObservable(node.arguments[0]))
+                    return;
+                context.report({
+                    node,
+                    message: "Drop this `useState` mirror and read the observable with `useValue(...)` where it renders, so the observable stays the single owner of the value.",
+                });
+            },
+        };
+    },
+});

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

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