@ashstack/lint 0.1.0

package/dist/react/rules/query/no-inline-keys.js

@@ -0,0 +1,107 @@
+import { problem } from "../../../lib/ast.js";
+import { propertyKeyName } from "./shared.js";
+const MESSAGES = {
+    inlineQueryKey: "Define this key in the feature's `*.keys.ts` factory and reference it: `queryKey: someKeys.scope(...)`, so invalidation elsewhere matches the same key.",
+    inlineGetQueryData: "Read through the feature's `*.keys.ts` factory: `getQueryData(someKeys.scope())`.",
+    inlineSetQueryData: "Write through the feature's `*.keys.ts` factory: `setQueryData(someKeys.scope(), updater)`.",
+};
+const QUERY_KEY_HOOKS = new Set([
+    "useQuery",
+    "useSuspenseQuery",
+    "useInfiniteQuery",
+    "useSuspenseInfiniteQuery",
+    "useQueries",
+]);
+const QUERY_KEY_METHODS = new Set([
+    "invalidateQueries",
+    "removeQueries",
+    "refetchQueries",
+    "cancelQueries",
+    "resetQueries",
+    "fetchQuery",
+    "prefetchQuery",
+    "ensureQueryData",
+    "getQueriesData",
+    "setQueriesData",
+]);
+const methodName = (node) => {
+    if (node.type !== "CallExpression")
+        return "";
+    const { callee } = node;
+    if (callee.type !== "MemberExpression" || callee.computed)
+        return "";
+    const { property } = callee;
+    return property.type === "Identifier" ? property.name : "";
+};
+const firstArgumentArray = (node) => {
+    if (node.type !== "CallExpression")
+        return undefined;
+    const [first] = node.arguments;
+    return first?.type === "ArrayExpression" ? first : undefined;
+};
+const takesQueryKeyOptions = (node, method) => {
+    const callee = node.type === "CallExpression" ? node.callee : undefined;
+    const isHook = callee?.type === "Identifier" && QUERY_KEY_HOOKS.has(callee.name);
+    return isHook || QUERY_KEY_METHODS.has(method);
+};
+const isQueryKeyProperty = (property) => {
+    if (property.type !== "Property" || property.computed)
+        return false;
+    const { key } = property;
+    if (key.type === "Identifier")
+        return key.name === "queryKey";
+    return key.type === "Literal" && key.value === "queryKey";
+};
+/** `useQueries({ queries: [...] })` carries its keys one level down, inside the array. */
+const optionObjects = (options) => {
+    if (options.type !== "ObjectExpression")
+        return [];
+    const queries = options.properties.find(property => property.type === "Property" && propertyKeyName(property) === "queries");
+    if (queries?.type !== "Property" || queries.value.type !== "ArrayExpression")
+        return [options];
+    return [options, ...queries.value.elements.filter(element => element !== null)];
+};
+const inlineQueryKeys = (node) => {
+    if (node.type !== "CallExpression")
+        return [];
+    const [first] = node.arguments;
+    if (first === undefined)
+        return [];
+    const inline = [];
+    for (const options of optionObjects(first)) {
+        if (options.type !== "ObjectExpression")
+            continue;
+        for (const property of options.properties) {
+            if (property.type !== "Property" || !isQueryKeyProperty(property))
+                continue;
+            const { value } = property;
+            if (value.type === "ArrayExpression")
+                inline.push(value);
+        }
+    }
+    return inline;
+};
+export const noInlineKeys = problem("Disallow a query key written as an array literal at the call site instead of coming from a keys factory.", {
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                const method = methodName(node);
+                if (method === "getQueryData" || method === "setQueryData") {
+                    const key = firstArgumentArray(node);
+                    if (key === undefined)
+                        return;
+                    context.report({
+                        node: key,
+                        message: method === "getQueryData" ? MESSAGES.inlineGetQueryData : MESSAGES.inlineSetQueryData,
+                    });
+                    return;
+                }
+                if (!takesQueryKeyOptions(node, method))
+                    return;
+                for (const key of inlineQueryKeys(node)) {
+                    context.report({ node: key, message: MESSAGES.inlineQueryKey });
+                }
+            },
+        };
+    },
+});

package/dist/react/rules/query/require-destructured-hooks.d.ts

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

package/dist/react/rules/query/require-destructured-hooks.js

@@ -0,0 +1,41 @@
+import { problem } from "../../../lib/ast.js";
+const DESTRUCTURE_QUERY_HOOK = "Destructure this hook at the call site: `const { data } = useFooQuery()` rather than binding the whole result to one name.";
+const API_HOOK_MODULE = /^@\/api\/.*\.(?:queries|mutations)$/;
+export const requireDestructuredHooks = problem("Require destructuring the result of a hook imported from an `@/api/*.queries` or `@/api/*.mutations` module.", {
+    createOnce(context) {
+        const apiHooks = new Set();
+        const candidates = [];
+        return {
+            before() {
+                apiHooks.clear();
+                candidates.length = 0;
+            },
+            ImportDeclaration(node) {
+                if (!API_HOOK_MODULE.test(node.source.value))
+                    return;
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === "ImportSpecifier")
+                        apiHooks.add(specifier.local.name);
+                }
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type !== "Identifier")
+                    return;
+                if (init?.type !== "CallExpression")
+                    return;
+                const { callee } = init;
+                if (callee.type !== "Identifier" || !/^use[A-Z]/.test(callee.name))
+                    return;
+                candidates.push({ node: id, hook: callee.name });
+            },
+            "Program:exit"() {
+                for (const candidate of candidates) {
+                    if (!apiHooks.has(candidate.hook))
+                        continue;
+                    context.report({ node: candidate.node, message: DESTRUCTURE_QUERY_HOOK });
+                }
+            },
+        };
+    },
+});

package/dist/react/rules/query/shared.d.ts

@@ -0,0 +1,2 @@
+import type { AstNode } from "../../../lib/types.js";
+export declare const propertyKeyName: (node: AstNode) => string;

package/dist/react/rules/query/shared.js

@@ -0,0 +1,10 @@
+export const propertyKeyName = (node) => {
+    if (node.type !== "Property" || node.computed)
+        return "";
+    const { key } = node;
+    if (key.type === "Identifier")
+        return key.name;
+    if (key.type === "Literal")
+        return String(key.value);
+    return "";
+};

package/dist/react/rules/zustand/index.d.ts

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

package/dist/react/rules/zustand/index.js

@@ -0,0 +1,12 @@
+import { defineModule } from "../../../lib/module.js";
+import { requireSelector } from "./require-selector.js";
+export default defineModule({
+    meta: { name: "@ashstack/zustand" },
+    url: import.meta.url,
+    packages: ["zustand"],
+    option: "zustand",
+    docsWhen: "auto-enabled by `react()` when `zustand` is a dependency",
+    rules: {
+        "require-selector": requireSelector,
+    },
+});

package/dist/react/rules/zustand/require-selector.d.ts

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

package/dist/react/rules/zustand/require-selector.js

@@ -0,0 +1,62 @@
+import { problem } from "../../../lib/ast.js";
+const MESSAGES = {
+    zustandBare: "Pass a selector to this store hook, for example `useSettingsStore(state => state.theme)`, so it re-renders only on that slice. Use `.getState()` instead for an imperative read.",
+    zustandUndefined: "Replace `undefined` with a selector such as `state => state.theme` — it still subscribes to the whole store otherwise. Use `.getState()` instead for an imperative read.",
+};
+const STORE_MODULE = /^(?:@\/stores\/|(?:\.\.?\/)+stores\/)[^"']*-store$/;
+const STORE_HOOK = /^use[A-Za-z0-9_$]*Store$/;
+const storeHookLocalName = (specifier) => {
+    if (specifier.type !== "ImportSpecifier")
+        return null;
+    const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : "";
+    const local = specifier.local.name;
+    return STORE_HOOK.test(imported) || STORE_HOOK.test(local) ? local : null;
+};
+export const requireSelector = problem("Require a selector on a store hook, rather than no arguments or `undefined` in its place.", {
+    createOnce(context) {
+        const hooks = new Set();
+        const calls = [];
+        return {
+            before() {
+                hooks.clear();
+                calls.length = 0;
+            },
+            ImportDeclaration(node) {
+                if (!STORE_MODULE.test(node.source.value))
+                    return;
+                for (const specifier of node.specifiers) {
+                    const local = storeHookLocalName(specifier);
+                    if (local !== null)
+                        hooks.add(local);
+                }
+            },
+            CallExpression(node) {
+                const { callee } = node;
+                if (callee.type !== "Identifier")
+                    return;
+                const { name } = callee;
+                if (!hooks.has(name) && !STORE_HOOK.test(name))
+                    return;
+                const args = node.arguments;
+                if (args.length === 0) {
+                    calls.push({ node, name, bare: true });
+                    return;
+                }
+                const [first] = args;
+                if (args.length === 1 && first?.type === "Identifier" && first.name === "undefined") {
+                    calls.push({ node, name, bare: false });
+                }
+            },
+            "Program:exit"() {
+                for (const call of calls) {
+                    if (!hooks.has(call.name))
+                        continue;
+                    context.report({
+                        node: call.node,
+                        message: call.bare ? MESSAGES.zustandBare : MESSAGES.zustandUndefined,
+                    });
+                }
+            },
+        };
+    },
+});

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

@@ -0,0 +1,11 @@
+import type { BanGroup, OxlintConfig, ReactNativeOptions } from "../lib/types.js";
+export declare const reactNativeModules: import("../lib/types.js").ModuleManifest[];
+export declare const banGroups: BanGroup[];
+/**
+ * React Native / Expo entry — everything in react plus generic RN rules, with
+ * per-library modules (unistyles, legendList, legendState, reanimated,
+ * turboImage, skia, keyboard) auto-detected from your dependencies. Your
+ * `rules` block always overrides.
+ */
+declare const reactNative: (options?: ReactNativeOptions) => OxlintConfig;
+export default reactNative;

package/dist/react-native/index.js

@@ -0,0 +1,113 @@
+import { TEST_FILES, coreModules } from "../core/index.js";
+import { mergeConfigs } from "../lib/merge.js";
+import { composeModules } from "../lib/module.js";
+import react, { reactModules } from "../react/index.js";
+import keyboardModule from "./rules/keyboard/index.js";
+import legendListModule from "./rules/legend-list/index.js";
+import legendStateModule from "./rules/legend-state/index.js";
+import reactNativeModule from "./rules/react-native/index.js";
+import reanimatedModule from "./rules/reanimated/index.js";
+import skiaModule from "./rules/skia/index.js";
+import turboImageModule from "./rules/turbo-image/index.js";
+import unistylesModule from "./rules/unistyles/index.js";
+export const reactNativeModules = [
+    reactNativeModule,
+    unistylesModule,
+    legendListModule,
+    legendStateModule,
+    reanimatedModule,
+    turboImageModule,
+    skiaModule,
+    keyboardModule,
+];
+export const banGroups = [
+    {
+        packages: ["react-native-gesture-handler"],
+        restrictedImports: {
+            paths: [
+                {
+                    name: "react-native",
+                    importNames: [
+                        "Pressable",
+                        "TouchableOpacity",
+                        "TouchableHighlight",
+                        "TouchableWithoutFeedback",
+                        "TouchableNativeFeedback",
+                    ],
+                    message: "Import `Pressable` from `react-native-gesture-handler` so it cooperates with the gesture system instead of competing with it. Exception: inside a SwiftUI/Compose host view touches never reach `GestureHandlerRootView` — keep React Native's `Pressable` there and suppress this rule with the host named in the reason.",
+                },
+            ],
+        },
+    },
+    {
+        packages: ["expo-router"],
+        restrictedImports: {
+            patterns: [
+                {
+                    group: ["@react-navigation/stack", "@react-navigation/bottom-tabs"],
+                    message: "Use expo-router's `Stack` / `NativeTabs` instead of a raw react-navigation navigator.",
+                },
+            ],
+        },
+    },
+    {
+        packages: ["expo-font"],
+        restrictedImports: {
+            paths: [
+                {
+                    name: "expo-font",
+                    importNames: ["useFonts", "loadAsync"],
+                    message: "Declare the fonts in the `expo-font` config plugin so they load at build time, instead of `useFonts`/`loadAsync` at runtime.",
+                },
+            ],
+        },
+    },
+    {
+        packages: ["react-native-quick-crypto"],
+        restrictedImports: {
+            paths: [
+                {
+                    name: "crypto-js",
+                    message: "Use `react-native-quick-crypto` instead — `crypto-js` is pure JavaScript and runs orders of magnitude slower.",
+                },
+            ],
+        },
+    },
+];
+const FORBID_EMPTY_NOOP_HANDLERS = {
+    "eslint/no-empty": "error",
+    "eslint/no-empty-function": "error",
+};
+const ALLOW_GESTURE_AND_ANIMATION_EFFECTS = {
+    "react-effect/no-event-handler": "off",
+};
+/**
+ * React Native / Expo entry — everything in react plus generic RN rules, with
+ * per-library modules (unistyles, legendList, legendState, reanimated,
+ * turboImage, skia, keyboard) auto-detected from your dependencies. Your
+ * `rules` block always overrides.
+ */
+const reactNative = (options = {}) => {
+    const composed = composeModules([...coreModules, ...reactModules, ...reactNativeModules], options, banGroups);
+    return mergeConfigs(react(options), {
+        jsPlugins: composed.jsPlugins,
+        globals: { __DEV__: "readonly" },
+        rules: {
+            ...FORBID_EMPTY_NOOP_HANDLERS,
+            ...ALLOW_GESTURE_AND_ANIMATION_EFFECTS,
+            "no-restricted-imports": ["error", composed.restricted],
+            ...composed.rules,
+        },
+        ignorePatterns: ["**/.expo/**", "**/android/**", "**/ios/**"],
+        overrides: [
+            {
+                files: TEST_FILES,
+                rules: {
+                    "@ashstack/react-native/no-dynamic-import": "off",
+                    "@ashstack/react-native/hoist-stateless-function": "off",
+                },
+            },
+        ],
+    });
+};
+export default reactNative;

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

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

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

@@ -0,0 +1,18 @@
+import { defineModule } from "../../../lib/module.js";
+export default defineModule({
+    meta: { name: "@ashstack/keyboard" },
+    url: import.meta.url,
+    packages: ["react-native-keyboard-controller"],
+    option: "keyboard",
+    docsWhen: "auto-enabled when `react-native-keyboard-controller` is a dependency",
+    rules: {},
+    restrictedImports: {
+        paths: [
+            {
+                name: "react-native",
+                importNames: ["KeyboardAvoidingView"],
+                message: "Import `KeyboardAvoidingView` from `react-native-keyboard-controller` — same props, and it tracks the keyboard per frame instead of waiting for Android's post-animation `keyboardDidShow`. For a scrolling form use its `KeyboardAwareScrollView`; to just shift a view, use `rt.insets.ime`.",
+            },
+        ],
+    },
+});

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

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

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

@@ -0,0 +1,51 @@
+import { defineModule } from "../../../lib/module.js";
+import { noFlexInContentContainer } from "./no-flex-in-content-container.js";
+import { noIndexKeyExtractor } from "./no-index-key-extractor.js";
+import { noInlineData } from "./no-inline-data.js";
+import { noInlineExtraData } from "./no-inline-extra-data.js";
+import { noInlineRenderItemProps } from "./no-inline-render-item-props.js";
+import { noMixedChildren } from "./no-mixed-children.js";
+import { noRemountKey } from "./no-remount-key.js";
+import { noScrollviewMap } from "./no-scrollview-map.js";
+import { noUnsupportedProps } from "./no-unsupported-props.js";
+import { requiredProps } from "./required-props.js";
+import { typedItemsNeedItemType } from "./typed-items-need-item-type.js";
+export default defineModule({
+    meta: { name: "@ashstack/legend-list" },
+    rules: {
+        "required-props": requiredProps,
+        "no-index-key-extractor": noIndexKeyExtractor,
+        "no-remount-key": noRemountKey,
+        "no-inline-data": noInlineData,
+        "no-inline-extra-data": noInlineExtraData,
+        "no-inline-render-item-props": noInlineRenderItemProps,
+        "no-mixed-children": noMixedChildren,
+        "no-flex-in-content-container": noFlexInContentContainer,
+        "typed-items-need-item-type": typedItemsNeedItemType,
+        "no-scrollview-map": noScrollviewMap,
+        "no-unsupported-props": noUnsupportedProps,
+    },
+    url: import.meta.url,
+    packages: ["@legendapp/list"],
+    option: "legendList",
+    docsWhen: "auto-enabled when `@legendapp/list` is a dependency",
+    restrictedImports: {
+        paths: [
+            {
+                name: "react-native",
+                importNames: ["FlatList", "SectionList", "VirtualizedList"],
+                message: "Render this list with `LegendList` from `@legendapp/list/react-native`; a `ScrollView` plus `map` is fine for fewer than 20 static items.",
+            },
+            {
+                name: "@shopify/flash-list",
+                message: "Import `LegendList` from `@legendapp/list/react-native` — Legend List replaced FlashList in this stack.",
+            },
+        ],
+        patterns: [
+            {
+                group: ["@legendapp/list"],
+                message: "Import from the platform entrypoint `@legendapp/list/react-native`, not the package root.",
+            },
+        ],
+    },
+});

package/dist/react-native/rules/legend-list/no-flex-in-content-container.d.ts

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

package/dist/react-native/rules/legend-list/no-flex-in-content-container.js

@@ -0,0 +1,77 @@
+import { attributeName, gate, problem } from "../../../lib/ast.js";
+import { isStyleSheetCreate, propertyName, stylesObjectOf } from "../../stylesheet.js";
+import { expressionOf, isListElement } from "./shared.js";
+const MESSAGE = "Move `flex` onto `style` and keep `contentContainerStyle` for padding inside the content. On the content container it sizes the content to the viewport, so the list measures as zero height and renders a blank screen with no error.";
+const hasFlexKey = (node) => node?.type === "ObjectExpression" &&
+    node.properties.some(property => property.type === "Property" && !property.computed && propertyName(property) === "flex");
+/** `styles.content` and `styles["content"]` both read as that pair; a dynamic key reads as null. */
+const styleReference = (node) => {
+    if (node?.type !== "MemberExpression" || node.object.type !== "Identifier")
+        return null;
+    const sheet = node.object.name;
+    if (!node.computed && node.property.type === "Identifier")
+        return { sheet, key: node.property.name };
+    if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") {
+        return { sheet, key: node.property.value };
+    }
+    return null;
+};
+/** A style prop holds one style or an array of them; both read as a list. */
+const styleParts = (value) => {
+    if (!value)
+        return [];
+    if (value.type !== "ArrayExpression")
+        return [value];
+    return value.elements.filter(element => element !== null);
+};
+export const noFlexInContentContainer = problem("Disallow `flex` in a Legend List's `contentContainerStyle`, where it sizes the scrolled content to the viewport and the list ends up measuring zero height.", {
+    createOnce(context) {
+        let flexKeysBySheet = new Map();
+        let candidates = [];
+        const holdsFlex = (part) => {
+            if (hasFlexKey(part))
+                return true;
+            const reference = styleReference(part);
+            return reference !== null && (flexKeysBySheet.get(reference.sheet)?.has(reference.key) ?? false);
+        };
+        return {
+            before() {
+                flexKeysBySheet = new Map();
+                candidates = [];
+                return gate(context, "contentContainerStyle");
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type !== "Identifier" || init?.type !== "CallExpression" || !isStyleSheetCreate(init))
+                    return;
+                const object = stylesObjectOf(init.arguments[0]);
+                if (!object)
+                    return;
+                const flexKeys = new Set();
+                for (const property of object.properties) {
+                    if (property.type !== "Property" || property.computed)
+                        continue;
+                    const name = propertyName(property);
+                    if (name !== "" && hasFlexKey(property.value))
+                        flexKeys.add(name);
+                }
+                flexKeysBySheet.set(id.name, flexKeys);
+            },
+            JSXAttribute(node) {
+                if (attributeName(node) !== "contentContainerStyle")
+                    return;
+                if (!isListElement(node.parent.parent))
+                    return;
+                const parts = styleParts(expressionOf(node));
+                if (parts.length > 0)
+                    candidates.push({ node, parts });
+            },
+            "Program:exit"() {
+                for (const { node, parts } of candidates) {
+                    if (parts.some(part => holdsFlex(part)))
+                        context.report({ node, message: MESSAGE });
+                }
+            },
+        };
+    },
+});

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

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

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

@@ -0,0 +1,26 @@
+import { attributeName, gate, problem, subtreeHas } from "../../../lib/ast.js";
+import { expressionOf, isListElement } from "./shared.js";
+export const noIndexKeyExtractor = problem("Disallow a `keyExtractor` that uses its index parameter. Cached sizes and recycled row state hang off the key, so a prepend points every measurement at the wrong item.", {
+    createOnce: context => ({
+        before: () => gate(context, "keyExtractor"),
+        JSXAttribute(node) {
+            if (attributeName(node) !== "keyExtractor")
+                return;
+            if (!isListElement(node.parent.parent))
+                return;
+            const fn = expressionOf(node);
+            if (fn?.type !== "ArrowFunctionExpression" && fn?.type !== "FunctionExpression")
+                return;
+            const indexParam = fn.params[1];
+            if (indexParam?.type !== "Identifier")
+                return;
+            if (!subtreeHas(fn.body, current => current.type === "Identifier" && current.name === indexParam.name)) {
+                return;
+            }
+            context.report({
+                node: fn,
+                message: "Return a stable per-item id from this `keyExtractor` instead of the index. Legend List hangs cached sizes and recycled row state off the key, so one prepend re-points every measurement at the wrong item.",
+            });
+        },
+    }),
+});

package/dist/react-native/rules/legend-list/no-inline-data.d.ts

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

package/dist/react-native/rules/legend-list/no-inline-data.js

@@ -0,0 +1,25 @@
+import { FUNCTION_TYPES, calleeName, crossesFunctionBefore, findInSubtree, gate, problem } from "../../../lib/ast.js";
+import { attributeNamed, expressionOf, isListElement, LIST } from "./shared.js";
+const MEMO_HOOKS = new Set(["useMemo", "useCallback"]);
+const buildsFreshArray = (node) => node.type === "ArrayExpression" || (node.type === "CallExpression" && node.callee.type === "MemberExpression");
+export const noInlineData = problem("Disallow building a Legend List's `data` inline. Each render produces a new array reference, and the list re-diffs, re-keys and drops what it had cached.", {
+    createOnce: context => ({
+        before: () => gate(context, LIST),
+        JSXElement(node) {
+            if (!isListElement(node))
+                return;
+            const data = attributeNamed(node, "data");
+            if (!data)
+                return;
+            if (MEMO_HOOKS.has(calleeName(expressionOf(data))))
+                return;
+            const built = findInSubtree(data.value, buildsFreshArray);
+            if (!built || crossesFunctionBefore(built, data, FUNCTION_TYPES))
+                return;
+            context.report({
+                node: data,
+                message: "Hoist this `data` into a `useMemo` or compute it upstream so its reference is stable. A new array each render makes the list re-diff, re-key and invalidate everything it had cached.",
+            });
+        },
+    }),
+});

package/dist/react-native/rules/legend-list/no-inline-extra-data.d.ts

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

package/dist/react-native/rules/legend-list/no-inline-extra-data.js

@@ -0,0 +1,21 @@
+import { attributeName, gate, problem } from "../../../lib/ast.js";
+import { expressionOf, isListElement, literalKind } from "./shared.js";
+export const noInlineExtraData = problem("An inline object or array as `extraData` takes a new identity on every parent render, and every mounted row re-evaluates with it.", {
+    createOnce: context => ({
+        before: () => gate(context, "extraData"),
+        JSXAttribute(node) {
+            if (attributeName(node) !== "extraData")
+                return;
+            if (!isListElement(node.parent.parent))
+                return;
+            const value = expressionOf(node);
+            const kind = literalKind(value);
+            if (value === null || kind === null)
+                return;
+            context.report({
+                node: value,
+                message: `Pass the primitive that actually changed as \`extraData\`, or hoist this ${kind} when it is stable. A fresh ${kind} reference each render re-evaluates every mounted row.`,
+            });
+        },
+    }),
+});

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

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