@ashstack/lint 0.1.0

package/dist/react-native/rules/unistyles/in-sheet.js

@@ -0,0 +1,116 @@
+import { calleeName, subtreeHas } from "../../../lib/ast.js";
+import { inCreate, isStyleSheetCreate, memberPath, propertyName } from "./shared.js";
+const LOGICAL_SPACING = new Set(["paddingLeft", "paddingRight", "marginLeft", "marginRight"]);
+const LEGACY_SHADOW = new Set(["shadowColor", "shadowOffset", "shadowOpacity", "shadowRadius", "elevation"]);
+const MESSAGES = {
+    logicalSpacing: "Use `paddingStart`/`paddingEnd` or `marginStart`/`marginEnd` here so the directional spacing mirrors in RTL.",
+    rtlInSheet: "Use `rt.rtl` for RTL-dependent styles so Unistyles tracks the dependency natively.",
+    screenDimensions: "Use reactive `rt.screen` inside `StyleSheet.create` instead of a `Dimensions.get` snapshot.",
+    pixelRatio: "Use reactive `rt.pixelRatio` inside `StyleSheet.create`.",
+    fontScale: "Use reactive `rt.fontScale` inside `StyleSheet.create`.",
+    statusBar: "Use reactive `rt.statusBar.height` inside `StyleSheet.create`.",
+    colorScheme: "Use the Unistyles theme or reactive `rt.colorScheme` inside `StyleSheet.create`.",
+    fullRuntime: "Use the injected mini runtime (`rt`) inside `StyleSheet.create` instead of `UnistylesRuntime`, so the style recalculates on its own.",
+    fullRuntimeDestructure: "Destructure from the injected mini runtime (`rt`) inside `StyleSheet.create`, not from `UnistylesRuntime`.",
+    themeScreen: "Use reactive `rt.screen`, or Unistyles breakpoints, instead of the theme's module-initialization screen snapshot.",
+    borderCurve: 'Add `borderCurve` (normally `"continuous"`) alongside `borderRadius`, or the corner renders as a circular arc rather than the squircle native iOS controls use.',
+    legacyShadow: 'Use `boxShadow` with CSS syntax, e.g. `boxShadow: "0 2px 8px rgba(0, 0, 0, 0.1)"`, which renders on both platforms on the New Architecture, instead of the legacy `shadow*`/`elevation` props.',
+    asConst: "Drop `as const` here — the typed `StyleSheet.create` already narrows the literal. If TS still widens the value to `string`, fix the `StyleSheet` import instead.",
+};
+export const inSheet = inCreate("Inside `StyleSheet.create`, require `rt` and theme values rather than Dimensions, PixelRatio, Appearance, I18nManager, StatusBar or `UnistylesRuntime`. It also covers logical spacing, `boxShadow`, `borderCurve` and a redundant `as const`.", (context, inside) => ({
+    CallExpression(node) {
+        if (!inside() || isStyleSheetCreate(node))
+            return;
+        const { callee } = node;
+        const path = callee.type === "MemberExpression" ? memberPath(callee) : calleeName(node);
+        if (path === "Dimensions.get")
+            context.report({ node, message: MESSAGES.screenDimensions });
+        else if (path === "PixelRatio.get")
+            context.report({ node, message: MESSAGES.pixelRatio });
+        else if (path === "PixelRatio.getFontScale")
+            context.report({ node, message: MESSAGES.fontScale });
+        else if (path === "Appearance.getColorScheme")
+            context.report({ node, message: MESSAGES.colorScheme });
+        else if (path === "useColorScheme")
+            context.report({ node, message: MESSAGES.colorScheme });
+    },
+    MemberExpression(node) {
+        if (!inside())
+            return;
+        const { parent } = node;
+        if (parent.type === "MemberExpression" && parent.object === node)
+            return;
+        const path = memberPath(node);
+        if (path === "I18nManager.isRTL") {
+            context.report({ node, message: MESSAGES.rtlInSheet });
+            return;
+        }
+        if (path === "StatusBar.currentHeight") {
+            context.report({ node, message: MESSAGES.statusBar });
+            return;
+        }
+        if (path.startsWith("UnistylesRuntime.")) {
+            context.report({ node, message: MESSAGES.fullRuntime });
+            return;
+        }
+        if (path.startsWith("theme.screen."))
+            context.report({ node, message: MESSAGES.themeScreen });
+    },
+    VariableDeclarator(node) {
+        if (!inside())
+            return;
+        const { id, init } = node;
+        if (id.type !== "ObjectPattern")
+            return;
+        if (init?.type === "Identifier" && init.name === "UnistylesRuntime") {
+            context.report({ node, message: MESSAGES.fullRuntimeDestructure });
+        }
+    },
+    TSAsExpression(node) {
+        if (!inside())
+            return;
+        const { typeAnnotation } = node;
+        if (typeAnnotation.type !== "TSTypeReference")
+            return;
+        const { typeName } = typeAnnotation;
+        if (typeName.type !== "Identifier" || typeName.name !== "const")
+            return;
+        context.report({ node, message: MESSAGES.asConst });
+    },
+    ObjectExpression(node) {
+        if (!inside())
+            return;
+        let borderRadius = null;
+        let hasBorderCurve = false;
+        for (const property of node.properties) {
+            if (property.type !== "Property")
+                continue;
+            const name = propertyName(property);
+            if (name === "borderRadius")
+                borderRadius = property;
+            else if (name === "borderCurve")
+                hasBorderCurve = true;
+        }
+        if (borderRadius && !hasBorderCurve)
+            context.report({ node: borderRadius, message: MESSAGES.borderCurve });
+    },
+    Property(node) {
+        if (!inside())
+            return;
+        const name = propertyName(node);
+        if (LEGACY_SHADOW.has(name)) {
+            context.report({ node, message: MESSAGES.legacyShadow });
+            return;
+        }
+        if (!LOGICAL_SPACING.has(name))
+            return;
+        const usesInsets = subtreeHas(node, current => {
+            if (current.type !== "MemberExpression")
+                return false;
+            const path = memberPath(current);
+            return path === "rt.insets.left" || path === "rt.insets.right";
+        });
+        if (!usesInsets)
+            context.report({ node, message: MESSAGES.logicalSpacing });
+    },
+}));

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

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

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

@@ -0,0 +1,58 @@
+import { defineModule } from "../../../lib/module.js";
+import { animatedTheme } from "./animated-theme.js";
+import { contentContainer } from "./content-container.js";
+import { inSheet } from "./in-sheet.js";
+import { insets } from "./insets.js";
+import { noHardcodedColor } from "./no-hardcoded-color.js";
+import { noHardcodedSpacing } from "./no-hardcoded-spacing.js";
+import { noMargin } from "./no-margin.js";
+import { noStyleSpread } from "./no-style-spread.js";
+import { noUnusedStyles } from "./no-unused-styles.js";
+import { rtlStyleCall } from "./rtl-style-call.js";
+import { themeScreenComponent } from "./theme-screen-component.js";
+import { themeStyleAttr } from "./theme-style-attr.js";
+export default defineModule({
+    meta: { name: "@ashstack/unistyles" },
+    rules: {
+        "animated-theme": animatedTheme,
+        "content-container": contentContainer,
+        "in-sheet": inSheet,
+        insets: insets,
+        "no-hardcoded-color": noHardcodedColor,
+        "no-hardcoded-spacing": noHardcodedSpacing,
+        "no-margin": noMargin,
+        "no-style-spread": noStyleSpread,
+        "no-unused-styles": noUnusedStyles,
+        "rtl-style-call": rtlStyleCall,
+        "theme-screen-component": themeScreenComponent,
+        "theme-style-attr": themeStyleAttr,
+    },
+    url: import.meta.url,
+    packages: ["react-native-unistyles"],
+    option: "unistyles",
+    docsWhen: "auto-enabled when `react-native-unistyles` is a dependency",
+    restrictedImports: {
+        paths: [
+            {
+                name: "react-native",
+                importNames: ["StyleSheet"],
+                message: "Import `StyleSheet` from `react-native-unistyles` instead of `react-native`.",
+            },
+            {
+                name: "react-native",
+                importNames: ["useWindowDimensions", "Dimensions"],
+                message: "Read screen size from `rt.screen` inside `StyleSheet.create`, or `UnistylesRuntime.screen` outside it, instead of the `Dimensions` APIs.",
+            },
+            {
+                name: "react-native",
+                importNames: ["SafeAreaView"],
+                message: 'Set `contentInsetAdjustmentBehavior="automatic"` on the scroll view, or apply `rt.insets` from `react-native-unistyles`, instead of `SafeAreaView`.',
+            },
+            {
+                name: "react-native-safe-area-context",
+                importNames: ["useSafeAreaInsets", "useSafeAreaFrame", "SafeAreaView"],
+                message: "Read safe-area values from `rt.insets`, or `UnistylesRuntime.insets` outside a stylesheet, in `react-native-unistyles`.",
+            },
+        ],
+    },
+});

package/dist/react-native/rules/unistyles/insets.d.ts

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

package/dist/react-native/rules/unistyles/insets.js

@@ -0,0 +1,92 @@
+import { calleeName, closestAncestor, gate, problem, subtreeHas } from "../../../lib/ast.js";
+import { isStyleSheetCreate } from "./shared.js";
+const INSET_TEXT = /(?:inset|safearea|top|bottom|left|right)/i;
+const MESSAGES = {
+    insetsStyleCall: "Read safe-area values from `rt.insets` inside `StyleSheet.create` instead of passing `useSafeAreaInsets()` into a style function.",
+    insetsAttribute: "Resolve these safe-area values through `rt.insets` in `StyleSheet.create` instead of a hook-fed inline JSX style object.",
+};
+const boundNames = (id) => {
+    if (id.type === "Identifier")
+        return [id.name];
+    if (id.type === "AssignmentPattern")
+        return boundNames(id.left);
+    if (id.type === "RestElement")
+        return boundNames(id.argument);
+    if (id.type === "ArrayPattern")
+        return id.elements.flatMap(element => (element ? boundNames(element) : []));
+    if (id.type !== "ObjectPattern")
+        return [];
+    return id.properties.flatMap(property => property.type === "Property" ? boundNames(property.value) : boundNames(property.argument));
+};
+export const insets = problem("Disallow passing `useSafeAreaInsets()` values into a dynamic style function or an inline JSX style object. Read `rt.insets` inside `StyleSheet.create` instead.", {
+    createOnce(context) {
+        const insetBindings = new Set();
+        const sheets = new Set();
+        const styleCalls = [];
+        const styleAttributes = [];
+        return {
+            before() {
+                insetBindings.clear();
+                sheets.clear();
+                styleCalls.length = 0;
+                styleAttributes.length = 0;
+                return gate(context, "useSafeAreaInsets");
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type === "Identifier" && isStyleSheetCreate(init)) {
+                    sheets.add(id.name);
+                    return;
+                }
+                if (calleeName(init) !== "useSafeAreaInsets")
+                    return;
+                for (const name of boundNames(id))
+                    insetBindings.add(name);
+            },
+            CallExpression(node) {
+                const { callee } = node;
+                if (callee.type !== "MemberExpression")
+                    return;
+                const receiver = callee.object;
+                if (receiver.type !== "Identifier")
+                    return;
+                const exempt = closestAncestor(node, new Set(["JSXAttribute"]));
+                if (exempt?.type === "JSXAttribute" &&
+                    exempt.name.type === "JSXIdentifier" &&
+                    exempt.name.name === "contentContainerStyle") {
+                    return;
+                }
+                styleCalls.push({ node, receiver: receiver.name });
+            },
+            JSXAttribute(node) {
+                if (node.name.type !== "JSXIdentifier" || node.name.name !== "style")
+                    return;
+                styleAttributes.push(node);
+            },
+            "Program:exit"() {
+                const referencesBinding = (node) => subtreeHas(node, current => current.type === "Identifier" && insetBindings.has(current.name));
+                for (const entry of styleCalls) {
+                    if (!sheets.has(entry.receiver))
+                        continue;
+                    const text = context.sourceCode.getText(entry.node);
+                    if (!INSET_TEXT.test(text))
+                        continue;
+                    if (!referencesBinding(entry.node))
+                        continue;
+                    context.report({ node: entry.node, message: MESSAGES.insetsStyleCall });
+                }
+                for (const attribute of styleAttributes) {
+                    const text = context.sourceCode.getText(attribute);
+                    if (!INSET_TEXT.test(text))
+                        continue;
+                    const usesInsetsMember = subtreeHas(attribute, current => current.type === "MemberExpression" &&
+                        current.object.type === "Identifier" &&
+                        insetBindings.has(current.object.name));
+                    if (!usesInsetsMember)
+                        continue;
+                    context.report({ node: attribute, message: MESSAGES.insetsAttribute });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/unistyles/no-hardcoded-color.d.ts

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

package/dist/react-native/rules/unistyles/no-hardcoded-color.js

@@ -0,0 +1,30 @@
+import { ancestors } from "../../../lib/ast.js";
+import { inCreate, propertyName } from "./shared.js";
+const HEX_COLOR = /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+const CSS_COLOR_FUNCTION = /^(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color)\(/i;
+const MESSAGE = "Use a `theme.colors` token for this value — a raw color bypasses dark mode and never shifts with the theme. If no token fits, add one to the theme.";
+const COLOR_KEY = /^colors?$|Colors?$/;
+/** The nearest style property this literal belongs to, seen through the arrays a gradient uses. */
+const underAColorKey = (node) => {
+    for (const current of ancestors(node)) {
+        if (current.type === "ArrayExpression")
+            continue;
+        if (current.type !== "Property")
+            return false;
+        return COLOR_KEY.test(propertyName(current));
+    }
+    return false;
+};
+export const noHardcodedColor = inCreate("Disallow hex and CSS-function colors inside `StyleSheet.create`. A raw color skips dark mode and never changes with the theme.", (context, inside) => ({
+    Literal(node) {
+        if (!inside())
+            return;
+        if (typeof node.value !== "string")
+            return;
+        if (!HEX_COLOR.test(node.value) && !CSS_COLOR_FUNCTION.test(node.value))
+            return;
+        if (!underAColorKey(node))
+            return;
+        context.report({ node, message: MESSAGE });
+    },
+}));

package/dist/react-native/rules/unistyles/no-hardcoded-spacing.d.ts

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

package/dist/react-native/rules/unistyles/no-hardcoded-spacing.js

@@ -0,0 +1,78 @@
+import { findInSubtree, hasAncestor, subtreeHas } from "../../../lib/ast.js";
+import { inCreate, memberPath, propertyName } from "./shared.js";
+const SPACING_AND_TYPE_SCALE = new Set([
+    "padding",
+    "paddingTop",
+    "paddingBottom",
+    "paddingHorizontal",
+    "paddingVertical",
+    "paddingStart",
+    "paddingEnd",
+    "margin",
+    "marginTop",
+    "marginBottom",
+    "marginHorizontal",
+    "marginVertical",
+    "marginStart",
+    "marginEnd",
+    "gap",
+    "rowGap",
+    "columnGap",
+    "borderRadius",
+    "borderTopLeftRadius",
+    "borderTopRightRadius",
+    "borderBottomLeftRadius",
+    "borderBottomRightRadius",
+    "fontSize",
+    "lineHeight",
+]);
+const SIGNIFICANT_NUMBER = /^-?[1-9][0-9]*(?:\.[0-9]+)?$/;
+const MESSAGE = "Use `theme.spacing[...]` or `theme.sizing.scale(...)` for this value, so a rhythm change stays one edit. If no token fits, add one to the theme.";
+const isThemeScaleHost = (node) => hasAncestor(node, current => {
+    if (current.type === "MemberExpression") {
+        const path = memberPath(current);
+        if (path.startsWith("theme.spacing") || path.startsWith("theme.sizing"))
+            return true;
+    }
+    if (current.type === "CallExpression") {
+        const { callee } = current;
+        const path = callee.type === "MemberExpression" ? memberPath(callee) : "";
+        if (path === "theme.spacing.scale" || path === "theme.sizing.scale" || path === "theme.scale")
+            return true;
+    }
+    return false;
+});
+const isTokenDerived = (node) => subtreeHas(node, current => {
+    if (current.type === "MemberExpression") {
+        const path = memberPath(current);
+        return path.startsWith("theme.spacing") || path.startsWith("theme.sizing");
+    }
+    if (current.type === "CallExpression" && current.callee.type === "MemberExpression") {
+        const path = memberPath(current.callee);
+        return path === "theme.spacing.scale" || path === "theme.sizing.scale" || path === "theme.scale";
+    }
+    return false;
+});
+export const noHardcodedSpacing = inCreate("Require `theme.spacing` or `theme.sizing.scale` for spacing, radius and type values inside `StyleSheet.create`, instead of raw numbers.", (context, inside) => ({
+    Property(node) {
+        if (!inside())
+            return;
+        const name = propertyName(node);
+        if (!SPACING_AND_TYPE_SCALE.has(name))
+            return;
+        if (isTokenDerived(node.value))
+            return;
+        const rawNumber = findInSubtree(node.value, current => (current.type === "Literal" &&
+            typeof current.value === "number" &&
+            SIGNIFICANT_NUMBER.test(String(current.value)) &&
+            !isThemeScaleHost(current)) ||
+            (current.type === "UnaryExpression" &&
+                current.operator === "-" &&
+                current.argument.type === "Literal" &&
+                typeof current.argument.value === "number" &&
+                SIGNIFICANT_NUMBER.test(`-${current.argument.value}`) &&
+                !isThemeScaleHost(current)));
+        if (rawNumber)
+            context.report({ node: rawNumber, message: MESSAGE });
+    },
+}));

package/dist/react-native/rules/unistyles/no-margin.d.ts

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

package/dist/react-native/rules/unistyles/no-margin.js

@@ -0,0 +1,19 @@
+import { subtreeHas } from "../../../lib/ast.js";
+import { inCreate, propertyName } from "./shared.js";
+const ANY_MARGIN = /^margin(?:$|Top$|Bottom$|Left$|Right$|Start$|End$|Horizontal$|Vertical$)/;
+/** A negative margin overlaps on purpose, and a zero one resets; neither is the spacing this rule replaces. */
+const isNegationOrZero = (current) => (current.type === "UnaryExpression" && current.operator === "-") ||
+    (current.type === "Literal" && typeof current.value === "number" && current.value <= 0);
+const MESSAGE = "Use `gap` on the parent or `padding` on this element instead of `margin`. Margin escapes the child's own box, so it leaves stray space behind when the first or last child is removed; a negative margin stays allowed for overlap and half-size centering, and `0` for a reset.";
+export const noMargin = inCreate("Disallow non-negative `margin` inside `StyleSheet.create`; `gap` on the parent or `padding` on the element spaces children without leaving a hole when one is removed.", (context, inside) => ({
+    Property(node) {
+        if (!inside())
+            return;
+        const name = propertyName(node);
+        if (name === "" || !ANY_MARGIN.test(name))
+            return;
+        if (subtreeHas(node.value, isNegationOrZero))
+            return;
+        context.report({ node, message: MESSAGE });
+    },
+}));

package/dist/react-native/rules/unistyles/no-style-spread.d.ts

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

package/dist/react-native/rules/unistyles/no-style-spread.js

@@ -0,0 +1,41 @@
+import { gate, problem } from "../../../lib/ast.js";
+import { isStyleSheetCreate } from "./shared.js";
+const MESSAGE = "Compose styles with an array — `[styles.a, styles.b]` — instead of spreading. A spread reads the object once and breaks the Unistyles C++ proxy, so the style silently stops reacting to the theme.";
+const spreadBase = (node) => {
+    let current = node;
+    while (current?.type === "MemberExpression")
+        current = current.object;
+    return current?.type === "Identifier" ? current.name : "";
+};
+export const noStyleSpread = problem("Disallow spreading a stylesheet style into another object. The spread reads through the Unistyles C++ proxy once, so the result stops reacting to the theme.", {
+    createOnce(context) {
+        const sheets = new Set();
+        const candidates = [];
+        return {
+            before() {
+                sheets.clear();
+                candidates.length = 0;
+                return gate(context, "...");
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type === "Identifier" && isStyleSheetCreate(init))
+                    sheets.add(id.name);
+            },
+            SpreadElement(node) {
+                if (node.parent.type !== "ObjectExpression")
+                    return;
+                const base = spreadBase(node.argument);
+                if (base !== "")
+                    candidates.push({ node, base });
+            },
+            "Program:exit"() {
+                for (const candidate of candidates) {
+                    if (!sheets.has(candidate.base) && !/[Ss]tyles$/.test(candidate.base))
+                        continue;
+                    context.report({ node: candidate.node, message: MESSAGE });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/unistyles/no-unused-styles.d.ts

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

package/dist/react-native/rules/unistyles/no-unused-styles.js

@@ -0,0 +1,99 @@
+import { gate, problem } from "../../../lib/ast.js";
+import { CREATE_MARKER, isStyleSheetCreate, propertyName, stylesObjectOf } from "./shared.js";
+const EVERY_KEY = "*";
+const namedStyleKeys = (styles) => {
+    const keys = new Map();
+    for (const property of styles.properties) {
+        if (property.type !== "Property" || property.computed)
+            return null;
+        const name = propertyName(property);
+        if (name === "")
+            return null;
+        keys.set(name, property.key);
+    }
+    return keys;
+};
+export const noUnusedStyles = problem("Disallow stylesheet keys that nothing in the file reads. A computed key, a computed read, or a sheet that leaves the module skips the whole file.", {
+    createOnce(context) {
+        let declaredStyleKeys = new Map();
+        let readStyleKeys = new Set();
+        let aUseCouldBeHidden = false;
+        const markRead = (sheet, key) => {
+            readStyleKeys.add(`${sheet}.${key}`);
+        };
+        const markWholeSheetRead = (sheet) => {
+            markRead(sheet, EVERY_KEY);
+        };
+        const reportUnusedAtEndOfFile = () => {
+            if (aUseCouldBeHidden)
+                return;
+            for (const [sheet, keys] of declaredStyleKeys) {
+                if (readStyleKeys.has(`${sheet}.${EVERY_KEY}`))
+                    continue;
+                for (const [name, keyNode] of keys) {
+                    if (readStyleKeys.has(`${sheet}.${name}`))
+                        continue;
+                    context.report({
+                        node: keyNode,
+                        message: `Delete \`${sheet}.${name}\` — nothing reads it, so it is dead weight that keeps a token alive nothing renders.`,
+                    });
+                }
+            }
+        };
+        return {
+            before() {
+                declaredStyleKeys = new Map();
+                readStyleKeys = new Set();
+                aUseCouldBeHidden = false;
+                return gate(context, CREATE_MARKER);
+            },
+            CallExpression(node) {
+                if (!isStyleSheetCreate(node))
+                    return;
+                const declarator = node.parent.type === "VariableDeclarator" ? node.parent : null;
+                const id = declarator?.id;
+                if (id?.type !== "Identifier") {
+                    aUseCouldBeHidden = true;
+                    return;
+                }
+                const styles = stylesObjectOf(node.arguments[0]);
+                const keys = styles === null ? null : namedStyleKeys(styles);
+                if (keys === null) {
+                    aUseCouldBeHidden = true;
+                    return;
+                }
+                declaredStyleKeys.set(id.name, keys);
+            },
+            MemberExpression(node) {
+                const { object, property } = node;
+                if (object.type !== "Identifier")
+                    return;
+                if (node.computed) {
+                    markWholeSheetRead(object.name);
+                    return;
+                }
+                if (property.type === "Identifier")
+                    markRead(object.name, property.name);
+            },
+            ExportNamedDeclaration(node) {
+                const { declaration } = node;
+                if (declaration?.type === "VariableDeclaration") {
+                    for (const child of declaration.declarations) {
+                        if (child.id.type === "Identifier")
+                            markWholeSheetRead(child.id.name);
+                    }
+                }
+                for (const specifier of node.specifiers) {
+                    if (specifier.local.type === "Identifier")
+                        markWholeSheetRead(specifier.local.name);
+                }
+            },
+            ExportDefaultDeclaration(node) {
+                const { declaration } = node;
+                if (declaration.type === "Identifier")
+                    markWholeSheetRead(declaration.name);
+            },
+            "Program:exit": reportUnusedAtEndOfFile,
+        };
+    },
+});

package/dist/react-native/rules/unistyles/rtl-style-call.d.ts

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

package/dist/react-native/rules/unistyles/rtl-style-call.js

@@ -0,0 +1,42 @@
+import { closestAncestor, gate, problem } from "../../../lib/ast.js";
+import { CREATE_MARKER, isStyleSheetCreate, memberPath } from "./shared.js";
+const MESSAGE = "Read `rt.rtl` inside the dynamic style instead of passing `I18nManager.isRTL` in from JSX.";
+export const rtlStyleCall = problem("Disallow passing `I18nManager.isRTL` from JSX into a dynamic style function. Unistyles tracks the dependency itself once the style reads `rt.rtl`.", {
+    createOnce(context) {
+        const sheets = new Set();
+        const candidates = [];
+        return {
+            before() {
+                sheets.clear();
+                candidates.length = 0;
+                return gate(context, CREATE_MARKER);
+            },
+            VariableDeclarator(node) {
+                const { id, init } = node;
+                if (id.type === "Identifier" && isStyleSheetCreate(init))
+                    sheets.add(id.name);
+            },
+            MemberExpression(node) {
+                if (memberPath(node) !== "I18nManager.isRTL")
+                    return;
+                const call = closestAncestor(node, new Set(["CallExpression"]));
+                if (call?.type !== "CallExpression")
+                    return;
+                const { callee } = call;
+                if (callee.type !== "MemberExpression")
+                    return;
+                const receiver = callee.object;
+                if (receiver.type !== "Identifier")
+                    return;
+                candidates.push({ call, receiver: receiver.name });
+            },
+            "Program:exit"() {
+                for (const candidate of candidates) {
+                    if (!sheets.has(candidate.receiver))
+                        continue;
+                    context.report({ node: candidate.call, message: MESSAGE });
+                }
+            },
+        };
+    },
+});

package/dist/react-native/rules/unistyles/shared.d.ts

@@ -0,0 +1,16 @@
+import type { AstNode, Rule, RuleContext, Visitor } from "../../../lib/types.js";
+export { CREATE_MARKER, isStyleSheetCreate, propertyName, stylesObjectOf, type StylesObject, } from "../../stylesheet.js";
+export declare const memberPath: (node: AstNode | null | undefined) => string;
+export declare const declaresUseUnistylesTheme: (scope: AstNode) => boolean;
+/**
+ * The enclosing function that destructures a `useUnistyles()` theme, innermost first. Walking past the
+ * innermost function matters: the read is often inside a callback the component passes down.
+ */
+export declare const themeConsumingComponent: (node: AstNode) => AstNode | null;
+export declare const readsTheme: (node: AstNode) => boolean;
+/**
+ * Builds a rule whose visitors only fire inside `StyleSheet.create(...)`, by tracking how deeply
+ * nested the traversal currently is in such a call. The depth resets per file in `before()`, which
+ * also runs the text gate.
+ */
+export declare const inCreate: (description: string, visit: (context: RuleContext, inside: () => boolean) => Visitor) => Rule;