rnwind 0.0.1 → 0.0.2

package/lib/esm/runtime/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../../src/runtime/index.ts"],"sourcesContent":["\n\n\n\nexport {\n  lookupCss,\n  registerAtoms,\n  registerBreakpoints,\n  registerSchemeLoader,\n  setWindowHeightProvider,\n  getBreakpoints,\n  activeBreakpointFor,\n  lookupCss as _l,\n} from './lookup-css'\nexport { useR_ } from './components/rnwind-provider'\nexport type { HoistedClassName, InteractState, LookupInsets, SafeMarkerSpec } from './lookup-css'\nexport { useCss } from './hooks/use-css'\nexport { useInteract } from './hooks/use-interact'\nexport type { UseInteractResult } from './hooks/use-interact'\nexport { chainPress, chainFocus } from './chain-handlers'\nexport { InteractiveBox, InteractiveBox as _ib } from './interactive-box'\nexport type { InteractiveBoxProps, InteractiveSpec } from './interactive-box'\nexport { RnwindProvider, useRnwind } from './components/rnwind-provider'\nexport type { RnwindProviderProps, RnwindState, Insets } from './components/rnwind-provider'\nexport { useMountHaptic, triggerHaptic, triggerHaptic as _ht, useMountHaptic as _hm } from './haptics'\n\n// ──────────────────────────────────────────────────────────────────────\n// Internal aliases the babel transformer uses. Underscore-prefixed so\n// user code (which imports the public names above) can never collide\n// with what we inject at JSX sites — even if the user shadows\n// `lookupCss` / `useHaptics` / `InteractiveBox` with a local symbol,\n// the transformer's emitted code still references the private alias.\n// Don't import these in app code.\n// ──────────────────────────────────────────────────────────────────────\n/** @internal */\n\n/** @internal */\n\n/** @internal */\n\n/** @internal */\n\nexport type { HapticRequest, HapticTrigger, OnHaptics } from '../core/parser/haptics'\nexport type { AsLinearGradientProps, LinearGradientPoint } from './gradient-types'\nexport type { ThemeTable, ThemeTables } from '../core/types'\nexport { useTheme, useToken, useColor, useSize } from './hooks/use-scheme'\nexport type { Scheme, RnwindConfig } from './types'\n\n/**\n * Installed rnwind version, inlined at publish time. Compare against a pinned\n * string when integrating with build tooling that may see multiple rnwind\n * copies (e.g. workspace overrides).\n */\nexport const VERSION = '0.0.1' as const\n"],"names":[],"mappings":";;;;;;;;;AAgDA;;;;AAIG;AACI,MAAM,OAAO,GAAG;;;;"}

package/lib/esm/runtime/interactive-box.d.ts

@@ -0,0 +1,40 @@
+import { type ElementType, type ReactElement } from 'react';
+import { type HoistedClassName } from './lookup-css';
+import type { RnwindState } from './components/rnwind-provider';
+/**
+ * Per-element "interactive" spec the transformer packs into the `_rw`
+ * prop on every JSX site it rewrites for active/focus support. Carrying
+ * it as one object prop (rather than four sibling props) keeps the
+ * rewritten JSX legible and avoids colliding with any host component's
+ * own naming.
+ */
+export interface InteractiveSpec {
+    /** The original JSX tag (`Pressable`, `TextInput`, `Animated.View`, …). */
+    readonly as: ElementType;
+    /** Hoisted atom-name array (or a dynamic classname string). */
+    readonly cn: HoistedClassName | string | null | undefined;
+    /** Full rnwind context — `_t = useRnwind___()` from the call site. */
+    readonly t: RnwindState;
+    /** Optional caller-supplied style forwarded as `lookupCss`'s 3rd arg. */
+    readonly us?: unknown;
+}
+/** Props InteractiveBox accepts — `_rw` plus anything to forward. */
+export interface InteractiveBoxProps {
+    /** Compile-time spec packed by the transformer. */
+    readonly _rw: InteractiveSpec;
+    /** Every other prop passes through to the inner component. */
+    readonly [key: string]: unknown;
+}
+/**
+ * Per-instance wrapper that drives `active:` / `focus:` variants. One
+ * `useInteract()` hook per mounted `InteractiveBox` means each element
+ * owns its own state — siblings never share `active` / `focus` flags.
+ *
+ * The transformer replaces
+ *   `<Pressable className="active:bg-sky-700" onPress={x} />`
+ * with
+ *   `<InteractiveBox _rw={{as: Pressable, cn: _c0, t: _t}} onPress={x} />`.
+ * @param props `_rw` spec + any props to forward to the inner component.
+ * @returns Rendered element of the inner component with interact wiring.
+ */
+export declare function InteractiveBox(props: InteractiveBoxProps): ReactElement;

package/lib/esm/runtime/interactive-box.mjs

@@ -0,0 +1,33 @@
+import { createElement } from 'react';
+import { chainFocus, chainPress } from './chain-handlers.mjs';
+import { useInteract } from './hooks/use-interact.mjs';
+import { lookupCss } from './lookup-css.mjs';
+
+/**
+ * Per-instance wrapper that drives `active:` / `focus:` variants. One
+ * `useInteract()` hook per mounted `InteractiveBox` means each element
+ * owns its own state — siblings never share `active` / `focus` flags.
+ *
+ * The transformer replaces
+ *   `<Pressable className="active:bg-sky-700" onPress={x} />`
+ * with
+ *   `<InteractiveBox _rw={{as: Pressable, cn: _c0, t: _t}} onPress={x} />`.
+ * @param props `_rw` spec + any props to forward to the inner component.
+ * @returns Rendered element of the inner component with interact wiring.
+ */
+function InteractiveBox(props) {
+    const { _rw, onPressIn, onPressOut, onFocus, onBlur, ...rest } = props;
+    const interact = useInteract();
+    const merged = {
+        ...rest,
+        style: lookupCss(_rw.cn, _rw.t, _rw.us, interact.state),
+        onPressIn: chainPress(onPressIn, interact.onPressIn),
+        onPressOut: chainPress(onPressOut, interact.onPressOut),
+        onFocus: chainFocus(onFocus, interact.onFocus),
+        onBlur: chainFocus(onBlur, interact.onBlur),
+    };
+    return createElement(_rw.as, merged);
+}
+
+export { InteractiveBox };
+//# sourceMappingURL=interactive-box.mjs.map

package/lib/esm/runtime/interactive-box.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactive-box.mjs","sources":["../../../../src/runtime/interactive-box.tsx"],"sourcesContent":["import { createElement, type ComponentType, type ElementType, type ReactElement } from 'react'\nimport { chainFocus, chainPress } from './chain-handlers'\nimport { useInteract } from './hooks/use-interact'\nimport { lookupCss, type HoistedClassName } from './lookup-css'\nimport type { RnwindState } from './components/rnwind-provider'\n\n/**\n * Per-element \"interactive\" spec the transformer packs into the `_rw`\n * prop on every JSX site it rewrites for active/focus support. Carrying\n * it as one object prop (rather than four sibling props) keeps the\n * rewritten JSX legible and avoids colliding with any host component's\n * own naming.\n */\nexport interface InteractiveSpec {\n  /** The original JSX tag (`Pressable`, `TextInput`, `Animated.View`, …). */\n  readonly as: ElementType\n  /** Hoisted atom-name array (or a dynamic classname string). */\n  readonly cn: HoistedClassName | string | null | undefined\n  /** Full rnwind context — `_t = useRnwind___()` from the call site. */\n  readonly t: RnwindState\n  /** Optional caller-supplied style forwarded as `lookupCss`'s 3rd arg. */\n  readonly us?: unknown\n}\n\n/** Props InteractiveBox accepts — `_rw` plus anything to forward. */\nexport interface InteractiveBoxProps {\n  /** Compile-time spec packed by the transformer. */\n  readonly _rw: InteractiveSpec\n  /** Every other prop passes through to the inner component. */\n  readonly [key: string]: unknown\n}\n\n/**\n * Per-instance wrapper that drives `active:` / `focus:` variants. One\n * `useInteract()` hook per mounted `InteractiveBox` means each element\n * owns its own state — siblings never share `active` / `focus` flags.\n *\n * The transformer replaces\n *   `<Pressable className=\"active:bg-sky-700\" onPress={x} />`\n * with\n *   `<InteractiveBox _rw={{as: Pressable, cn: _c0, t: _t}} onPress={x} />`.\n * @param props `_rw` spec + any props to forward to the inner component.\n * @returns Rendered element of the inner component with interact wiring.\n */\nexport function InteractiveBox(props: InteractiveBoxProps): ReactElement {\n  const { _rw, onPressIn, onPressOut, onFocus, onBlur, ...rest } = props\n  const interact = useInteract()\n  const merged: Record<string, unknown> = {\n    ...rest,\n    style: lookupCss(_rw.cn, _rw.t, _rw.us, interact.state),\n    onPressIn: chainPress(onPressIn as Parameters<typeof chainPress>[0], interact.onPressIn),\n    onPressOut: chainPress(onPressOut as Parameters<typeof chainPress>[0], interact.onPressOut),\n    onFocus: chainFocus(onFocus as Parameters<typeof chainFocus>[0], interact.onFocus),\n    onBlur: chainFocus(onBlur as Parameters<typeof chainFocus>[0], interact.onBlur),\n  }\n  return createElement(_rw.as as ComponentType<Record<string, unknown>>, merged)\n}\n"],"names":[],"mappings":";;;;;AAgCA;;;;;;;;;;;AAWG;AACG,SAAU,cAAc,CAAC,KAA0B,EAAA;AACvD,IAAA,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK;AACtE,IAAA,MAAM,QAAQ,GAAG,WAAW,EAAE;AAC9B,IAAA,MAAM,MAAM,GAA4B;AACtC,QAAA,GAAG,IAAI;AACP,QAAA,KAAK,EAAE,SAAS,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC;QACvD,SAAS,EAAE,UAAU,CAAC,SAA6C,EAAE,QAAQ,CAAC,SAAS,CAAC;QACxF,UAAU,EAAE,UAAU,CAAC,UAA8C,EAAE,QAAQ,CAAC,UAAU,CAAC;QAC3F,OAAO,EAAE,UAAU,CAAC,OAA2C,EAAE,QAAQ,CAAC,OAAO,CAAC;QAClF,MAAM,EAAE,UAAU,CAAC,MAA0C,EAAE,QAAQ,CAAC,MAAM,CAAC;KAChF;IACD,OAAO,aAAa,CAAC,GAAG,CAAC,EAA4C,EAAE,MAAM,CAAC;AAChF;;;;"}

package/lib/esm/runtime/lookup-css.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Runtime resolver for rnwind-transformed files.
+ *
+ * Hot path is ONE WeakMap.get + cached-array return for stable atoms
+ * (no `active:`/`focus:`/`*-safe` variance beyond what the cache key
+ * captures). First call per (hoist, scheme, stateIndex) walks the
+ * atoms once, looks each up as
+ *
+ *   `cache.atoms[scheme]?.[atom] ?? cache.atoms.common?.[atom]`
+ *
+ * and caches the result. `registerAtoms(scheme, record)` bumps a
+ * version counter; the next lookup notices the mismatch and rebuilds.
+ *
+ * Keyframes are inlined directly into atom values via `animationName`
+ * at build time — no separate registry.
+ */
+import type { RnwindState } from './components/rnwind-provider';
+/**
+ * One entry in the sorted-by-threshold breakpoints array. The runtime
+ * derives an atom's threshold by matching its `<prefix>:` against
+ * `name`; the array form is preferred over a Map so the hot-path
+ * `tierFor(width)` walk is a tight numeric loop.
+ */
+interface BreakpointEntry {
+    readonly name: string;
+    readonly minWidth: number;
+}
+/** Optional window-height provider for the `screen-minus-y` marker. */
+type WindowHeightProvider = () => number;
+/**
+ * Optional scheme loader. Registered by the generated manifest module
+ * (`rnwind/__generated/schemes`) once at import time. SchemeProvider
+ * calls it synchronously on every render with the active scheme name;
+ * first call per scheme pulls the scheme's style module in via an
+ * inline `require()` — subsequent calls are a no-op through Metro's
+ * module cache.
+ */
+type SchemeLoader = (scheme: string) => void;
+/**
+ * Per-render snapshot of which interactive states (active, focus) are
+ * currently engaged. Forwarded from the `useInteract()` hook the
+ * transformer injects.
+ */
+export interface InteractState {
+    active?: boolean;
+    focus?: boolean;
+}
+/**
+ * Safe-area insets bundle the transformer passes to `lookupCss` when a
+ * file uses any `*-safe` utility.
+ */
+export interface LookupInsets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * Precomputed safe-area marker spec emitted by the build-side
+ * `envelopeSafeMarkers`. Tuple form: `[cssKey, sideTag, or, offset]`.
+ */
+export type SafeMarkerSpec = readonly [string, string, number | undefined, number | undefined];
+/** Type alias: the atom-list build output the transformer emits. */
+export type HoistedClassName = readonly string[];
+/**
+ * Register a window-height provider used by the `screen-minus-y`
+ * safe-area variant. When not wired, `h-screen-safe` resolves to `0`.
+ * @param provider Callback returning the current window height in px.
+ */
+export declare function setWindowHeightProvider(provider: WindowHeightProvider | null): void;
+/**
+ * Register the scheme-loader function exported by the generated
+ * manifest module. Called once at manifest-module evaluation time —
+ * subsequent registrations override the previous loader (useful for
+ * tests).
+ * @param loader Manifest's `ensureSchemeLoaded` function, or null to
+ *   detach (tests).
+ */
+export declare function registerSchemeLoader(loader: SchemeLoader | null): void;
+/**
+ * Ensure the given scheme's style module is loaded. Safe to call in
+ * render — zero-cost after the first call per scheme thanks to
+ * Metro's module cache, and a no-op when no loader is registered
+ * (tests, or a bundle without rnwind-transformed sources).
+ * @param scheme Active scheme name.
+ */
+export declare function loadScheme(scheme: string): void;
+/**
+ * Register (or re-register) one scheme's atoms in the global registry.
+ * Pure property assignment — no iteration, no allocation. The version
+ * counter bump invalidates every hoist-level result cache lazily on
+ * next read.
+ * @param scheme Registry key — `'common'` for the always-loaded
+ *   fallback, or a variant name (`'dark'`, `'light'`, `'brand'`, ...).
+ * @param atoms Plain record keyed by atom name.
+ */
+export declare function registerAtoms(scheme: string, atoms: Record<string, unknown>): void;
+/**
+ * Register the responsive-breakpoint table the manifest module emits at
+ * load time. Replaces the prior table — calling with `{}` clears it.
+ * Bumps `atomVersion` so any cached lookup invalidates on next read,
+ * which matters during a theme HMR cycle that adds/removes breakpoints.
+ * @param breakpoints Breakpoint name → minimum-width threshold (px).
+ */
+export declare function registerBreakpoints(breakpoints: Record<string, number>): void;
+/**
+ * Snapshot of the registered breakpoints, for callers that want to
+ * compute their own derivations (e.g. the provider deriving the active
+ * breakpoint name). Returns a fresh array — callers can iterate without
+ * worrying about concurrent mutation from a manifest reload.
+ * @returns Breakpoints sorted by ascending min-width threshold.
+ */
+export declare function getBreakpoints(): readonly BreakpointEntry[];
+/**
+ * Sentinel name returned by {@link activeBreakpointFor} ONLY when no
+ * breakpoints are registered at all (bundle without rnwind-transformed
+ * sources, fresh test setup). When at least one breakpoint is
+ * registered, the function falls back to the smallest registered name
+ * instead — so phone-width devices (402 dp on a stock iPhone, well
+ * below `sm = 640`) report `activeBreakpoint === 'sm'` rather than the
+ * abstract `'base'`. This matches the user expectation that the value
+ * is always a real Tailwind breakpoint label they can branch on.
+ *
+ * Note: this is decoupled from the className filter. `sm:*` atoms
+ * still only fire at `windowWidth >= 640` per Tailwind's mobile-first
+ * spec — `activeBreakpoint === 'sm'` at 402 means "I'm in the smallest
+ * tier", not "`sm:` classes are firing".
+ */
+export declare const BASE_BREAKPOINT = "base";
+/**
+ * Resolve the currently-active breakpoint name for a width:
+ *  - `windowWidth >= some threshold` → the highest matching breakpoint name.
+ *  - below every registered threshold → the smallest registered name.
+ *  - no breakpoints registered → {@link BASE_BREAKPOINT}.
+ * Always returns a string so consumers can branch on it without
+ * null-handling.
+ * @param windowWidth Live window width in px.
+ * @returns Active breakpoint name (never null).
+ */
+export declare function activeBreakpointFor(windowWidth: number): string;
+/**
+ * Resolve a className input against the active rnwind context. Hot
+ * path:
+ *  - Array input (build hoist): ONE WeakMap.get + ONE record-access
+ *    + cached array return. No per-render allocation when there's no
+ *    userStyle and the hoist has no safe atoms.
+ *  - String input (dynamic `className={expr}`): tokenise + walk.
+ * @param input Hoisted atom list or raw className string.
+ * @param ctx Rnwind context — `{scheme, fontScale, insets}` (extra
+ *   fields ignored). Pass the result of `useRnwind()` directly.
+ * @param userStyle Optional caller-supplied style appended last.
+ * @param interactState Live active/focus flags from `useInteract()`.
+ * @returns Style array for React Native's `style` prop.
+ */
+export declare function lookupCss(input: HoistedClassName | string | null | undefined, ctx: RnwindState, userStyle?: unknown, interactState?: InteractState): readonly unknown[];
+/** Test-only — clear the global registry between suites. */
+export declare function __resetLookupCssState(): void;
+/**
+ * Test-only sugar: accept a single-scheme record and register it as the
+ * `common` table.
+ * @param record Atom name → value record (registered under `common`).
+ */
+export declare function __registerAtomsFromRecord(record: Record<string, unknown>): void;
+export {};