pixelize-native-library 1.0.6

package/lib/typescript/modules/checkbox/Checkbox.variants.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Checkbox's style + behaviour resolution — the pure functions the component (and its tests) depend
+ * on, plus the themed structural variant resolvers.
+ *
+ * The split every sibling module copies (see `Button.variants.ts`):
+ *  - STRUCTURE (box size, radius, border WIDTH, row gap) lives in the two `createThemedVariants`
+ *    resolvers below — static per (brand, mode), registered once via `StyleSheet.create`.
+ *  - COLOUR is resolved from the theme's ROLE colours (`resolveCheckboxColors`), never a raw ramp,
+ *    never a hardcoded hex. Unlike Button's `tone`, a checkbox has no per-instance colour choice —
+ *    every state (unchecked / checked / indeterminate) maps to exactly one role pairing, so the
+ *    resolver takes no selector argument.
+ *  - ACCESSIBILITY prop derivation is `resolveCheckboxAccessibility`, kept pure so the
+ *    "indeterminate reports mixed / disabled blocks the toggle" contract is unit-testable without
+ *    rendering React Native.
+ *
+ * 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` and `Button.variants.ts` do).
+ */
+import type { RoleColors, Theme } from "../../theme";
+export type CheckboxSize = "sm" | "md";
+/**
+ * Same touch-target floor as `Button` (44dp, WCAG 2.5.5 AAA). Duplicated rather than imported —
+ * modules never import across `src/modules/*` — so this is the component's own copy.
+ */
+export declare const MIN_TOUCH_TARGET = 44;
+export interface CheckboxSizeSpec {
+    /** Visual box side, in dp. */
+    readonly boxSize: number;
+    /** Check/minus glyph size, in dp. */
+    readonly iconSize: number;
+    /** Label size, on the theme's `fontSizes` scale. */
+    readonly fontSize: number;
+    /** Symmetric touch expansion so `boxSize + 2·hitSlop ≥ 44`. */
+    readonly hitSlop: number;
+}
+/**
+ * Checkbox-specific dimensions. Kept a plain constant — no theme dependency — so the hit-target
+ * test can assert `boxSize + 2·hitSlop ≥ 44` without a provider, same as `BUTTON_SIZES`.
+ */
+export declare const CHECKBOX_SIZES: {
+    readonly sm: {
+        readonly boxSize: 16;
+        readonly iconSize: 12;
+        readonly fontSize: 14;
+        readonly hitSlop: number;
+    };
+    readonly md: {
+        readonly boxSize: 20;
+        readonly iconSize: 14;
+        readonly fontSize: 16;
+        readonly hitSlop: number;
+    };
+};
+export interface CheckboxColors {
+    /** Unchecked box boundary (WCAG 1.4.11 ≥ 3:1 against the canvas, every brand). */
+    readonly border: string;
+    /** Checked/indeterminate box fill — also its own boundary against the canvas (≥ 3:1). */
+    readonly fill: string;
+    /** Check/minus glyph on `fill` — the derived on-colour (≥ 3:1 non-text; measured, never assumed). */
+    readonly icon: string;
+    /** Label text, read on the canvas (≥ 4.5:1). */
+    readonly label: string;
+}
+/**
+ * Maps the checkbox's states onto role colours. There is no `tone`/`color` prop to widen — every
+ * colour a checkbox can show is one of these role lookups, guaranteed legible in both modes and
+ * never an off-palette value an app invented (same reasoning as `resolveButtonTone`, minus the
+ * selector: a checkbox has exactly one accent identity, not a closed union of them).
+ */
+export declare function resolveCheckboxColors(colors: RoleColors): CheckboxColors;
+export interface CheckboxAccessibilityInput {
+    readonly label?: string | undefined;
+    readonly accessibilityLabel?: string | undefined;
+    readonly checked: boolean;
+    readonly indeterminate?: boolean | undefined;
+    readonly disabled?: boolean | undefined;
+}
+export interface CheckboxAccessibilityProps {
+    readonly accessibilityRole: "checkbox";
+    /** Falls back to the visible label; required by the type when there is no visible label. */
+    readonly accessibilityLabel: string | undefined;
+    readonly accessibilityState: {
+        readonly checked: boolean | "mixed";
+        readonly disabled: boolean;
+    };
+    /** The `Pressable` disabled prop — true while disabled, so touches are blocked. */
+    readonly disabled: boolean;
+}
+/**
+ * Derives the accessibility surface once, purely, so the contract is testable without a renderer:
+ *  - `indeterminate` reports `"mixed"` over the literal `checked` value — regardless of `checked` —
+ *    because a screen reader must hear the tri-state, not a stale boolean (matches the visual: the
+ *    "minus" glyph also wins over "check" whenever `indeterminate` is true).
+ *  - `disabled` blocks the toggle (the `Pressable disabled` prop), so `accessibilityState.disabled`
+ *    always matches what actually renders.
+ */
+export declare function resolveCheckboxAccessibility(input: CheckboxAccessibilityInput): CheckboxAccessibilityProps;
+/**
+ * Structural row styles — layout only, no colour. Applied to the outermost `Pressable`, before the
+ * consumer's own `style` (last, once). Fixed regardless of `size`: the box (below) is what scales.
+ */
+export declare const checkboxRowStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/**
+ * Structural box styles — size, radius, border WIDTH. No colours: border/fill colour is
+ * checked-state-driven and applied inline over this, same split as `buttonStructure`. Compiles once
+ * per theme identity via the `WeakMap`-cached themed resolver, never rebuilds per render.
+ */
+export declare const checkboxBoxStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    size: {
+        sm: {
+            width: 16;
+            height: 16;
+        };
+        md: {
+            width: 20;
+            height: 20;
+        };
+    };
+}, import("react-native").ViewStyle>;
+//# sourceMappingURL=Checkbox.variants.d.ts.map

package/lib/typescript/modules/checkbox/Checkbox.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checkbox.variants.d.ts","sourceRoot":"","sources":["../../../../src/modules/checkbox/Checkbox.variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGrD,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,IAAI,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAKnC,MAAM,WAAW,gBAAgB;IAC/B,8BAA8B;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,qCAAqC;IACrC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;CAGgC,CAAC;AAE5D,MAAM,WAAW,cAAc;IAC7B,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,yFAAyF;IACzF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qGAAqG;IACrG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,GAAG,cAAc,CAOxE;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACzC;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,iBAAiB,EAAE,UAAU,CAAC;IACvC,4FAA4F;IAC5F,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;IAChD,QAAQ,CAAC,kBAAkB,EAAE;QAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;QACpC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;KAC5B,CAAC;IACF,mFAAmF;IACnF,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,0BAA0B,GAChC,0BAA0B,CAW5B;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,uKAM9B,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;oCAc9B,CAAC"}

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

@@ -0,0 +1,10 @@
+/**
+ * Public surface of `pixelize-native-library/checkbox`. Value exports and type exports are split for
+ * `verbatimModuleSyntax`. The visual/behaviour resolvers (`resolveCheckboxColors`, `CHECKBOX_SIZES`,
+ * …) stay internal — a consumer configures a Checkbox through its props, never by importing its
+ * internals.
+ */
+export { Checkbox } from "./Checkbox";
+export type { CheckboxProps } from "./Checkbox";
+export type { CheckboxSize } from "./Checkbox.variants";
+//# sourceMappingURL=index.d.ts.map

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

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

package/lib/typescript/modules/divider/Divider.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Divider — a single hairline separator between sections of content. Purely decorative: it carries
+ * no information of its own, so `accessibilityRole="none"` keeps it out of the accessibility tree
+ * (the same "no role" conclusion `Card` documents for its own plain-`View` container — see
+ * `Card.tsx` — made explicit here since, unlike `Card`, a divider has no children to carry meaning).
+ */
+import type { LayoutStyle } from "../../core/style";
+import type { DividerOrientation } from "./Divider.variants";
+export interface DividerProps {
+    orientation?: DividerOrientation;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+declare function DividerImpl({ orientation, style, testID }: DividerProps): import("react").JSX.Element;
+export declare const Divider: import("react").MemoExoticComponent<typeof DividerImpl>;
+export {};
+//# sourceMappingURL=Divider.d.ts.map

package/lib/typescript/modules/divider/Divider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Divider.d.ts","sourceRoot":"","sources":["../../../../src/modules/divider/Divider.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAIpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,8FAA8F;IAC9F,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,iBAAS,WAAW,CAAC,EAAE,WAA0B,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,+BAc/E;AAID,eAAO,MAAM,OAAO,yDAAoB,CAAC"}

package/lib/typescript/modules/divider/Divider.variants.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Divider's style resolution — same split as `Card.variants` / `Button.variants`:
+ *  - STRUCTURE (the hairline's thickness on the cross axis) lives in the themed `dividerStructure`
+ *    resolver, static per (brand, mode), registered once via `StyleSheet.create`.
+ *  - COLOUR is resolved from the theme's ROLE colours by `resolveDividerColor`, never a raw ramp
+ *    and never a hardcoded hex.
+ *
+ * Free of React, so the colour-resolution test imports this directly (mocking only `react-native`'s
+ * `StyleSheet`, as `core/style` and every sibling module's tests do).
+ */
+import type { RoleColors } from "../../theme";
+import type { Theme } from "../../theme";
+export type DividerOrientation = "horizontal" | "vertical";
+/**
+ * Maps the divider onto the theme's role colours. `colors.border.default` — the decorative rung,
+ * deliberately NOT `colors.border.interactive` — is the correct choice here: a divider draws no
+ * interactive boundary and conveys no information of its own (removing it changes spacing, not
+ * meaning), and WCAG 1.4.11 binds only a "User Interface Component" or a "Graphical Object …
+ * required to understand the content" — neither of which a decorative separator is. It measures
+ * ~1.0–1.4:1 against `bg.canvas` on every brand × mode (see `Card.variants.ts`'s identical note for
+ * its own un-bordered variants) — that is the intended subtle shadcn-style rule, not an oversight,
+ * which is why this module's tests assert the mapping rather than gating it at 3:1.
+ */
+export declare function resolveDividerColor(colors: RoleColors): string;
+/**
+ * Structural styles only — the hairline's thickness on the theme's `borderWidths` scale, spanning
+ * the full cross axis. No colour (resolved separately, applied inline over this), so this compiles
+ * once per theme identity via the `WeakMap`-cached themed resolver and never rebuilds per render.
+ */
+export declare const dividerStructure: import("../../core/style").ThemedVariantResolver<Theme, {
+    orientation: {
+        horizontal: {
+            height: 1;
+            width: "100%";
+        };
+        vertical: {
+            width: 1;
+            alignSelf: "stretch";
+        };
+    };
+}, import("react-native").ViewStyle>;
+//# sourceMappingURL=Divider.variants.d.ts.map

package/lib/typescript/modules/divider/Divider.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Divider.variants.d.ts","sourceRoot":"","sources":["../../../../src/modules/divider/Divider.variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGzC,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,UAAU,CAAC;AAE3D;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAE9D;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;oCAQ1B,CAAC"}

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

@@ -0,0 +1,9 @@
+/**
+ * Public surface of `pixelize-native-library/divider`. Value exports and type exports are split for
+ * `verbatimModuleSyntax`. The resolvers (`resolveDividerColor`, `dividerStructure`) stay internal —
+ * a consumer configures a Divider through its props, never by importing its internals.
+ */
+export { Divider } from "./Divider";
+export type { DividerProps } from "./Divider";
+export type { DividerOrientation } from "./Divider.variants";
+//# sourceMappingURL=index.d.ts.map

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

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

package/lib/typescript/modules/drawer/Drawer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Drawer — a bottom-sheet-style panel built directly on REACT NATIVE'S OWN `Modal`, the same
+ * "transient overlay, raw RN Modal" pattern Select already established for this library (never this
+ * library's own `../modal` COMPONENT, a persistent title/children dialog — a different shape). The one
+ * deliberate exception, same as Select's, is the web portal mechanism below — a plain context + a
+ * stateless helper, not the `Modal` component's rendered output.
+ *
+ * The panel slides up from the bottom and the backdrop fades in, both driven by ONE Animated
+ * `progress` value — never RN Modal's native `animationType`, which can only pick a single discrete
+ * transition for the whole native surface and can't keep a custom-Animated backdrop opacity in
+ * lockstep with a custom panel slide. `animationType` is therefore always `"none"` here; this module
+ * owns the whole transition, so it can collapse to an instant snap under reduced motion (WCAG 2.3.3)
+ * without ever showing a frozen half-animated frame.
+ *
+ * Because RN's `<Modal>` only hides its children once native dismissal completes (or the component
+ * unmounts) — the same fact Modal.tsx's own top comment documents — the sheet stays internally
+ * "mounted" for one more animation tick after `visible` goes false, so the exit slide/fade actually
+ * plays before the native Modal disappears. A plain `setTimeout` (not the `Animated.timing`
+ * completion callback, which rides `requestAnimationFrame`) unmounts it afterwards — the same
+ * determinism fix `Toast.tsx`'s `hide()` uses, for the same reason (a RAF callback doesn't resolve on
+ * a predictable jest-fake-timer tick).
+ *
+ * Fully controlled: the caller owns `visible` and reacts to `onRequestClose`, which fires from the
+ * backdrop press, the Android hardware back button (RN Modal's own `onRequestClose` — free), and, via
+ * `onAccessibilityEscape` on the panel, iOS VoiceOver's two-finger-Z escape gesture — identical wiring
+ * to this library's own `Modal`.
+ *
+ * Web portal opt-in: when an ancestor renders `ModalPortalProvider` (web only), this bypasses RN's
+ * `<Modal>` and portals the SAME backdrop+panel tree into the provided container via `renderWebPortal`
+ * instead — see `../modal/ModalPortalContext.ts` for why. `ModalPortalContext`/`renderWebPortal` are
+ * read directly from `../modal` (a plain context + a stateless helper, no footprint of this library's
+ * own `Modal` COMPONENT), the same one deliberate cross-module exception `Select.tsx`'s own top comment
+ * documents. Every other case (native, or web with no provider — the default `ModalPortalContext` value
+ * is `null`) renders through RN's own `<Modal>`, byte-identical to before this mechanism existed.
+ */
+import type { ReactNode } from "react";
+export interface DrawerProps {
+    visible: boolean;
+    onRequestClose: () => void;
+    children: ReactNode;
+    testID?: string;
+}
+export declare const Drawer: import("react").NamedExoticComponent<DrawerProps>;
+//# sourceMappingURL=Drawer.d.ts.map

package/lib/typescript/modules/drawer/Drawer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Drawer.d.ts","sourceRoot":"","sources":["../../../../src/modules/drawer/Drawer.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AA0BvC,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAOD,eAAO,MAAM,MAAM,mDAwGjB,CAAC"}

package/lib/typescript/modules/drawer/Drawer.variants.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Drawer's style + behaviour resolution — same split as Modal/Select:
+ *  - STRUCTURE (padding, radius, the grabber's fixed dimensions) lives in the `createThemedVariants`
+ *    resolvers below, static per (brand, mode), registered once via `StyleSheet.create`.
+ *  - COLOUR is resolved from the theme's ROLE colours by `resolveDrawerPanelColors`, never a raw
+ *    ramp and never a hardcoded hex.
+ *  - The reduced-motion contract (WCAG 2.3.3) is `resolveDrawerAnimationDuration`, and the
+ *    safe-area-less bottom-inset fallback is `resolveDrawerBottomInset` — both kept pure so they are
+ *    unit-testable without rendering React Native.
+ *
+ * Free of React and of any `Modal`/`Pressable`/`Animated` import, so the tests import it directly
+ * (mocking only `react-native`'s `StyleSheet`, as `core/style` does).
+ */
+import type { RoleColors, Theme } from "../../theme";
+/** The slide-up + backdrop-fade duration in ms. A component design constant — not on the theme's
+ *  numeric scale — same status `PRESS_FADE_MS` (Button) / `ANIMATION_MS` (Toast) have. */
+export declare const DRAWER_ANIMATION_MS = 260;
+/** WCAG 2.3.3 — the slide/fade collapses to an instant snap (never a frozen frame) when the OS has
+ *  reduced motion on. Mirrors Modal's `resolveModalAnimationType`, pulled into its own resolver
+ *  because Drawer drives the transition with `Animated.timing` (a duration), not RN Modal's
+ *  `animationType` (a discrete enum) — Modal's own native transition can't also fade a separately
+ *  Animated backdrop in lockstep with a custom slide, which is why this module never sets
+ *  `animationType` to anything but `"none"` and does the whole transition itself. */
+export declare function resolveDrawerAnimationDuration(reducedMotion: boolean): number;
+/**
+ * Static bottom-inset fallback. `react-native-safe-area-context` is listed as an optional peer in
+ * `peerDependenciesMeta`, but — same finding `Toast`'s MODULE.md already recorded — it is not
+ * actually installed as a dependency of THIS package (only pulled in transitively by the `example`
+ * workspace), so importing `useSafeAreaInsets` here would work in this repo's dev sandbox and then
+ * fail to resolve in a consumer app that installs `pixelize-native-library` without also installing that
+ * package. This constant approximates the iOS home-indicator inset instead; see MODULE.md "Known
+ * gaps" for the real fix once the dependency is added for real.
+ */
+export declare const DRAWER_IOS_HOME_INDICATOR_INSET = 20;
+/** Adds the static iOS home-indicator approximation to a base padding; Android's gesture/3-button
+ *  nav already reserves its own space outside the app window, so it needs no extra padding here. */
+export declare function resolveDrawerBottomInset(basePadding: number, platformOS: string): number;
+/** The grabber's fixed pill dimensions — a design constant, not a `size` scale (Drawer takes no
+ *  `size` prop; unlike Modal/Select it has exactly one shape). */
+export declare const GRABBER_WIDTH = 36;
+export declare const GRABBER_HEIGHT = 4;
+export interface DrawerPanelColors {
+    /** Panel fill. */
+    readonly background: string;
+    /** The decorative grabber pill — `accessibilityElementsHidden` in the component, so it carries no
+     *  WCAG 1.4.11 obligation (a purely decorative graphic is out of that SC's scope), same status the
+     *  backdrop scrims across this library (`MODAL_BACKDROP`, `PRESS_SCRIM_DARK/LIGHT`,
+     *  `BACKDROP_SCRIM`) already have. */
+    readonly grabber: string;
+}
+/**
+ * Maps the panel onto role colours. Kept this small on purpose, same reasoning Modal's own
+ * `resolveModalPanelColors` documents: `children` is arbitrary consumer content this module has no
+ * colour opinion about, and Drawer owns no text of its own (no `title`, unlike Modal) — so there is
+ * no text/fill pairing here for a WCAG 1.4.3 test to measure. See `Drawer.test.ts` for the full
+ * accounting of what this module does and does not owe a contrast test.
+ */
+export declare function resolveDrawerPanelColors(colors: RoleColors): DrawerPanelColors;
+/** The full-screen overlay the panel bottom-aligns in. `box-none` (applied by the component) lets a
+ *  tap on its empty area above the panel fall through to the backdrop press underneath — same shape
+ *  as Modal's `modalOverlayStructure` / Select's `selectOverlayStructure`, bottom-aligned instead of
+ *  centered. No theme dependency (no themed numbers used), so it uses the untethemed resolver, same
+ *  idiom `drawerGrabberStructure` below does. */
+export declare const drawerOverlayStructure: import("../../core/style").VariantResolver<import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/**
+ * Structural styles only — layout, padding, top-corner radius. No colour (resolved by
+ * `resolveDrawerPanelColors`, applied inline over this) and no bottom padding (the safe-area-aware
+ * amount is themed but state-dependent on `Platform.OS`, so it's computed by
+ * `resolveDrawerBottomInset` and applied inline in `Drawer.tsx`), so this compiles once per theme
+ * identity via the `WeakMap`-cached themed resolver and never rebuilds per render.
+ */
+export declare const drawerPanelStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** The grabber's touch-friendly wrapper strip — its own row, above `children`, so a future pointer
+ *  down on it can never land on scrollable content underneath (see MODULE.md on why swipe-to-dismiss
+ *  isn't wired to it in v1). */
+export declare const drawerHandleStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+/** No theme dependency at all (fixed design constants, not a themed scale), so it uses the
+ *  untethemed resolver — same idiom as RadioGroup's `radioDotStructure`. */
+export declare const drawerGrabberStructure: import("../../core/style").VariantResolver<import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+//# sourceMappingURL=Drawer.variants.d.ts.map

package/lib/typescript/modules/drawer/Drawer.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Drawer.variants.d.ts","sourceRoot":"","sources":["../../../../src/modules/drawer/Drawer.variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGrD;0FAC0F;AAC1F,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC;;;;;qFAKqF;AACrF,wBAAgB,8BAA8B,CAAC,aAAa,EAAE,OAAO,GAAG,MAAM,CAE7E;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B,KAAK,CAAC;AAElD;oGACoG;AACpG,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAExF;AAED;kEACkE;AAClE,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,MAAM,WAAW,iBAAiB;IAChC,kBAAkB;IAClB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;0CAGsC;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,UAAU,GAAG,iBAAiB,CAK9E;AAED;;;;iDAIiD;AACjD,eAAO,MAAM,sBAAsB,0JAKjC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,uKAS9B,CAAC;AAEJ;;gCAEgC;AAChC,eAAO,MAAM,qBAAqB,uKAM/B,CAAC;AAEJ;4EAC4E;AAC5E,eAAO,MAAM,sBAAsB,0JAMjC,CAAC"}

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

@@ -0,0 +1,8 @@
+/**
+ * Public surface of `pixelize-native-library/drawer`. Value exports and type exports are split for
+ * `verbatimModuleSyntax`. The resolvers (`resolveDrawerPanelColors`, `DRAWER_ANIMATION_MS`, …) stay
+ * internal — a consumer controls a Drawer through its props, never by importing its internals.
+ */
+export { Drawer } from "./Drawer";
+export type { DrawerProps } from "./Drawer";
+//# sourceMappingURL=index.d.ts.map

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

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

package/lib/typescript/modules/empty-state/EmptyState.d.ts

@@ -0,0 +1,29 @@
+/**
+ * EmptyState — a centred placeholder for "nothing here yet" / zero-result states: an optional
+ * decorative icon, a required title, an optional description, and an optional call-to-action.
+ * The action is rendered through this library's own, stable `Button` module — a justified
+ * composition (the same reasoning `AlertDialog` documents for its own footer buttons) — never a
+ * hand-rolled `Pressable` that would duplicate Button's press/focus/disabled/hit-target wiring.
+ *
+ * No `accessibilityRole` of its own: like `Card`, this is a plain grouping container with no
+ * interaction beyond the composed Button, so there is nothing here for assistive tech to announce
+ * beyond its children — the title and description read as their own `Text` elements, in order,
+ * and the icon (redundant with the title) is hidden from the accessibility tree entirely.
+ */
+import type { IconName } from "../../core/icon";
+import type { LayoutStyle } from "../../core/style";
+export interface EmptyStateAction {
+    readonly label: string;
+    readonly onPress: () => void;
+}
+export interface EmptyStateProps {
+    icon?: IconName;
+    title: string;
+    description?: string;
+    action?: EmptyStateAction;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const EmptyState: import("react").NamedExoticComponent<EmptyStateProps>;
+//# sourceMappingURL=EmptyState.d.ts.map

package/lib/typescript/modules/empty-state/EmptyState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmptyState.d.ts","sourceRoot":"","sources":["../../../../src/modules/empty-state/EmptyState.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAMpD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,8FAA8F;IAC9F,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAMD,eAAO,MAAM,UAAU,uDA4CrB,CAAC"}

package/lib/typescript/modules/empty-state/EmptyState.variants.d.ts

@@ -0,0 +1,43 @@
+/**
+ * EmptyState's style resolution — same split as `Card.variants` / `Divider.variants`:
+ *  - STRUCTURE (centring, padding, the vertical rhythm between icon / title / description /
+ *    action) lives in the themed `emptyStateStructure` resolver, static per (brand, mode),
+ *    registered once via `StyleSheet.create`. There is no `variant`/`size`/`tone` to select
+ *    between — one visual identity, same reasoning `Divider`/`Avatar` give for their own single
+ *    identity.
+ *  - COLOUR is resolved from the theme's ROLE colours by `resolveEmptyStateColors`, never a raw
+ *    ramp and never a hardcoded hex.
+ *
+ * Free of React and lucide, so the WCAG test imports this directly (mocking only `react-native`'s
+ * `StyleSheet`, as `core/style` and every sibling module's tests do).
+ */
+import type { RoleColors, Theme } from "../../theme";
+/**
+ * The icon glyph's rendered size, in dp. A component design constant — same status `Button`'s
+ * `ICON_STROKE` / `BUTTON_SIZES.*.iconSize` have — not on the theme's numeric scale: EmptyState
+ * takes no `size` prop, so there is exactly one icon size, deliberately large since it is the
+ * focal point of an otherwise mostly-empty layout.
+ */
+export declare const EMPTY_STATE_ICON_SIZE = 48;
+export interface EmptyStateColors {
+    /** Icon — decorative, muted against the canvas. */
+    readonly icon: string;
+    /** Title — the strongest-emphasis text this component renders. */
+    readonly title: string;
+    /** Description — secondary, muted. */
+    readonly description: string;
+}
+/**
+ * Maps EmptyState onto the theme's role colours. No `tone`/`color` prop to widen — every colour
+ * this component can show is one of these role lookups (same reasoning as `Divider`/`Avatar`), so
+ * it inverts light↔dark for free and can never be an off-palette value an app invented.
+ */
+export declare function resolveEmptyStateColors(colors: RoleColors): EmptyStateColors;
+/**
+ * Structural styles only — centring, padding, and the vertical rhythm between children. No
+ * colours (those are resolved separately and applied inline over this) and no closed union to
+ * select, so this compiles once per theme identity via the `WeakMap`-cached themed resolver and
+ * never rebuilds per render.
+ */
+export declare const emptyStateStructure: import("../../core/style").ThemedVariantResolver<Theme, import("../../core/style").VariantGroups<import("react-native").ViewStyle>, import("react-native").ViewStyle>;
+//# sourceMappingURL=EmptyState.variants.d.ts.map

package/lib/typescript/modules/empty-state/EmptyState.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmptyState.variants.d.ts","sourceRoot":"","sources":["../../../../src/modules/empty-state/EmptyState.variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGrD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC,MAAM,WAAW,gBAAgB;IAC/B,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,UAAU,GAAG,gBAAgB,CAM5E;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,uKAQ7B,CAAC"}

package/lib/typescript/modules/empty-state/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Public surface of `pixelize-native-library/empty-state`. Value exports and type exports are split
+ * for `verbatimModuleSyntax`. The style/colour resolvers (`resolveEmptyStateColors`,
+ * `emptyStateStructure`) stay internal — a consumer configures an EmptyState through its props,
+ * never by importing its internals.
+ */
+export { EmptyState } from "./EmptyState";
+export type { EmptyStateProps, EmptyStateAction } from "./EmptyState";
+export type { IconName } from "../../core/icon";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/modules/empty-state/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/empty-state/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGtE,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}

package/lib/typescript/modules/file-upload/FileUpload.d.ts

@@ -0,0 +1,44 @@
+/**
+ * FileUpload — a trigger `Button` that opens a native picker and reports the picked LOCAL file back
+ * through the controlled `onChange`. No network upload logic lives here: turning the returned `uri`
+ * into a real upload is the consumer's job.
+ *
+ * The first module in this library with a genuine native-picker dependency. `expo-image-picker`/
+ * `expo-document-picker` are optional peers (see package.json) imported PLAIN at the top of
+ * `FileUpload.variants.ts` — the established `core/icon` pattern for an optional-peer native
+ * dependency (no lazy-loading gymnastics): per-component subpath exports already mean this module's
+ * code, and everything it imports, loads only when a consumer imports `pixelize-native-library/file-upload`
+ * at all. Because the import is unconditional, a consumer needs BOTH packages installed even if they
+ * only ever pass `source="document"` in their app — the same tradeoff `core/icon` already makes for
+ * `lucide-react-native` + `react-native-svg` (a Button that renders no icon still requires both).
+ *
+ * Composes the library's own `Button` for BOTH interactive elements (the trigger AND the "remove"
+ * control) rather than hand-rolling a `Pressable` — see MODULE.md "Why this module has no colour
+ * resolver" for why that's a deliberate departure from every sibling module's structure/colour split.
+ */
+import type { LayoutStyle } from "../../core/style";
+import type { FileUploadResult, FileUploadSize, FileUploadSource } from "./FileUpload.variants";
+export interface FileUploadProps {
+    source: FileUploadSource;
+    /** The trigger's visible label, e.g. `"Upload photo"`. Always shown as-is — pressing the trigger
+     *  again while a file is already selected re-opens the picker and replaces it; the label does not
+     *  change to "change" or similar (the "selected file" row below is what communicates state). */
+    label: string;
+    /** Controlled — the currently selected file, or `null`/`undefined` for none. */
+    value?: FileUploadResult | null;
+    /** Fires with the picked file on a successful pick, or `null` when the user clears the selection
+     *  OR a pick attempt fails outright. Does NOT fire on a user cancel (the picker closes with
+     *  nothing chosen) — `value` is left exactly as it was. */
+    onChange: (result: FileUploadResult | null) => void;
+    size?: FileUploadSize;
+    disabled?: boolean;
+    /** Document-only — forwarded as `DocumentPicker.getDocumentAsync`'s `type`. Ignored when `source` is `"image"`. */
+    allowedMimeTypes?: string[];
+    /** Image-only — forwarded as `ImagePicker.launchImageLibraryAsync`'s `allowsEditing`. Ignored when `source` is `"document"`. Defaults to `false`, the default (permission-less) picker flow — see `FileUpload.variants.ts`'s `pickImageFile`. */
+    allowsEditing?: boolean;
+    /** Layout-only, outermost, applied exactly once as the LAST entry in the root style array. */
+    style?: LayoutStyle;
+    testID?: string;
+}
+export declare const FileUpload: import("react").NamedExoticComponent<FileUploadProps>;
+//# sourceMappingURL=FileUpload.d.ts.map

package/lib/typescript/modules/file-upload/FileUpload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileUpload.d.ts","sourceRoot":"","sources":["../../../../src/modules/file-upload/FileUpload.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAapD,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEhG,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,gBAAgB,CAAC;IACzB;;oGAEgG;IAChG,KAAK,EAAE,MAAM,CAAC;IACd,gFAAgF;IAChF,KAAK,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAChC;;+DAE2D;IAC3D,QAAQ,EAAE,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,KAAK,IAAI,CAAC;IACpD,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mHAAmH;IACnH,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,iPAAiP;IACjP,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,8FAA8F;IAC9F,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,UAAU,uDAuHrB,CAAC"}