@oxyhq/bloom 0.26.0 → 0.26.1

package/lib/typescript/module/design-tokens/scales.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Numeric design-token scales for the Oxy Unified Design Language.
+ *
+ * These are platform-agnostic plain numbers / CSS strings consumed by the Bloom
+ * Tailwind preset (`tailwind-preset.ts`). The SAME keys produce the SAME utility
+ * class names on Tailwind (web) and NativeWind (native):
+ *   - spacing  → `p-space-8`, `gap-space-20`, `px-screen-margin`, `m-space-16`
+ *   - radius   → `rounded-radius-20`
+ *   - type     → `font-body` (family/weight) + `text-body` (size/lineHeight)
+ *   - shadow   → `shadow-s`, `shadow-m`
+ *
+ * ADDITIVE: every key is namespaced (`space-*`, `radius-*`, the typography role
+ * names, `shadow-s/m`) and does not collide with Tailwind's built-in numeric
+ * scale (`p-4`, `rounded-lg`, `text-sm`) — those keep working unchanged.
+ */
+/**
+ * Spacing scale (px). Consumed via every Tailwind spacing utility:
+ * `p-space-8`, `px-space-16`, `gap-space-20`, `m-space-24`, `py-space-12`, …
+ *
+ * `screen-margin` is the standard page gutter (left/right inset). Default 20px —
+ * matches Bloom's existing `space.xl` and the `Dialog` default `contentPadding`.
+ */
+export declare const SPACING: {
+    readonly 'space-2': 2;
+    readonly 'space-4': 4;
+    readonly 'space-8': 8;
+    readonly 'space-12': 12;
+    readonly 'space-16': 16;
+    readonly 'space-20': 20;
+    readonly 'space-24': 24;
+    readonly 'space-32': 32;
+    readonly 'screen-margin': 20;
+};
+/**
+ * Corner-radius scale (px). Consumed via `rounded-radius-*`:
+ * `rounded-radius-8`, `rounded-radius-12`, `rounded-radius-20`,
+ * `rounded-radius-28`, `rounded-radius-max` (pill / circle).
+ */
+export declare const RADIUS: {
+    readonly 'radius-8': 8;
+    readonly 'radius-12': 12;
+    readonly 'radius-20': 20;
+    readonly 'radius-28': 28;
+    readonly 'radius-max': 9999;
+};
+/**
+ * Border-width helpers. `border-hairline` is the 0.5px hairline that pairs with
+ * the `border-border-image` color role. (Tailwind's default `border` = 1px
+ * stays untouched.)
+ */
+export declare const BORDER_WIDTH: {
+    readonly hairline: 0.5;
+};
+/**
+ * One typography role. `size`/`lineHeight` are px; `weight` is a CSS font-weight
+ * string; `family` selects the Bloom font CSS var (`sans` = body/UI,
+ * `display` = headings/serif).
+ *
+ * The Tailwind preset splits each role into TWO utilities so a consumer can
+ * apply the size/leading and the family/weight independently or together:
+ *   - `text-<role>`  → `fontSize` + `lineHeight`   (via theme.fontSize)
+ *   - `font-<role>`  → `fontFamily` + `fontWeight` (via theme.fontFamily, which
+ *                       maps a key to a [family, { fontWeight }] tuple)
+ */
+export interface TypeRole {
+    /** Font size in px. */
+    size: number;
+    /** Line height in px. */
+    lineHeight: number;
+    /** CSS font-weight (string for Tailwind/RN parity). */
+    weight: '400' | '500' | '600' | '700';
+    /** Which Bloom font family CSS var to use. */
+    family: 'sans' | 'display';
+}
+/**
+ * The coherent Oxy type scale. Sizes climb 11 → 28; line-heights use a ~1.3–1.5
+ * leading for body roles and tighter leading for large titles.
+ *
+ * | role            | size/line | weight | family  | usage                          |
+ * | --------------- | --------- | ------ | ------- | ------------------------------ |
+ * | caption         | 11 / 14   | 400    | sans    | timestamps, meta, fine print   |
+ * | bodySmall       | 13 / 18   | 400    | sans    | secondary body, captions       |
+ * | bodyTitleSmall  | 13 / 18   | 600    | sans    | small emphasized labels        |
+ * | body            | 15 / 22   | 400    | sans    | default body text              |
+ * | subtitle        | 17 / 24   | 500    | sans    | list subtitles, lead-ins       |
+ * | sectionTitle    | 20 / 26   | 600    | sans    | section headers                |
+ * | headerBold      | 28 / 34   | 700    | display | screen / page titles           |
+ * | buttonLarge     | 17 / 22   | 600    | sans    | primary button label           |
+ */
+export declare const TYPOGRAPHY: {
+    readonly caption: {
+        readonly size: 11;
+        readonly lineHeight: 14;
+        readonly weight: "400";
+        readonly family: "sans";
+    };
+    readonly bodySmall: {
+        readonly size: 13;
+        readonly lineHeight: 18;
+        readonly weight: "400";
+        readonly family: "sans";
+    };
+    readonly bodyTitleSmall: {
+        readonly size: 13;
+        readonly lineHeight: 18;
+        readonly weight: "600";
+        readonly family: "sans";
+    };
+    readonly body: {
+        readonly size: 15;
+        readonly lineHeight: 22;
+        readonly weight: "400";
+        readonly family: "sans";
+    };
+    readonly subtitle: {
+        readonly size: 17;
+        readonly lineHeight: 24;
+        readonly weight: "500";
+        readonly family: "sans";
+    };
+    readonly sectionTitle: {
+        readonly size: 20;
+        readonly lineHeight: 26;
+        readonly weight: "600";
+        readonly family: "sans";
+    };
+    readonly headerBold: {
+        readonly size: 28;
+        readonly lineHeight: 34;
+        readonly weight: "700";
+        readonly family: "display";
+    };
+    readonly buttonLarge: {
+        readonly size: 17;
+        readonly lineHeight: 22;
+        readonly weight: "600";
+        readonly family: "sans";
+    };
+};
+export type TypeRoleName = keyof typeof TYPOGRAPHY;
+/**
+ * Bloom font-family CSS-var stacks, keyed by the `family` field above. Web reads
+ * `var(--bloom-font-*)` (set by `applyFontFaces`); the preset falls back to the
+ * literal stack so utilities still resolve before the vars are injected and on
+ * native (where NativeWind passes the family string straight through).
+ */
+export declare const FONT_FAMILY_VARS: {
+    readonly sans: "var(--bloom-font-sans)";
+    readonly display: "var(--bloom-font-display)";
+    readonly mono: "var(--bloom-font-mono)";
+};
+//# sourceMappingURL=scales.d.ts.map

package/lib/typescript/module/design-tokens/scales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scales.d.ts","sourceRoot":"","sources":["../../../../src/design-tokens/scales.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;CAUV,CAAC;AAMX;;;;GAIG;AACH,eAAO,MAAM,MAAM;;;;;;CAMT,CAAC;AAMX;;;;GAIG;AACH,eAAO,MAAM,YAAY;;CAEf,CAAC;AAMX;;;;;;;;;;GAUG;AACH,MAAM,WAAW,QAAQ;IACvB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,yBAAyB;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;IACtC,8CAA8C;IAC9C,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASsB,CAAC;AAE9C,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,UAAU,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC"}

package/lib/typescript/module/design-tokens/shadows.d.ts

@@ -0,0 +1,34 @@
+import { type ViewStyle } from 'react-native';
+/**
+ * Elevation / shadow tokens for the Oxy Unified Design Language.
+ *
+ * Two roles: `shadow-s` (subtle raise — cards, chips) and `shadow-m` (overlays —
+ * menus, popovers, dialogs). Consumers write ONE class (`shadow-s` / `shadow-m`)
+ * and Bloom owns the platform split:
+ *   - Web: the Bloom Tailwind preset registers `boxShadow.s` / `boxShadow.m`
+ *     (the `SHADOW_BOX` strings below) → `shadow-s` / `shadow-m` utilities.
+ *   - Native: NativeWind cannot translate a multi-layer web `box-shadow` to RN
+ *     elevation reliably, so apps that need the shadow on a React Native surface
+ *     apply the matching style object from `bloomShadowStyle('s' | 'm')` (this
+ *     module is platform-forked: `.native.ts` returns RN `shadow*`/`elevation`).
+ *
+ * This default file is the WEB / consumer-tsc variant. Metro selects the sibling
+ * `shadows.native.ts` on iOS/Android. Web bundlers and a consumer's `tsc` see
+ * this file (the `box-shadow` CSS string path), matching Bloom's existing
+ * `.native`/`.web` split convention.
+ */
+export type ShadowRole = 's' | 'm';
+/**
+ * Web `box-shadow` strings. Subtle, brand-neutral elevation that reads on both
+ * light and dark surfaces. Registered by the Tailwind preset as `boxShadow.s/m`.
+ */
+export declare const SHADOW_BOX: Record<ShadowRole, string>;
+/**
+ * Return the platform-appropriate shadow style for a role.
+ *
+ * On WEB this returns a `{ boxShadow }` style object (so it can also be applied
+ * inline without Tailwind). The `.native.ts` fork returns RN
+ * `shadowColor/shadowOffset/shadowOpacity/shadowRadius/elevation`.
+ */
+export declare function bloomShadowStyle(role: ShadowRole): ViewStyle;
+//# sourceMappingURL=shadows.d.ts.map

package/lib/typescript/module/design-tokens/shadows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadows.d.ts","sourceRoot":"","sources":["../../../../src/design-tokens/shadows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,UAAU,GAAG,GAAG,GAAG,GAAG,CAAC;AAEnC;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAGjD,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CAE5D"}

package/lib/typescript/module/design-tokens/shadows.native.d.ts

@@ -0,0 +1,19 @@
+import { type ViewStyle } from 'react-native';
+/**
+ * NATIVE variant of the shadow tokens (see `shadows.ts` for the rationale and
+ * the web `box-shadow` path). Metro selects this file on iOS/Android.
+ *
+ * The `SHADOW_BOX` map is kept identical to the web file so any code that reads
+ * the raw string (e.g. to feed a NativeWind `boxShadow` utility on a host that
+ * supports it) stays in lockstep; the canonical native styling path is
+ * `bloomShadowStyle`, which returns RN elevation + shadow props tuned to match
+ * the web `shadow-s` / `shadow-m` visual weight.
+ */
+export type ShadowRole = 's' | 'm';
+export declare const SHADOW_BOX: Record<ShadowRole, string>;
+/**
+ * RN shadow/elevation style matching the web `shadow-<role>` weight. Apply to a
+ * React Native `View`/surface: `style={bloomShadowStyle('m')}`.
+ */
+export declare function bloomShadowStyle(role: ShadowRole): ViewStyle;
+//# sourceMappingURL=shadows.native.d.ts.map

package/lib/typescript/module/design-tokens/shadows.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadows.native.d.ts","sourceRoot":"","sources":["../../../../src/design-tokens/shadows.native.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;GASG;AAEH,MAAM,MAAM,UAAU,GAAG,GAAG,GAAG,GAAG,CAAC;AAEnC,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAGjD,CAAC;AAmBF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CAE5D"}

package/lib/typescript/module/design-tokens/tailwind-preset.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The Bloom Tailwind / NativeWind preset — the SINGLE opt-in that gives every
+ * Oxy app the same semantic design-token utility classes.
+ *
+ * Consumers add it to their Tailwind config:
+ *
+ *   // tailwind.config.js  (web Tailwind v3/v4 AND native NativeWind)
+ *   const { bloomTailwindPreset } = require('@oxyhq/bloom/tailwind-preset');
+ *   module.exports = {
+ *     presets: [bloomTailwindPreset],
+ *     content: [ ...existing globs ],
+ *     theme: { extend: { ...existing app overrides } },
+ *   };
+ *
+ * The preset only EXTENDS `theme` (everything lives under `theme.extend`), so it
+ * is purely additive: existing Tailwind built-ins (`p-4`, `rounded-lg`,
+ * `text-sm`) and the app's own `var(--x)`-backed color utilities keep working.
+ *
+ * Cross-platform: NativeWind reads the same `tailwind.config.js`, so the SAME
+ * class names (`bg-fill`, `text-text-tertiary`, `p-space-8`, `rounded-radius-20`,
+ * `text-body`, `font-body`, `shadow-s`) resolve on web (Tailwind → CSS) and
+ * native (NativeWind → react-native-css). Color roles are `var(--x)` references
+ * that Bloom's `BloomThemeProvider` populates at runtime on both platforms.
+ *
+ * Type: returned as a `TailwindPreset` (a structural subset of Tailwind's
+ * `Config`) so Bloom does not need to depend on `tailwindcss` types.
+ */
+/** A Tailwind `fontSize` value: `[size, { lineHeight }]`. */
+type FontSizeValue = [string, {
+    lineHeight: string;
+}];
+/** A Tailwind `fontFamily` value: `[family, { fontWeight }]`. */
+type FontFamilyValue = [string, {
+    fontWeight: string;
+}];
+export interface TailwindPresetThemeExtend {
+    colors: Record<string, string>;
+    backgroundColor: Record<string, string>;
+    textColor: Record<string, string>;
+    borderColor: Record<string, string>;
+    spacing: Record<string, string>;
+    borderRadius: Record<string, string>;
+    borderWidth: Record<string, string>;
+    fontSize: Record<string, FontSizeValue>;
+    fontFamily: Record<string, FontFamilyValue>;
+    boxShadow: Record<string, string>;
+}
+export interface TailwindPreset {
+    theme: {
+        extend: TailwindPresetThemeExtend;
+    };
+}
+/**
+ * The Bloom Tailwind/NativeWind preset. Frozen so accidental mutation by a
+ * consumer's config merge cannot corrupt the shared vocabulary.
+ */
+export declare const bloomTailwindPreset: TailwindPreset;
+export {};
+//# sourceMappingURL=tailwind-preset.d.ts.map

package/lib/typescript/module/design-tokens/tailwind-preset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwind-preset.d.ts","sourceRoot":"","sources":["../../../../src/design-tokens/tailwind-preset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAaH,6DAA6D;AAC7D,KAAK,aAAa,GAAG,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AACtD,iEAAiE;AACjE,KAAK,eAAe,GAAG,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAExD,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC5C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE;QAAE,MAAM,EAAE,yBAAyB,CAAA;KAAE,CAAC;CAC9C;AAuDD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,cAoBhC,CAAC"}

package/lib/typescript/module/design-tokens/theme-css.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Tailwind v4 `@theme` block generator for the Oxy Unified Design Language.
+ *
+ * Tailwind v4 web apps (auth, console, website) configure their design tokens in
+ * CSS via `@theme { --color-X: var(--X); … }` rather than a JS preset. This
+ * module produces the exact `@theme` body that mirrors `bloomTailwindPreset`, so
+ * a v4 app gets the SAME semantic utilities (`bg-fill`, `text-text-tertiary`,
+ * `p-space-8`, `rounded-radius-20`, `text-body`, `font-body`, `shadow-s`) as the
+ * NativeWind/Tailwind-v3 apps that consume the JS preset.
+ *
+ * Each color role is emitted as a `--color-<role>: var(--canonical)` alias.
+ * Per Bloom's web CSS-var contract, the canonical `--x` token already resolves
+ * to a full `rgb(...)` color at runtime, so the alias is a direct `var(--x)`
+ * reference — NEVER `hsl(var(--x))`.
+ *
+ * Usage (web Tailwind v4, in the app's global stylesheet):
+ *
+ *   import { bloomThemeCss } from '@oxyhq/bloom/design-tokens';
+ *   // build-time: write `@theme { ${bloomThemeCss()} }` into global.css, OR
+ *   // paste the generated block once (see docs/design-tokens.md).
+ *
+ * A consumer that prefers a static stylesheet can copy the output of
+ * `bloomThemeCss()` directly into their `@theme { … }` — the values are stable.
+ */
+/**
+ * Produce the BODY of a Tailwind v4 `@theme` block (no surrounding braces) that
+ * registers the full Bloom semantic vocabulary.
+ *
+ * - Colors → `--color-<role>: var(--canonical);`
+ * - Spacing → `--spacing-<key>: <px>;`
+ * - Radius  → `--radius-<key>: <px>;`
+ * - Type    → `--text-<role>: <size>; --text-<role>--line-height: <lh>;`
+ *             `--font-<role>: var(--bloom-font-*);` (+ weight via utility doc)
+ * - Shadow  → `--shadow-<s|m>: <box-shadow>;`
+ */
+export declare function bloomThemeCss(): string;
+/** The full `@theme { … }` block, ready to inject into a v4 stylesheet. */
+export declare function bloomThemeBlock(): string;
+//# sourceMappingURL=theme-css.d.ts.map

package/lib/typescript/module/design-tokens/theme-css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-css.d.ts","sourceRoot":"","sources":["../../../../src/design-tokens/theme-css.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAaH;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,IAAI,MAAM,CA8CtC;AAED,2EAA2E;AAC3E,wBAAgB,eAAe,IAAI,MAAM,CAExC"}

package/lib/typescript/module/dialog/BloomDialogProvider.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+/**
+ * Mounts the imperative `alert()` host inside your app.
+ *
+ * Wrap your app root once (after `BloomThemeProvider`, so the dialog's
+ * colours come from the active theme) and you can call `alert()` from
+ * anywhere — including from code that runs before the provider mounts
+ * (alerts are queued and drained on subscribe).
+ *
+ * ```tsx
+ * import { BloomDialogProvider } from '@oxyhq/bloom';
+ *
+ * <BloomThemeProvider mode="system" colorPreset="oxy">
+ *   <BloomDialogProvider>
+ *     <App />
+ *   </BloomDialogProvider>
+ * </BloomThemeProvider>
+ * ```
+ *
+ * Alerts are presented one at a time. While one is on screen, subsequent
+ * `alert()` calls enqueue and present in FIFO order once their predecessor
+ * has finished closing.
+ */
+export declare function BloomDialogProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=BloomDialogProvider.d.ts.map

package/lib/typescript/module/dialog/BloomDialogProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BloomDialogProvider.d.ts","sourceRoot":"","sources":["../../../../src/dialog/BloomDialogProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAUnD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,2CAgB9E"}

package/lib/typescript/module/dialog/BloomDialogProvider.web.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+/**
+ * Web variant of `BloomDialogProvider`. Identical surface area to the
+ * native version — it just uses the web-fork `Dialog` (`Dialog.web.tsx`)
+ * underneath instead of the bottom-sheet variant.
+ *
+ * See the native file (`./BloomDialogProvider.tsx`) for the full design
+ * notes; this fork exists purely so the bundler's `browser` condition can
+ * resolve to a `Dialog` that doesn't pull in the native gesture-handler /
+ * reanimated stack.
+ */
+export declare function BloomDialogProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=BloomDialogProvider.web.d.ts.map

package/lib/typescript/module/dialog/BloomDialogProvider.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BloomDialogProvider.web.d.ts","sourceRoot":"","sources":["../../../../src/dialog/BloomDialogProvider.web.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAUnD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,2CAa9E"}

package/lib/typescript/module/dialog/Dialog.d.ts

@@ -0,0 +1,40 @@
+import { DIALOG_SHEET_BACKDROP_TESTID } from './placement';
+import type { DialogAction, DialogProps } from './types';
+export { DIALOG_SHEET_BACKDROP_TESTID };
+/**
+ * Native variant of `<Dialog>`.
+ *
+ * Open/close is driven by EITHER the imperative `control` (legacy) OR the
+ * controlled `open` prop. When `open` is provided it wins.
+ *
+ * `placement` selects the surface:
+ *
+ *   - `'center'` (default) / `'bottom'` — bloom's `BottomSheet` (`detached`
+ *     for center: a floating, content-hugging card that degrades from sheet to
+ *     centered card via the 500px cap; flush for bottom: a full-width sheet
+ *     with a drag handle). Default behavior is unchanged.
+ *   - `'left'` / `'right'` — an anchored side-sheet/drawer driven by
+ *     reanimated. Exit animations are safe on native.
+ *
+ * The component accepts three rendering modes simultaneously:
+ *
+ *   1. Declarative — `title`, `description`, `actions`.
+ *   2. Custom children — caller passes JSX, bloom renders the chrome.
+ *   3. Pure children — no `title`/`description`/`actions`.
+ */
+export declare function Dialog({ placement, ...rest }: DialogProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Helper used by the imperative `alert()` API. Mounts a `<Dialog>` against
+ * a fresh control and presents it immediately. `onResolve` is invoked
+ * exactly once when the dialog finishes closing (regardless of how the
+ * dismissal happened).
+ *
+ * Kept private to the dialog module — `alert()` is the public surface.
+ */
+export declare function AutoMountedDialog({ title, description, actions, onResolve, }: {
+    title?: string;
+    description?: string;
+    actions: DialogAction[];
+    onResolve: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Dialog.d.ts.map

package/lib/typescript/module/dialog/Dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dialog.d.ts","sourceRoot":"","sources":["../../../../src/dialog/Dialog.tsx"],"names":[],"mappings":"AAgCA,OAAO,EAIL,4BAA4B,EAK7B,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EACV,YAAY,EAGZ,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,4BAA4B,EAAE,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,EACrB,SAAS,EACT,GAAG,IAAI,EACR,EAAE,WAAW,2CAab;AAqZD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,WAAW,EACX,OAAO,EACP,SAAS,GACV,EAAE;IACD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB,2CAoBA"}

package/lib/typescript/module/dialog/Dialog.web.d.ts

@@ -0,0 +1,55 @@
+import { DIALOG_SHEET_BACKDROP_TESTID } from './placement';
+import type { DialogAction, DialogProps } from './types';
+/**
+ * Web variant of `<Dialog>`.
+ *
+ * A centered modal card (default) rendered into the bloom Portal at the end of
+ * `document.body`, an anchored side-sheet for `left`/`right`, or — for
+ * `bottom` — bloom's cross-platform `BottomSheet` (the SAME component native
+ * uses), so the bottom placement drags-to-dismiss on web too. Same prop API as
+ * native, so call sites are platform agnostic.
+ *
+ * Open/close is driven by EITHER the imperative `control` (legacy) OR the
+ * controlled `open` prop. When `open` is provided it wins.
+ *
+ * Accessibility: the panel has `role="dialog"` and the `title`/`description`
+ * props (when provided) become the `aria-labelledby` / `aria-describedby`
+ * targets. Pressing the backdrop dismisses. Pressing `Escape` dismisses.
+ * Focus is locked inside the dialog while it's open.
+ *
+ * Web motion never uses reanimated `exiting` (which throws `removeChild` on
+ * concurrent React unmounts): the centered card uses CSS keyframes and the
+ * side modes use self-contained CSS transitions on a mounted-through-exit
+ * node. The bottom placement animates via `BottomSheet`'s shared-value/gesture
+ * animation (no `exiting` layout animation).
+ */
+export declare function Dialog({ placement, ...rest }: DialogProps): import("react/jsx-runtime").JSX.Element;
+export { DIALOG_SHEET_BACKDROP_TESTID };
+/**
+ * Inline imperative dialog used by `alert()`. Mounts and immediately
+ * presents; resolves the host's `onResolve` once the dialog has finished
+ * its exit animation.
+ */
+export declare function AutoMountedDialog({ title, description, actions, onResolve, }: {
+    title?: string;
+    description?: string;
+    actions: DialogAction[];
+    onResolve: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * CSS keyframes required for web dialog animations.
+ * Consumers should inject this string into a <style> tag or their global CSS:
+ *
+ * ```css
+ * @keyframes bloomDialogFadeIn { from { opacity: 0; } to { opacity: 1; } }
+ * @keyframes bloomDialogFadeOut { from { opacity: 1; } to { opacity: 0; } }
+ * @keyframes bloomDialogZoomFadeIn { from { opacity: 0; transform: scale(0.95); } to { opacity: 1; transform: scale(1); } }
+ * @keyframes bloomDialogZoomFadeOut { from { opacity: 1; transform: scale(1); } to { opacity: 0; transform: scale(0.95); } }
+ * ```
+ *
+ * The `left`/`right` placements do NOT depend on this — they animate via
+ * self-contained inline CSS transitions and need no keyframe injection. The
+ * `bottom` placement uses bloom's `BottomSheet` (reanimated) and needs none.
+ */
+export declare const BLOOM_DIALOG_CSS = "\n@keyframes bloomDialogFadeIn { from { opacity: 0; } to { opacity: 1; } }\n@keyframes bloomDialogFadeOut { from { opacity: 1; } to { opacity: 0; } }\n@keyframes bloomDialogZoomFadeIn { from { opacity: 0; transform: scale(0.95); } to { opacity: 1; transform: scale(1); } }\n@keyframes bloomDialogZoomFadeOut { from { opacity: 1; transform: scale(1); } to { opacity: 0; transform: scale(0.95); } }\n";
+//# sourceMappingURL=Dialog.web.d.ts.map

package/lib/typescript/module/dialog/Dialog.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dialog.web.d.ts","sourceRoot":"","sources":["../../../../src/dialog/Dialog.web.tsx"],"names":[],"mappings":"AAyBA,OAAO,EAML,4BAA4B,EAM7B,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EACV,YAAY,EAGZ,WAAW,EACZ,MAAM,SAAS,CAAC;AASjB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,WAAW,2CAazD;AAoSD,OAAO,EAAE,4BAA4B,EAAE,CAAC;AAqNxC;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,WAAW,EACX,OAAO,EACP,SAAS,GACV,EAAE;IACD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB,2CAgBA;AA6BD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,mZAK5B,CAAC"}

package/lib/typescript/module/dialog/DialogBottomSheet.d.ts

@@ -0,0 +1,29 @@
+import type { DialogProps } from './types';
+/**
+ * Shared `BottomSheet`-backed surface for the `bottom` placement, used by BOTH
+ * `Dialog.tsx` (native) and `Dialog.web.tsx` (web). `BottomSheet` is itself a
+ * single cross-platform implementation (react-native-gesture-handler +
+ * reanimated, drag-to-dismiss on web and native alike), so routing the bottom
+ * placement through here gives ONE code path with drag working everywhere — no
+ * duplicated CSS slide-up sheet.
+ *
+ * This component owns the entire open↔present/dismiss bridge and the Dialog →
+ * BottomSheet prop mapping in one place:
+ *
+ *   - `open` (controlled) / `control` (imperative) → `present()` / `dismiss()`
+ *   - `onClose`                                     → fired once the sheet settles
+ *   - `maxHeightRatio`                              → sheet `maxHeight`
+ *   - `showHandle` / `dismissOnBackdrop` / `label`  → forwarded to the surface
+ *   - `panelStyle`                                  → paints the sheet surface
+ *   - `containerStyle`                              → wraps the content subtree
+ *     so a host's CSS-var theme scope (`vars()`) still applies to descendants
+ *   - `title` / `description` / `actions` / `children` → declarative body
+ */
+export declare function DialogBottomSheet({ control, open: controlledOpen, onClose, testID, title, description, actions, maxHeightRatio, showHandle, dismissOnBackdrop, contentPadding, style, panelStyle, panelClassName, containerStyle, containerClassName, label, children, }: DialogBottomSheetProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Props the shared bottom-sheet surface consumes — the `bottom`-relevant subset
+ * of `DialogProps`. `width`, `maxWidth`, and `inset` are placement-specific to
+ * the side/centered surfaces and intentionally excluded.
+ */
+export type DialogBottomSheetProps = Pick<DialogProps, 'control' | 'open' | 'onClose' | 'testID' | 'title' | 'description' | 'actions' | 'maxHeightRatio' | 'showHandle' | 'dismissOnBackdrop' | 'contentPadding' | 'style' | 'panelStyle' | 'panelClassName' | 'containerStyle' | 'containerClassName' | 'label' | 'children'>;
+//# sourceMappingURL=DialogBottomSheet.d.ts.map

package/lib/typescript/module/dialog/DialogBottomSheet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DialogBottomSheet.d.ts","sourceRoot":"","sources":["../../../../src/dialog/DialogBottomSheet.tsx"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAsB,WAAW,EAAE,MAAM,SAAS,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,OAAO,EACP,IAAI,EAAE,cAAc,EACpB,OAAO,EACP,MAAM,EACN,KAAK,EACL,WAAW,EACX,OAAO,EACP,cAAyC,EACzC,UAAiB,EACjB,iBAAwB,EACxB,cAA+C,EAC/C,KAAK,EACL,UAAU,EACV,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,KAAK,EACL,QAAQ,GACT,EAAE,sBAAsB,2CAiKxB;AAED;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACvC,WAAW,EACT,SAAS,GACT,MAAM,GACN,SAAS,GACT,QAAQ,GACR,OAAO,GACP,aAAa,GACb,SAAS,GACT,gBAAgB,GAChB,YAAY,GACZ,mBAAmB,GACnB,gBAAgB,GAChB,OAAO,GACP,YAAY,GACZ,gBAAgB,GAChB,gBAAgB,GAChB,oBAAoB,GACpB,OAAO,GACP,UAAU,CACb,CAAC"}

package/lib/typescript/module/dialog/DialogContent.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { ThemeColors } from '../theme/types';
+import type { DialogAction, DialogActionColor } from './types';
+/**
+ * Shared dialog content primitives used by every `<Dialog>` placement on both
+ * platforms — the centered panel, the side-sheets, and the `BottomSheet`-backed
+ * bottom placement. Keeping them here is the single source of truth for the
+ * declarative `title` / `description` / `actions` chrome, so the surfaces never
+ * drift in spacing, typography, or action-button behaviour.
+ */
+/**
+ * Renders the dialog's body: optional declarative title + description, any
+ * `children`, then the action row. The `titleId`/`descriptionId` are wired by
+ * the caller onto the dialog role element for `aria-labelledby` /
+ * `aria-describedby`.
+ */
+export declare function DialogBody({ titleId, descriptionId, title, description, actions, children, }: {
+    titleId: string;
+    descriptionId: string;
+    title?: string;
+    description?: string;
+    actions?: DialogAction[];
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ActionRow({ actions }: {
+    actions: DialogAction[];
+}): import("react/jsx-runtime").JSX.Element;
+export declare function getActionPalette(color: DialogActionColor, colors: ThemeColors): {
+    background: string;
+    foreground: string;
+};
+//# sourceMappingURL=DialogContent.d.ts.map

package/lib/typescript/module/dialog/DialogContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DialogContent.d.ts","sourceRoot":"","sources":["../../../../src/dialog/DialogContent.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsB,MAAM,OAAO,CAAC;AAQ3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGlD,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE/D;;;;;;GAMG;AAEH;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,aAAa,EACb,KAAK,EACL,WAAW,EACX,OAAO,EACP,QAAQ,GACT,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B,2CAmCA;AAED,wBAAgB,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,YAAY,EAAE,CAAA;CAAE,2CAQjE;AAkDD,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,WAAW,GAClB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAiB5C"}

package/lib/typescript/module/dialog/SheetShell.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Internal bottom-sheet shell shared by `Menu`, `Select` and `ContextMenu`.
+ *
+ * Not exported from the public `@oxyhq/bloom` surface — these three
+ * components historically used the low-level `Dialog.Outer / Inner /
+ * Handle` primitives, which are gone in 0.5.0. This shell captures the
+ * shared shape (BottomSheet + drag handle + close-on-tap context) in a
+ * single place so the three internal call sites stay symmetrical.
+ *
+ * Consumers needing the same behaviour for app code should use the public
+ * `BottomSheet` primitive directly.
+ */
+import React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+import type { DialogControlProps } from './types';
+export interface SheetShellProps {
+    control: DialogControlProps;
+    label?: string;
+    header?: React.ReactNode;
+    onClose?: () => void;
+    /** Style overrides applied to the inner padded content container. */
+    contentStyle?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+/**
+ * Bottom-sheet shell with an embedded drag handle. Exposes the bloom
+ * dialog `close()` context to descendants — `MenuItem`, `SelectItem`
+ * etc. rely on it to dismiss the sheet after selection.
+ */
+export declare function SheetShell({ control, label, header, onClose, contentStyle, children, }: SheetShellProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SheetShell.d.ts.map

package/lib/typescript/module/dialog/SheetShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SheetShell.d.ts","sourceRoot":"","sources":["../../../../src/dialog/SheetShell.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAA4D,MAAM,OAAO,CAAC;AACjF,OAAO,EAA+B,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAM3F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,kBAAkB,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,qEAAqE;IACrE,YAAY,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,EACzB,OAAO,EACP,KAAK,EACL,MAAM,EACN,OAAO,EACP,YAAY,EACZ,QAAQ,GACT,EAAE,eAAe,2CAwEjB"}