pixelize-native-library 1.0.6

package/lib/typescript/modules/timeline/Timeline.variants.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Timeline's style + colour resolution — pure, React/lucide-free, same split as `Button`:
+ *  - STRUCTURE (row layout, marker diameter, connector width, content spacing) lives in the
+ *    `createThemedVariants` resolvers below, registered once per theme identity — never rebuilt
+ *    per render.
+ *  - COLOUR is resolved from the theme's ROLE colours (`resolveTimelineColors`), never a raw hex:
+ *    every marker is the accent role and every text tier a fixed `fg` role. There is no
+ *    `tone`/`color` prop to widen — a Timeline event has no per-item emphasis to express, so (like
+ *    `resolveAvatarColors` / `resolveTabsColors`) this is pure indirection, not a union to resolve.
+ *
+ * Free of React and of any lucide import, so the WCAG + colour-mapping tests import it directly
+ * (mocking only `react-native`'s `StyleSheet`, as `core/style` and every sibling module's tests do).
+ */
+import type { RoleColors, Theme } from "../../theme";
+export interface TimelineMarkerSpec {
+    /** Plain-dot diameter, in dp — used when an item carries no `icon`. */
+    readonly dot: number;
+    /** Icon-circle diameter, in dp — used when an item carries an `icon`. Also the connector
+     *  column's fixed width, so a dot row and an icon row centre on the same vertical axis. */
+    readonly icon: number;
+    /** Glyph size inside the icon circle, in dp. */
+    readonly glyph: number;
+}
+/**
+ * Timeline-specific dimensions. Kept a plain constant — no theme dependency — same as
+ * `BUTTON_SIZES` / `AVATAR_SIZES`, so the render layer and tests share one source of truth.
+ *
+ * Not a touch target: Timeline has no `onPress` in this contract (a purely informational list), so
+ * the 44dp floor interactive modules hold themselves to (see `Button`'s `MIN_TOUCH_TARGET`) does
+ * not apply here — same reasoning `AVATAR_SIZES` documents for its own non-interactive diameters.
+ */
+export declare const TIMELINE_MARKER: TimelineMarkerSpec;
+export interface TimelineColors {
+    /** Marker fill — the plain dot, or the icon circle's background. */
+    readonly markerFill: string;
+    /** The icon glyph on `markerFill` — derived, so it always clears 4.5:1 (never a hardcoded white). */
+    readonly markerIcon: string;
+    /** The line connecting one marker to the next — decorative, the same role `Divider` uses. */
+    readonly connector: string;
+    readonly title: string;
+    readonly description: string;
+    readonly timestamp: string;
+}
+/**
+ * Maps Timeline's fixed visual roles onto ROLE colours — never a hardcoded hex. There is no
+ * `tone`/`color` prop to widen: every event reads identically, so every colour Timeline can show is
+ * one of these role lookups, guaranteed legible in both modes.
+ */
+export declare function resolveTimelineColors(colors: RoleColors): TimelineColors;
+/**
+ * The whole row: the connector column beside the content column. No theme dependency (a plain
+ * constant layout, like `spinnerBox`/`radioDotStructure`), so this uses `createVariants`, not the
+ * themed resolver — no theme identity to cache against.
+ */
+export declare const timelineRowStructure: import("../../core/style").VariantResolver<import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/**
+ * The connector column — fixed at the icon circle's width so a dot row and an icon row centre on
+ * the same vertical axis regardless of which marker kind that particular item renders. No explicit
+ * height: it stretches (the row's default cross-axis behaviour for a `flexDirection: "row"`
+ * container) to match the content column's height, which is what lets the line below the marker
+ * reach all the way down to the next row's marker — see `timelineContentStructure` below. No theme
+ * dependency, so `createVariants` again.
+ */
+export declare const timelineConnectorStructure: import("../../core/style").VariantResolver<import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** The marker itself — a small dot, or a larger circle sized to hold an icon glyph. */
+export declare const timelineMarkerStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    kind: {
+        dot: {
+            width: number;
+            height: number;
+        };
+        icon: {
+            width: number;
+            height: number;
+        };
+    };
+}, import("react-native").ViewStyle>;
+/**
+ * The line connecting one marker to the next. `flex: 1` fills whatever height the connector
+ * column above stretches to; a `middle` row's CONTENT carries the extra bottom padding that makes
+ * that stretched height reach past the text into the gap before the next row (see
+ * `timelineContentStructure`), so the line never visibly stops short of the next marker.
+ */
+export declare const timelineConnectorLineStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/**
+ * The text column beside the connector. A `middle` row (one with a following item) reserves the
+ * gap to that next row HERE, on the content sibling, not on the shared row wrapper — a row with an
+ * undetermined height stretches its children to its tallest child's own intrinsic height, so
+ * padding placed on the row itself would sit outside what the connector column stretches to match,
+ * leaving a visible break in the line. Placed on content instead, the padding becomes part of the
+ * height the connector column stretches to, so the line spans through it.
+ */
+export declare const timelineContentStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    position: {
+        middle: {
+            paddingBottom: 24;
+        };
+        last: {
+            paddingBottom: number;
+        };
+    };
+}, import("react-native").ViewStyle>;
+//# sourceMappingURL=Timeline.variants.d.ts.map

package/lib/typescript/modules/timeline/Timeline.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Timeline.variants.d.ts","sourceRoot":"","sources":["../../../../src/modules/timeline/Timeline.variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGrD,MAAM,WAAW,kBAAkB;IACjC,uEAAuE;IACvE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;+FAC2F;IAC3F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,kBAAoD,CAAC;AAEnF,MAAM,WAAW,cAAc;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,qGAAqG;IACrG,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,6FAA6F;IAC7F,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,GAAG,cAAc,CAkBxE;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,0JAI/B,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,0JAKrC,CAAC;AAEH,uFAAuF;AACvF,eAAO,MAAM,uBAAuB;;;;;;;;;;;oCAajC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,uKAKxC,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;oCAYlC,CAAC"}

package/lib/typescript/modules/timeline/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Public surface of `pixelize-native-library/timeline`. Value exports and type exports are split for
+ * `verbatimModuleSyntax`. The internal resolvers (`resolveTimelineColors`, `TIMELINE_MARKER`, …)
+ * stay internal — a consumer configures a Timeline through its `items`, never by importing internals.
+ */
+export { Timeline } from "./Timeline";
+export type { TimelineProps, TimelineItem } from "./Timeline";
+export type { IconName } from "../../core/icon";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/timeline/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/timeline/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG9D,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}

package/lib/typescript/modules/toast/Toast.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Toast — a `ToastProvider` + `useToast()` hook, not a component a consumer places directly (it has
+ * no visual home of its own to lay out: it always floats above whatever the provider wraps). Every
+ * screen mounts `ToastProvider` once, near the root; any descendant calls `useToast().show(...)`.
+ *
+ * Deliberately NOT React Native's `<Modal>`: a confirmed iOS bug drops or breaks a second `<Modal>`
+ * presented while a sibling Modal — this library's own, or an OS share sheet — is still mounted or
+ * mid-dismiss-animation, so a toast shown over one would silently fail. The overlay is instead a
+ * plain absolutely-positioned `View` mounted at the provider's own root, entirely outside RN's Modal
+ * system, so it floats over anything without competing for the same presentation stack.
+ *
+ * Single-slot by design: `show()` while a toast is already visible replaces its message/tone and
+ * restarts the auto-dismiss timer (and, since a fresh message reads as a new event, restarts the
+ * entrance animation) rather than queueing a second one. `dismiss()` always dismisses that one slot,
+ * and is a safe no-op when nothing is showing.
+ */
+import type { ReactNode } from "react";
+import type { ToastPosition, ToastTone } from "./Toast.variants";
+export interface ToastOptions {
+    readonly message: string;
+    readonly tone?: ToastTone;
+    /** Auto-dismiss delay in ms. Defaults to `DEFAULT_TOAST_DURATION` (~3000ms). */
+    readonly duration?: number;
+}
+export interface ToastContextValue {
+    show: (options: ToastOptions) => void;
+    dismiss: () => void;
+}
+export interface ToastProviderProps {
+    children: ReactNode;
+    /** Which screen edge the toast hugs. Provider-level (one overlay for the whole app), not per-toast.
+     * Defaults to `top`. */
+    position?: ToastPosition;
+}
+export declare const ToastProvider: import("react").NamedExoticComponent<ToastProviderProps>;
+/** Throws outside a `ToastProvider` — same contract as `useTheme()`. */
+export declare function useToast(): ToastContextValue;
+//# sourceMappingURL=Toast.d.ts.map

package/lib/typescript/modules/toast/Toast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Toast.d.ts","sourceRoot":"","sources":["../../../../src/modules/toast/Toast.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAkBvC,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEjE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAC1B,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;IACtC,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,SAAS,CAAC;IACpB;4BACwB;IACxB,QAAQ,CAAC,EAAE,aAAa,CAAC;CAC1B;AAeD,eAAO,MAAM,aAAa,0DAmExB,CAAC;AA6DH,wEAAwE;AACxE,wBAAgB,QAAQ,IAAI,iBAAiB,CAS5C"}

package/lib/typescript/modules/toast/Toast.variants.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Toast's style + behaviour resolution — same split as Button.variants:
+ *  - STRUCTURE (padding, radius, gap, the accent bar's width, the overlay's edge inset, the overlay's
+ *    z-index) lives in the themed resolvers below, static per (brand, mode), registered once via
+ *    `StyleSheet.create`.
+ *  - COLOUR is `tone`-driven and resolved from the theme's ROLE colours by `resolveToastTone`, never
+ *    a raw ramp and never a hardcoded hex.
+ *  - ACCESSIBILITY: the screen-reader announcement (WCAG 4.1.3) is one cross-platform imperative
+ *    `AccessibilityInfo.announceForAccessibility` call in `Toast.tsx`'s `show()`, not a tone-driven
+ *    resolver here — every tone announces the same way.
+ *
+ * Free of React and of `lucide`, so the WCAG + behaviour tests import it directly (mocking only
+ * `react-native`'s `StyleSheet`, as `core/style` does).
+ */
+import type { RoleColors } from "../../theme";
+import type { Theme } from "../../theme";
+export type ToastTone = "success" | "warning" | "danger" | "info" | "neutral";
+export type ToastPosition = "top" | "bottom";
+/** Same floor as Button/Input/Checkbox — 44dp (WCAG 2.5.5 / HIG). Duplicated, not imported: modules
+ * stay isolated. */
+export declare const MIN_TOUCH_TARGET = 44;
+/** The close button's own visual box + glyph. Toast takes no `size` prop, so this is a fixed pair,
+ * not a scale — mirrors `BUTTON_SIZES`' shape for exactly one size. */
+export declare const CLOSE_BUTTON_SIZE = 24;
+export declare const CLOSE_ICON_SIZE = 16;
+export declare const CLOSE_HIT_SLOP: number;
+/** `duration?: number` on `ToastOptions` defaults to this when omitted. */
+export declare const DEFAULT_TOAST_DURATION = 3000;
+export interface ToastToneColors {
+    /** The card's own background — constant across tones (an elevated, neutral surface). */
+    readonly background: string;
+    /** The left accent bar. */
+    readonly accent: string;
+    /** The message colour. */
+    readonly text: string;
+}
+/**
+ * Maps `tone` onto the theme's role colours. The whole reason the prop is a closed union and not
+ * `color?: string`: every colour a Toast can show is one of these role lookups, so it can never be
+ * an off-palette value an app invented, and it inverts light↔dark for free.
+ *
+ * The card always sits on `bg.raised` — the same "elevated surface" role `Card`'s own `elevated`
+ * variant uses (`Card.variants.ts`). The accent bar and the message BOTH read `status.<role>.text`,
+ * deliberately NOT `status.<role>.solid`: `solid` is only measured against its own pale `subtle` fill
+ * (`roleColors.test.ts`'s `status.solid` vs `status.onSolid`/`subtle` promises), and on
+ * `success`/`warning`/`info` in light mode it falls as low as ~1.9:1 against `bg.raised` — nowhere
+ * near the 3:1 floor a rendered accent bar needs. `text` is the rung `readableOn` already proved
+ * ≥ 4.5:1 nearby, which comfortably clears the bar's lighter 3:1 floor too — one role, measured here
+ * for both jobs, rather than a second unverified pairing (`Toast.test.ts`).
+ */
+export declare function resolveToastTone(colors: RoleColors, tone: ToastTone): ToastToneColors;
+/**
+ * Structural styles only — the card's padding, radius, and gap. No colour (tone-driven, applied
+ * inline over this) and no shadow (elevation is applied directly from `theme.elevation.lg`, same
+ * idiom as `Card`), so this compiles once per theme identity via the `WeakMap`-cached themed
+ * resolver and never rebuilds per render. `overflow: "hidden"` lets the accent bar's square corners
+ * get clipped by the card's own rounding instead of resolving a second radius for the bar.
+ */
+export declare const toastCardStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** The accent bar's width — a structural constant on the theme's `space` scale, not a hardcoded dp. */
+export declare const toastAccentBarStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/**
+ * The overlay's inset from the screen edge it hugs, plus its stacking order. `position` is
+ * provider-level (one overlay for the whole app), not per-toast, so it lives here as a themed
+ * structural variant rather than something `resolveToastTone` touches. `zIndex` is themed (not a
+ * per-render inline value) for the same reason as the rest of this file: it's a structural,
+ * theme-scoped constant, so it belongs in the cached resolver, not recomputed as a fresh object
+ * every render in `Toast.tsx`.
+ */
+export declare const toastOverlayStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    position: {
+        top: {
+            top: 16;
+        };
+        bottom: {
+            bottom: 16;
+        };
+    };
+}, import("react-native").ViewStyle>;
+//# sourceMappingURL=Toast.variants.d.ts.map

package/lib/typescript/modules/toast/Toast.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Toast.variants.d.ts","sourceRoot":"","sources":["../../../../src/modules/toast/Toast.variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGzC,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAC9E,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,QAAQ,CAAC;AAE7C;oBACoB;AACpB,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAGnC;uEACuE;AACvE,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,cAAc,QAA6B,CAAC;AAEzD,2EAA2E;AAC3E,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,MAAM,WAAW,eAAe;IAC9B,wFAAwF;IACxF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,2BAA2B;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,GAAG,eAAe,CAUrF;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,uKAU5B,CAAC;AAEJ,uGAAuG;AACvG,eAAO,MAAM,uBAAuB,uKAEjC,CAAC;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;oCAgB/B,CAAC"}

package/lib/typescript/modules/toast/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Public surface of `pixelize-native-library/toast`. Value exports and type exports are split for
+ * `verbatimModuleSyntax`. The pure resolvers (`resolveToastTone`, …) stay internal — a consumer
+ * configures a toast through `show(options)`, never by importing them.
+ *
+ * No `IconName` re-export here: unlike `Button`, Toast takes no public `icon` prop — its dismiss
+ * glyph is a fixed internal choice, not something a consumer selects.
+ */
+export { ToastProvider, useToast } from "./Toast";
+export type { ToastContextValue, ToastOptions, ToastProviderProps } from "./Toast";
+export type { ToastPosition, ToastTone } from "./Toast.variants";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/toast/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/toast/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAClD,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAEnF,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC"}

package/lib/typescript/modules/tooltip/Tooltip.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Tooltip — wraps a single trigger element and reveals a short themed tip on long-press, without
+ * requiring the trigger to know anything about it. No `style` prop: unlike the other modules,
+ * Tooltip renders no sized node of its own for an app to place — the trigger child keeps whatever
+ * layout it already has, and the wrapping host below exists only to anchor the bubble.
+ *
+ * Composition is `React.cloneElement` on the single child, never `{...rest}`: `onLongPress` and
+ * `onPressOut` are injected (chaining any handler the child already defined, so Tooltip never
+ * silently breaks a trigger that already used them), and `accessibilityHint` is MERGED via
+ * `mergeAccessibilityHint` — the one prop that must never be clobbered, since it is how a
+ * screen-reader user gets the tip's content without performing the gesture at all.
+ */
+import type { ReactElement } from "react";
+import type { GestureResponderEvent } from "react-native";
+import type { TooltipPlacement } from "./Tooltip.variants";
+/** The subset of props Tooltip reads from / injects into its trigger child. */
+export interface TooltipTriggerProps {
+    onLongPress?: (event: GestureResponderEvent) => void;
+    onPressOut?: (event: GestureResponderEvent) => void;
+    accessibilityHint?: string;
+}
+export interface TooltipProps {
+    /** The tip's text. Also what gets merged into the trigger's `accessibilityHint`. */
+    label: string;
+    /** A single element that accepts `onLongPress`/`onPressOut` (e.g. a `Pressable`). */
+    children: ReactElement<TooltipTriggerProps>;
+    placement?: TooltipPlacement;
+    testID?: string;
+}
+export declare const Tooltip: import("react").NamedExoticComponent<TooltipProps>;
+//# sourceMappingURL=Tooltip.d.ts.map

package/lib/typescript/modules/tooltip/Tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tooltip.d.ts","sourceRoot":"","sources":["../../../../src/modules/tooltip/Tooltip.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAM1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IAClC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACrD,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACpD,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,YAAY;IAC3B,oFAAoF;IACpF,KAAK,EAAE,MAAM,CAAC;IACd,qFAAqF;IACrF,QAAQ,EAAE,YAAY,CAAC,mBAAmB,CAAC,CAAC;IAC5C,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,OAAO,oDA+FlB,CAAC"}

package/lib/typescript/modules/tooltip/Tooltip.variants.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Tooltip's pure resolvers + the themed structural variant resolver — same split as Button:
+ *
+ *  - STRUCTURE (padding, radius, the placement offset) lives in `tooltipBubbleStructure`, a
+ *    `createThemedVariants` resolver, static per (brand, mode), registered once.
+ *  - COLOUR is not tone-driven here — the bubble always reads `bg.raised` / `fg.default`, so it is
+ *    resolved inline in the component from `theme.colors`, never a hardcoded hex.
+ *  - The accessibility-hint MERGE is `mergeAccessibilityHint`, kept pure so "never clobber the
+ *    child's existing hint" is unit-testable without mounting React.
+ *
+ * Free of `lucide` and of any React tree, so the WCAG + behaviour tests import it directly
+ * (mocking only `react-native`'s `StyleSheet`, as `core/style` does).
+ */
+import type { Theme } from "../../theme";
+export type TooltipPlacement = "top" | "bottom";
+/**
+ * Design constants, not theme tokens — this module's own timing, not a scale other components
+ * share.
+ */
+export declare const TOOLTIP_TIMING: {
+    /** Fade-in duration; skipped (duration 0) when the OS reduce-motion setting is on (WCAG 2.3.3). */
+    readonly fadeInMs: 150;
+    /** Fallback auto-dismiss so a tip can't stay stuck open if `onPressOut` never fires. */
+    readonly autoHideMs: 2500;
+};
+/**
+ * Appends `label` to any `accessibilityHint` the trigger already carries, so screen-reader users
+ * get the tip's content without needing the long-press gesture — the child's own hint is
+ * preserved, never overwritten. Reuses the existing sentence's terminal punctuation if there is
+ * one, so the merged hint reads as two sentences rather than a run-on.
+ */
+export declare function mergeAccessibilityHint(existing: string | undefined, label: string): string;
+/**
+ * Structural styles only — no colour (the bubble's fill/label are resolved from `RoleColors` in
+ * the component). `left: 0` anchors the bubble to the trigger's left edge rather than stretching
+ * it to the trigger's full width: a v1 simplification (no measurement library) that reads better
+ * for small icon-sized triggers than forcing the tip's width to match them. `maxWidth` reuses the
+ * shared `sizes` primitive's smallest step rather than a new hardcoded number.
+ */
+export declare const tooltipBubbleStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    placement: {
+        bottom: {
+            top: "100%";
+            marginTop: 4;
+        };
+        top: {
+            bottom: "100%";
+            marginBottom: 4;
+        };
+    };
+}, import("react-native").ViewStyle>;
+//# sourceMappingURL=Tooltip.variants.d.ts.map

package/lib/typescript/modules/tooltip/Tooltip.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tooltip.variants.d.ts","sourceRoot":"","sources":["../../../../src/modules/tooltip/Tooltip.variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAIzC,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,cAAc;IACzB,mGAAmG;;IAEnG,wFAAwF;;CAEhF,CAAC;AAEX;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK1F;AAED;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;oCAgBhC,CAAC"}

package/lib/typescript/modules/tooltip/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Public surface of `pixelize-native-library/tooltip`. Value exports and type exports are split for
+ * `verbatimModuleSyntax`. The pure resolvers (`mergeAccessibilityHint`, `tooltipBubbleStructure`,
+ * `TOOLTIP_TIMING`) stay internal — a consumer configures a Tooltip through its props only.
+ */
+export { Tooltip } from "./Tooltip";
+export type { TooltipProps, TooltipTriggerProps } from "./Tooltip";
+export type { TooltipPlacement } from "./Tooltip.variants";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/tooltip/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/tooltip/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEnE,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/theme/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The `pixelize-native-library/theme` public surface — the provider, the three hooks, and the theme-side
+ * types a consumer annotates with. Design tokens themselves ship under `pixelize-native-library/tokens`;
+ * this subpath is intentionally the small, runtime-facing layer an app wires once at its root.
+ */
+export { PixelizeProvider, useTheme, useThemeColors, useThemeMode, createAsyncStorageAdapter, } from './provider';
+export type { PixelizeProviderProps, Theme, ThemeModeValue, ThemeMode, ColorModeStorageAdapter, AsyncStorageLike, } from './provider';
+export type { RoleColors, StatusColors, StatusRole } from './tokens/roles';
+export type { ThemeName, ColorScheme, PaletteProps } from './tokens/types';
+export { themeNames, DEFAULT_THEME } from './tokens/brands';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/theme/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/theme/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,gBAAgB,EAChB,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,yBAAyB,GAC1B,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,qBAAqB,EACrB,KAAK,EACL,cAAc,EACd,SAAS,EACT,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAGpB,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC3E,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/lib/typescript/theme/platform/colorScheme.native.d.ts

@@ -0,0 +1,12 @@
+export type ColorMode = 'light' | 'dark';
+/**
+ * `Appearance.getColorScheme()` is nullable — `null` when the native Appearance module is
+ * unavailable — and on RN 0.85+ can also report `'unspecified'`. Our peer floor spans both, so
+ * anything that isn't explicitly `'dark'` floors to light, mirroring web's matchMedia which only
+ * ever asks "is it dark?". Read it per render, never cache: it changes at sunrise/sunset and on
+ * `Appearance.setColorScheme()`.
+ */
+export declare function getSystemColorMode(): ColorMode;
+/** Returns an unsubscribe fn. */
+export declare function subscribeToSystemColorMode(callback: (mode: ColorMode) => void): () => void;
+//# sourceMappingURL=colorScheme.native.d.ts.map

package/lib/typescript/theme/platform/colorScheme.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorScheme.native.d.ts","sourceRoot":"","sources":["../../../../src/theme/platform/colorScheme.native.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;AAEzC;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,SAAS,CAE9C;AAED,iCAAiC;AACjC,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,GAClC,MAAM,IAAI,CAKZ"}

package/lib/typescript/theme/platform/elevation.native.d.ts

@@ -0,0 +1,35 @@
+import type { ViewStyle } from 'react-native';
+import type { ElevationToken } from '../tokens/primitives';
+/**
+ * The style props an elevation resolves to. A `Pick` rather than `ViewStyle` so a future RN
+ * shadow prop cannot silently widen what this function is allowed to emit.
+ */
+export type ElevationStyle = Pick<ViewStyle, 'shadowColor' | 'shadowOffset' | 'shadowOpacity' | 'shadowRadius' | 'elevation'>;
+/**
+ * Resolve an elevation token to RN style props.
+ *
+ * Uses the legacy shadow props over `boxShadow` because `boxShadow` is New-Architecture-only, and
+ * our peer range (RN >= 0.79) still lets a consumer ship `newArchEnabled=false` — on which
+ * `boxShadow` renders nothing at all. The legacy props map straight to the platform APIs and are
+ * not deprecated, so they are the only path that works on both architectures. react-native-web's
+ * style preprocessor converts these same legacy props into a real CSS `box-shadow`, so the `web`
+ * branch below rides that conversion rather than emitting `boxShadow` itself.
+ *
+ * An elevation token is a STACK of layers (web needs both an ambient and a contact shadow per
+ * step), but legacy RN shadow props can only express one. This renders `layers[0]` — the dominant
+ * layer — and drops the rest. That is an honest limit of the legacy path, not a token compromise:
+ * a future `boxShadow`-only resolver (new-arch-only consumers) can render every layer.
+ *
+ * `layer.spread` is dropped — neither legacy platform API exposes it (RN implements it by
+ * insetting a custom shadowPath). The ramp's `md`/`lg` carry a negative spread to tighten the
+ * shadow on web, so those two steps read marginally wider here. Accepted: honouring it would mean
+ * hand-drawing a shadow layer per view.
+ *
+ * Returns one of three shapes: `ios`, `android` (RN's `default` branch — Android reads the numeric
+ * `elevation` prop and ignores offset/opacity/radius), and `web`. `web` MUST stay its own explicit
+ * key: without it, react-native-web falls through to `default` (the Android shape), whose only
+ * meaningful field — `elevation` — react-native-web silently ignores (it is Android-only), so the
+ * shadow renders as nothing at all.
+ */
+export declare function elevation(token: ElevationToken): ElevationStyle;
+//# sourceMappingURL=elevation.native.d.ts.map

package/lib/typescript/theme/platform/elevation.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevation.native.d.ts","sourceRoot":"","sources":["../../../../src/theme/platform/elevation.native.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,CAC/B,SAAS,EACT,aAAa,GAAG,cAAc,GAAG,eAAe,GAAG,cAAc,GAAG,WAAW,CAChF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,cAAc,CAgC/D"}

package/lib/typescript/theme/platform/fonts.native.d.ts

@@ -0,0 +1,41 @@
+import type { TextStyle } from 'react-native';
+import { fontWeights } from '../tokens/primitives';
+/**
+ * The weight VALUES the `fontWeights` tokens resolve to ('400'…'700') — which is exactly RN's own
+ * `fontWeight` string domain. Derived from the token so adding a weight there fails the `satisfies`
+ * below until a matching face is registered here.
+ */
+export type FontWeightValue = (typeof fontWeights)[keyof typeof fontWeights];
+/** The style a weight resolves to. Never both keys at once — see `fontStyleForWeight`. */
+export type FontStyleForWeight = Pick<TextStyle, 'fontFamily' | 'fontWeight'>;
+/**
+ * Keyed by the weight VALUE, not the token name, because the value is what a copied web call passes
+ * (`fontStyleForWeight(fontWeights.semibold)`) and what the `fontWeight` fallback below needs
+ * verbatim — one input serves the family lookup and the fallback.
+ *
+ * The values are the family names the consumer app registers with expo-font. Loading Inter is the
+ * app's job; this library takes no font dependency:
+ *   useFonts({ 'Inter-Regular': require('…'), 'Inter-SemiBold': require('…'), … })
+ */
+export declare const interFontFamilies: {
+    readonly '400': "Inter-Regular";
+    readonly '500': "Inter-Medium";
+    readonly '600': "Inter-SemiBold";
+    readonly '700': "Inter-Bold";
+};
+/** The platform's own UI font, used when the app has not registered Inter. */
+export declare const systemFontFamily: string;
+/**
+ * Resolve a weight to a text style.
+ *
+ * With Inter loaded this returns `fontFamily` ONLY, deliberately omitting `fontWeight`: each Inter
+ * face already carries its weight, and pairing a weighted face with `fontWeight` makes Android
+ * synthesise a faux-bold on top of it. The system fallback is the reverse — one family, so the
+ * weight has to be carried by `fontWeight` (the token value is already the string RN expects).
+ *
+ * `interLoaded` is passed in from the theme provider, not detected: without expo-font there is no
+ * way to ask whether a family registered, and an unregistered family degrades inconsistently
+ * (silent fallback on Android, a warning on iOS).
+ */
+export declare function fontStyleForWeight(weight: FontWeightValue, interLoaded?: boolean): FontStyleForWeight;
+//# sourceMappingURL=fonts.native.d.ts.map

package/lib/typescript/theme/platform/fonts.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fonts.native.d.ts","sourceRoot":"","sources":["../../../../src/theme/platform/fonts.native.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,WAAW,CAAC,CAAC;AAE7E,0FAA0F;AAC1F,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC,CAAC;AAE9E;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;;;CAKsB,CAAC;AAErD,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,EAAE,MAG7B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,eAAe,EACvB,WAAW,UAAO,GACjB,kBAAkB,CAKpB"}

package/lib/typescript/theme/platform/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The platform seam. Web's mirror exports these same names over CSS/DOM, which is what lets the
+ * theme provider and every module's styles be copy-pasted between the repos unchanged.
+ *
+ * Imports are `.native`-suffixed on purpose: this package ships native only, so there is no `.ts`
+ * sibling for a bundler to choose between and nothing to resolve implicitly.
+ */
+export { rem, hairline } from './units.native';
+export { elevation } from './elevation.native';
+export type { ElevationStyle } from './elevation.native';
+export { interFontFamilies, systemFontFamily, fontStyleForWeight } from './fonts.native';
+export type { FontWeightValue, FontStyleForWeight } from './fonts.native';
+export { getSystemColorMode, subscribeToSystemColorMode } from './colorScheme.native';
+export type { ColorMode } from './colorScheme.native';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/theme/platform/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/theme/platform/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzF,YAAY,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AACtF,YAAY,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC"}

package/lib/typescript/theme/platform/units.native.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Identity on native: RN lengths are already density-independent pixels.
+ * It exists so theme code copied from web — which calls `rem(space[4])` — compiles unchanged
+ * here, where the web mirror returns `n / 16 + 'rem'`.
+ */
+export declare const rem: (n: number) => number;
+/**
+ * The thinnest crisp line on this device, resolved at runtime from screen density.
+ * This is why `borderWidths` tokens stay plain numbers: a density-dependent value cannot live in
+ * the copy-paste zone, so the token says `1` and a border that wants a hairline reaches for this.
+ */
+export declare const hairline: number;
+//# sourceMappingURL=units.native.d.ts.map

package/lib/typescript/theme/platform/units.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"units.native.d.ts","sourceRoot":"","sources":["../../../../src/theme/platform/units.native.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,KAAG,MAAW,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAiC,CAAC"}

package/lib/typescript/theme/provider/PixelizeProvider.d.ts

@@ -0,0 +1,81 @@
+import type { ReactNode } from 'react';
+import { space, radii, fontSizes, fontWeights, lineHeights, letterSpacings, borderWidths, breakpoints, zIndices } from '../tokens';
+import type { ColorScheme, ElevationLevel, PaletteProps, RoleColors, ThemeName } from '../tokens';
+import type { ElevationStyle, FontStyleForWeight, FontWeightValue } from '../platform';
+import type { ColorModeStorageAdapter, ThemeMode } from './colorModeStorage';
+/**
+ * The fully resolved theme for one (brand, resolvedMode): role colours resolved to plain strings,
+ * the unitless numeric scale, and the platform-rendered pieces a token cannot hold (RN shadow props,
+ * a font-style resolver). This is what `useTheme()` returns; component modules read it, never the
+ * raw palette directly.
+ */
+export type Theme = {
+    brand: ThemeName;
+    /** The resolved mode this theme was built for — never `'system'`. */
+    mode: ColorScheme;
+    /** Semantic role colours as resolved values. The `useThemeColors()` escape hatch returns this. */
+    colors: RoleColors;
+    /** The raw ramps, for the rare consumer that needs a specific rung the roles don't name. */
+    palette: PaletteProps;
+    space: typeof space;
+    radii: typeof radii;
+    fontSizes: typeof fontSizes;
+    fontWeights: typeof fontWeights;
+    lineHeights: typeof lineHeights;
+    letterSpacings: typeof letterSpacings;
+    borderWidths: typeof borderWidths;
+    breakpoints: typeof breakpoints;
+    zIndices: typeof zIndices;
+    /** Elevation levels already rendered to RN shadow props. Mode-independent — shared across themes. */
+    elevation: Record<ElevationLevel, ElevationStyle>;
+    /** A weight → RN text style, bound to whether the app has registered Inter. */
+    fontStyleForWeight: (weight: FontWeightValue) => FontStyleForWeight;
+};
+export type ThemeModeValue = {
+    /** The user's selection: `'light' | 'dark' | 'system'`. */
+    mode: ThemeMode;
+    /** What `system` currently resolves to, tracking the OS live. */
+    resolvedMode: ColorScheme;
+    /** Persists the choice and switches the theme. */
+    setMode: (mode: ThemeMode) => void;
+    /** The active brand. */
+    brand: ThemeName;
+    /** Persists the choice and switches the theme — mirrors `setMode`. */
+    setBrand: (brand: ThemeName) => void;
+};
+export type PixelizeProviderProps = {
+    children: ReactNode;
+    /**
+     * Initial brand. A persisted user choice wins over this. Defaults to `zinc` (the shadcn look).
+     * Read once on mount, like `mode` below — change it afterward via `setBrand` from
+     * `useThemeMode()`, not by re-passing a different prop value.
+     */
+    brand?: ThemeName;
+    /** Initial mode. A persisted user choice wins over this. Defaults to `system`. */
+    mode?: ThemeMode;
+    /** Persistence adapter. Absent → in-memory (choice lost on restart) + a dev warning. */
+    storage?: ColorModeStorageAdapter;
+    storageKey?: string;
+    /** Storage key for the brand choice — separate from `storageKey` (mode) so a plain-string
+     * adapter never has to encode two values into one slot. */
+    brandStorageKey?: string;
+    /**
+     * Whether the app has registered the Inter faces (`useFonts({...})`). Defaults to `false`: without
+     * this the library must use the always-safe system font, since an unregistered face degrades
+     * inconsistently across platforms. Pass `interLoaded={fontsLoaded}` once loading resolves.
+     */
+    interLoaded?: boolean;
+};
+/**
+ * Two contexts, on purpose. `ThemeContext` holds the heavy resolved `Theme`; `ThemeModeContext` holds
+ * the small mode-control triple. Both provider values are memoised on their true inputs, so:
+ *  - a mode flip recomputes the theme exactly ONCE and re-renders each consumer once, and
+ *  - an OS colour change while the mode is pinned (`resolvedMode` unchanged) keeps BOTH values
+ *    reference-stable, so it re-renders nobody.
+ * Splitting also means a `useThemeMode()` reader isn't invalidated by unrelated theme-object churn
+ * and vice versa.
+ */
+export declare const ThemeContext: import("react").Context<Theme | undefined>;
+export declare const ThemeModeContext: import("react").Context<ThemeModeValue | undefined>;
+export declare function PixelizeProvider({ children, brand: brandProp, mode, storage: storageProp, storageKey, brandStorageKey, interLoaded, }: PixelizeProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=PixelizeProvider.d.ts.map