@oxyhq/bloom 0.26.0 → 0.27.0

package/lib/typescript/module/theme/color-space.d.ts

@@ -0,0 +1,28 @@
+export interface Oklch {
+    l: number;
+    c: number;
+    h: number;
+}
+export interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/** OKLCH → linear OKLab → linear sRGB → gamma sRGB → 0..255. Pure. */
+export declare function oklchToSrgb({ l, c, h }: Oklch): Rgb;
+export declare function srgbToRgbString({ r, g, b }: Rgb, alpha?: number): string;
+/**
+ * Parse an `rgb(...)` / `rgba(...)` string into an {@link Rgb}.
+ *
+ * Contract: input MUST be an `rgb(...)` / `rgba(...)` string (e.g. a resolved
+ * token from `getResolvedTokens`). Both modern (`rgb(r g b)`) and legacy
+ * (`rgb(r, g, b)`) syntaxes are accepted. Anything else throws — this is a
+ * canonical-pipeline primitive and a non-rgb input signals a real bug at the
+ * call site, never a value to silently coerce to black.
+ *
+ * @throws {Error} if `s` is not an `rgb()` / `rgba()` string.
+ */
+export declare function parseRgbString(s: string): Rgb;
+/** Cheap perceptual-ish distance in sRGB (sufficient for a ≤1 rounding gate). */
+export declare function deltaE(a: Rgb, b: Rgb): number;
+//# sourceMappingURL=color-space.d.ts.map

package/lib/typescript/module/theme/color-space.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-space.d.ts","sourceRoot":"","sources":["../../../../src/theme/color-space.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,KAAK;IAAG,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE;AAC1D,MAAM,WAAW,GAAG;IAAG,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE;AAMxD,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,GAAG,CAgBnD;AAED,wBAAgB,eAAe,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAIxE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAO7C;AAED,iFAAiF;AACjF,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,CAE7C"}

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

@@ -0,0 +1,18 @@
+export { BloomThemeProvider } from './BloomThemeProvider';
+export type { BloomThemeProviderProps, BloomThemeContextValue, } from './BloomThemeProvider';
+export { BloomColorScope, useColorScopeStyle } from './color-scope';
+export type { BloomColorScopeProps } from './color-scope';
+export { buildTheme, STATUS_COLORS } from './build-theme';
+export { useTheme, useThemeColor, useBloomTheme } from './use-theme';
+export { useNavigationTheme } from './use-navigation-theme';
+export type { NavigationTheme, NavigationThemeFont } from './use-navigation-theme';
+export type { Theme, ThemeColors, ThemeMode } from './types';
+export type { AppColorName, AppColorPreset, PresetTokens } from './color-presets';
+export { APP_COLOR_NAMES, PREMIUM_COLOR_NAMES, APP_COLOR_PRESETS, HEX_TO_APP_COLOR, hexToAppColorName, } from './color-presets';
+export { getPresetVars, applyPresetVarsToDocument } from './preset-vars';
+export { applyDarkClass } from './apply-dark-class';
+export { setColorSchemeSafe } from './set-color-scheme-safe';
+export { initCssInteropDarkMode } from './init-css-interop';
+export type { BloomThemeStorage, PersistedThemeState } from './persistence';
+export { webLocalStorage } from './persistence';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/theme/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,YAAY,EACV,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACpE,YAAY,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,YAAY,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AACnF,YAAY,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAC7D,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAClF,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/lib/typescript/module/theme/init-css-interop.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Idempotent initializer. Safe to call from multiple modules; only the first
+ * invocation performs work.
+ */
+export declare function initCssInteropDarkMode(): void;
+//# sourceMappingURL=init-css-interop.d.ts.map

package/lib/typescript/module/theme/init-css-interop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-css-interop.d.ts","sourceRoot":"","sources":["../../../../src/theme/init-css-interop.ts"],"names":[],"mappings":"AA2GA;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAS7C"}

package/lib/typescript/module/theme/native-root-vars.d.ts

@@ -0,0 +1,33 @@
+import { type AppColorName } from './color-presets';
+/**
+ * Platform-neutral DEFAULT variant of `applyNativeRootVars` — a no-op.
+ *
+ * This is the file resolved by every bundler / type-checker that does NOT do
+ * React Native's platform-extension resolution:
+ *   - a consumer's `tsc` (resolving Bloom's `"react-native"` -> `./src/...` source
+ *     export condition: `theme/index.ts` -> `BloomThemeProvider` -> this import);
+ *   - non-Metro web bundlers (Vite/Rolldown, webpack) resolving the package
+ *     `exports` `import`/`require` conditions to `lib/.../native-root-vars.js`.
+ *
+ * It deliberately does NOT import `react-native-css/native-internal`. That subpath
+ * is native-only. Statically importing it from a file a web bundler resolves breaks
+ * module resolution outright (the original report: `Rolldown failed to resolve
+ * import "react-native-css/native-internal" from .../native-root-vars.js`).
+ * Importing it from a file a consumer's `tsc` resolves breaks type-check (TS2307).
+ *
+ * Confining the real implementation (and that import) to the `.native` sibling —
+ * `native-root-vars.native.ts`, which ONLY Metro selects — keeps both web bundling
+ * AND downstream `tsc` green, while native still publishes the preset vars into
+ * react-native-css's GLOBAL `rootVariables` family so the whole native tree
+ * (navigator screens + portals/modals) resolves the palette.
+ *
+ * The other variants:
+ *   - `native-root-vars.native.ts` — iOS/Android (Metro), the real implementation;
+ *   - `native-root-vars.web.ts` — web, also a no-op (web writes the same vars to
+ *     `document.documentElement` via `applyColorPresetVars` instead).
+ *
+ * The signature is intentionally identical to those variants so the import site in
+ * `BloomThemeProvider` is platform-agnostic.
+ */
+export declare function applyNativeRootVars(_colorPreset: AppColorName, _mode: 'light' | 'dark'): void;
+//# sourceMappingURL=native-root-vars.d.ts.map

package/lib/typescript/module/theme/native-root-vars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-root-vars.d.ts","sourceRoot":"","sources":["../../../../src/theme/native-root-vars.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAG7F"}

package/lib/typescript/module/theme/native-root-vars.native.d.ts

@@ -0,0 +1,104 @@
+import { type AppColorName } from './color-presets';
+/**
+ * Publish the active color preset's CSS custom properties into react-native-css's
+ * GLOBAL root-variable family so they reach the ENTIRE native app tree — including
+ * content rendered outside the React subtree of `BloomThemeProvider`: expo-router
+ * navigator screens, `Portal`s, `Dialog`/`BottomSheet` overlays, and any other host
+ * that paints through a separate React root.
+ *
+ * Why a global write is required (native only)
+ * --------------------------------------------
+ * react-native-css resolves a `var(--x)` reference (its `varResolver`) in this order:
+ *   1. `name in inheritedVariables`  — the React-context-inherited vars. This is what
+ *      `VariableContextProvider` populates, but it is React-context-scoped, so it only
+ *      reaches *direct descendants* of the provider in the React tree.
+ *   2. `inlineVariables[name]`        — same-component inline vars.
+ *   3. `variables[name]`             — resolved inherited vars.
+ *   4. `universalVariables(name)`    — a GLOBAL observable family.
+ *   5. `rootVariables(name)`         — a GLOBAL observable family.
+ *   6. the declared fallback.
+ *
+ * `BloomThemeProvider`'s `VariableContextProvider` only feeds path #1, so the navigator
+ * host and every portal/modal — which render outside that subtree — never see the
+ * preset vars and fall through to `rootVariables`/`universalVariables`. By default those
+ * families hold only react-native-css's own `__rn-css-rem`/`__rn-css-color` entries, so
+ * the whole tree below the navigator renders monochrome until the palette is injected at
+ * runtime. Writing the vars into `rootVariables` here is the exact same mechanism
+ * react-native-css uses for compiled `:root {}` / `@theme` vars (`StyleCollection.inject`
+ * does `rootVariables(name).set(valueArray)`), so portaled content resolves the palette
+ * identically regardless of React-tree position.
+ *
+ * Consumer contract (CRITICAL — single canonical color pipeline)
+ * -------------------------------------------------------------
+ * Each base `--x` token is now written as a FULL `rgb(...)` color (not a raw HSL
+ * triple). A consuming app's Tailwind `@theme` must therefore reference these
+ * base tokens DIRECTLY (its Tailwind color var equals `var(--x)`) and must NOT
+ * wrap them in `hsl(...)`. The legacy `hsl(var(--x))` indirection (which assumed
+ * a raw triple) would produce the invalid `hsl(rgb(...))` and must be removed in
+ * every consumer. Web and native now share this one contract.
+ *
+ * Every token is written as an sRGB `rgb(...)` string from the single canonical
+ * token pipeline (`getResolvedTokens`) — `primary: 'rgb(31 153 239)'` — the SAME
+ * values web writes to `document.documentElement`. sRGB is the space
+ * react-native-css's `color-mix` resolver registers, so `color-mix`-based alpha
+ * utilities (`bg-primary/10`) resolve on native; full (non-alpha) utilities
+ * resolve directly through bloom's `global.css` `var(--x)` indirection.
+ *
+ * Why a STATIC `import`, not a runtime `require` (critical)
+ * ---------------------------------------------------------
+ * react-native-css@3.0.7 ships both a `dist/commonjs` and a `dist/module` build, and
+ * Metro bundles BOTH. In `native-internal/root.js` the variable families are plain
+ * module-local consts — NOT `globalThis`-guarded the way `StyleCollection` is — so the
+ * commonjs `root.js` and the module `root.js` each instantiate their OWN separate
+ * `rootVariables` family. The react-native-css renderer (`react-native-css/src/components/View.tsx`
+ * → `varResolver`) imports its `root.js` via ESM `import`, i.e. the MODULE build. A
+ * runtime `require('react-native-css/native-internal')` resolves the package's `require`
+ * export condition → the COMMONJS build → a DIFFERENT family the renderer never
+ * subscribes to, so the writes are a silent no-op on device. A static top-level
+ * `import` resolves the `import` condition → the MODULE build → the renderer's instance.
+ *
+ * This plain file is the NATIVE/default variant (Metro selects it on iOS/Android,
+ * which have no `.native` override here); the web variant lives in the sibling
+ * `native-root-vars.web.ts` no-op, which web bundlers pick over this one. So the
+ * static `react-native-css/native-internal` import below is never pulled into a web
+ * bundle — only into native. This mirrors Bloom's existing platform-split convention
+ * (`color-scope/index.tsx` + `color-scope/index.web.tsx`, `FontLoader.native.tsx`).
+ *
+ * Keying contract (verified against react-native-css@3.0.7)
+ * ---------------------------------------------------------
+ * The `rootVariables` family is keyed by the BARE variable name, WITHOUT the leading
+ * `--`. The compiler strips it uniformly: a `:root { --primary: ... }` declaration is
+ * stored via `rule.v.push([property.slice(2), value])` then routed into
+ * `shared.rootVariables[name]`, and `@property --x` goes through
+ * `name.startsWith("--") ? name.slice(2) : name`. The lookup side matches: a `var(--x)`
+ * reference compiles to `[{}, "var", ident.slice(2)]`, so `varResolver` looks up the
+ * bare name. `getResolvedTokens` returns keys WITH the `--` prefix, so we strip it
+ * before writing each entry.
+ *
+ * Value shape
+ * -----------
+ * Each entry is a `VariableValue[]` — an array of `[value, mediaCondition?]` tuples.
+ * Bloom's preset vars are unconditional, so each is a single-element `[[value]]`, e.g.
+ * `rootVariables('primary').set([['rgb(31 153 239)']])`. This is the same shape the
+ * compiler emits for unconditional `:root` vars.
+ *
+ * This is native-only and additive: the `VariableContextProvider` wrapper stays (it is
+ * the correct, scoped mechanism for `BloomColorScope` subtree overrides and harmlessly
+ * covers direct descendants). The web fork (`native-root-vars.web.ts`) no-ops — web
+ * writes the same vars to `document.documentElement` via `applyColorPresetVars`.
+ */
+/**
+ * Write the preset's CSS vars to react-native-css's global `rootVariables` family
+ * so the whole native tree (navigator screens + portals/modals/bottom-sheets)
+ * resolves the active palette.
+ *
+ * Each `.set` notifies its own observers synchronously (react-native-css only
+ * batches notifications inside its own `StyleCollection.inject`; outside it,
+ * `observableBatch.current` is unset so every `.set` runs observers immediately),
+ * so sequential writes correctly trigger a re-render when the preset/mode changes.
+ *
+ * Defensive guard: if a host ships a react-native-css build that doesn't expose
+ * `rootVariables` as a callable (it always does on @3), we bail rather than throw.
+ */
+export declare function applyNativeRootVars(colorPreset: AppColorName, mode: 'light' | 'dark'): void;
+//# sourceMappingURL=native-root-vars.native.d.ts.map

package/lib/typescript/module/theme/native-root-vars.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-root-vars.native.d.ts","sourceRoot":"","sources":["../../../../src/theme/native-root-vars.native.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAS3F"}

package/lib/typescript/module/theme/native-root-vars.web.d.ts

@@ -0,0 +1,20 @@
+import { type AppColorName } from './color-presets';
+/**
+ * Web fork of `applyNativeRootVars` — a no-op.
+ *
+ * On web, `BloomThemeProvider` already writes the active preset's CSS vars to
+ * `document.documentElement` via `applyColorPresetVars`, which the browser /
+ * react-native-web resolve natively. The native/default variant — the plain
+ * sibling `native-root-vars.ts` — instead publishes those vars into
+ * react-native-css's GLOBAL `rootVariables` family.
+ *
+ * Keeping the native variant's `react-native-css/native-internal` import out of
+ * the web bundle is the whole reason this is a platform-split module: web (and
+ * any non-NativeWind host) picks this `.web` fork over the plain file and so
+ * never statically pulls react-native-css internals.
+ *
+ * The signature is intentionally identical to the plain variant so the import
+ * site in `BloomThemeProvider` is platform-agnostic.
+ */
+export declare function applyNativeRootVars(_colorPreset: AppColorName, _mode: 'light' | 'dark'): void;
+//# sourceMappingURL=native-root-vars.web.d.ts.map

package/lib/typescript/module/theme/native-root-vars.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-root-vars.web.d.ts","sourceRoot":"","sources":["../../../../src/theme/native-root-vars.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAE7F"}

package/lib/typescript/module/theme/persistence.d.ts

@@ -0,0 +1,50 @@
+import { type AppColorName } from './color-presets';
+import type { ThemeMode } from './types';
+/**
+ * Storage adapter for persisting Bloom theme state.
+ *
+ * Methods may be synchronous or asynchronous. The provider awaits both, so
+ * `AsyncStorage`-compatible adapters on native and `localStorage`-backed
+ * adapters on web both work without consumer-side branching.
+ *
+ * On web, a synchronous adapter lets Bloom hydrate before the first paint —
+ * preventing a flash of the default palette. On native, the provider can
+ * gate `children` rendering until hydration completes (see
+ * `awaitHydration` on `BloomThemeProvider`).
+ */
+export interface BloomThemeStorage {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem?(key: string): void | Promise<void>;
+}
+export interface PersistedThemeState {
+    mode?: ThemeMode;
+    colorPreset?: AppColorName;
+}
+export type SyncReadResult = {
+    kind: 'sync';
+    state: PersistedThemeState | null;
+} | {
+    kind: 'async';
+} | {
+    kind: 'none';
+};
+/**
+ * Read persisted state during the first render. Returns a discriminated union
+ * so the provider can tell apart:
+ *   - `none`: persistence not configured.
+ *   - `sync`: adapter returned a value synchronously (web `localStorage`).
+ *     Provider can render immediately with the resolved state.
+ *   - `async`: adapter returned a Promise (native `AsyncStorage`). Provider
+ *     must await `readPersistedTheme` before painting if gating is enabled.
+ */
+export declare function readPersistedThemeSync(persistKey: string | undefined, storage: BloomThemeStorage | undefined): SyncReadResult;
+export declare function readPersistedTheme(persistKey: string | undefined, storage: BloomThemeStorage | undefined): Promise<PersistedThemeState | null>;
+export declare function writePersistedTheme(persistKey: string | undefined, storage: BloomThemeStorage | undefined, state: PersistedThemeState): Promise<void>;
+export declare function removePersistedTheme(persistKey: string | undefined, storage: BloomThemeStorage | undefined): Promise<void>;
+/**
+ * `localStorage`-backed storage adapter. Only defined on web; on native the
+ * export is `undefined` so consumers pass an `AsyncStorage` adapter explicitly.
+ */
+export declare const webLocalStorage: BloomThemeStorage | undefined;
+//# sourceMappingURL=persistence.d.ts.map

package/lib/typescript/module/theme/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../../../src/theme/persistence.ts"],"names":[],"mappings":"AACA,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAKzC;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC7D,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,UAAU,CAAC,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,WAAW,CAAC,EAAE,YAAY,CAAC;CAC5B;AA4BD,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAKrB;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,iBAAiB,GAAG,SAAS,GACrC,cAAc,CAYhB;AAED,wBAAsB,kBAAkB,CACtC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,iBAAiB,GAAG,SAAS,GACrC,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CASrC;AAED,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,iBAAiB,GAAG,SAAS,EACtC,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,OAAO,EAAE,iBAAiB,GAAG,SAAS,GACrC,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,iBAAiB,GAAG,SA8B9C,CAAC"}

package/lib/typescript/module/theme/preset-vars.d.ts

@@ -0,0 +1,28 @@
+import { type AppColorName, type PresetTokens } from './color-presets';
+/**
+ * Bloom's base preset tokens extended with the surface/card/chart/sidebar
+ * tokens that apps layer on top of the core shadcn palette. Synthesized from
+ * the preset's primary hue so every preset stays in sync automatically.
+ *
+ * This is the single source of truth for extended theming vars — consumer apps
+ * must not redefine these per-app.
+ *
+ * Values are platform-agnostic **raw HSL triples** (`'185 100% 20%'`, optionally
+ * with a `/ A` alpha tail). The single canonical resolver `getResolvedTokens`
+ * (in `token-registry.ts`) converts these to sRGB `rgb(...)` for BOTH web and
+ * native runtime writes — this function only produces the raw triple map.
+ */
+export declare function getPresetVars(colorName: AppColorName, mode: 'light' | 'dark'): PresetTokens;
+/**
+ * Apply a preset's extended vars to `document.documentElement`. Web-only no-op
+ * on native. `BloomThemeProvider` already writes the base preset vars on web;
+ * call this only when an app needs the extended (card/chart/sidebar) tokens on
+ * the document root.
+ *
+ * Tokens are resolved to sRGB `rgb(...)` via the single canonical
+ * `getResolvedTokens` pipeline, so `var(--x)` — the form Tailwind v4
+ * `@theme inline` compiles its color utilities to — resolves directly to a
+ * valid color on web.
+ */
+export declare function applyPresetVarsToDocument(colorName: AppColorName, mode: 'light' | 'dark'): void;
+//# sourceMappingURL=preset-vars.d.ts.map

package/lib/typescript/module/theme/preset-vars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preset-vars.d.ts","sourceRoot":"","sources":["../../../../src/theme/preset-vars.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAe1F;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,YAAY,EACvB,IAAI,EAAE,OAAO,GAAG,MAAM,GACrB,YAAY,CAiCd;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,YAAY,EACvB,IAAI,EAAE,OAAO,GAAG,MAAM,GACrB,IAAI,CAQN"}

package/lib/typescript/module/theme/set-color-scheme-safe.d.ts

@@ -0,0 +1,33 @@
+import type { ThemeMode } from './types';
+/**
+ * Safely set the color scheme via Appearance API.
+ *
+ * Behavior by mode:
+ * - 'light' / 'dark': set the explicit override.
+ * - 'system' / 'adaptive': leave the OS in control. We must NOT call
+ *   Appearance.setColorScheme(resolved) here — doing so installs an
+ *   app-level override that masks the OS preference. Once that override
+ *   is set, useColorScheme() / Appearance.getColorScheme() return the
+ *   frozen override instead of the live OS value, and the app stops
+ *   following dark↔light OS toggles until a cold restart.
+ *
+ *   On iOS we additionally pass 'unspecified' to clear any prior
+ *   override that may have been installed by a previous explicit mode.
+ *   'unspecified' is the documented sentinel that tells the native
+ *   Appearance module to fall back to the OS preference. (RN's JS
+ *   implementation forwards this straight through to the native
+ *   bridge; on iOS this clears the override.)
+ *
+ *   On Android (RN 0.83+) the native Kotlin signature has @NonNull on
+ *   `style` and rejects null, and 'unspecified' is not honored as a
+ *   clear-override sentinel on Android either. As a result, if a user
+ *   previously selected 'light' or 'dark' and then switches back to
+ *   'system' on Android, the override remains until the next cold
+ *   restart. Users who never explicitly overrode are unaffected because
+ *   we never install an override in system mode in the first place.
+ *
+ * On react-native-web, Appearance.setColorScheme is not implemented at
+ * all; the browser controls the color scheme, so we bail out on web.
+ */
+export declare function setColorSchemeSafe(mode: ThemeMode): void;
+//# sourceMappingURL=set-color-scheme-safe.d.ts.map

package/lib/typescript/module/theme/set-color-scheme-safe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-color-scheme-safe.d.ts","sourceRoot":"","sources":["../../../../src/theme/set-color-scheme-safe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,QAkBjD"}

package/lib/typescript/module/theme/token-registry.d.ts

@@ -0,0 +1,53 @@
+import { APP_COLOR_NAMES, type AppColorName } from './color-presets';
+/**
+ * The canonical set of Bloom theme token names — WITHOUT the leading `--`.
+ *
+ * This is the single source of truth for which tokens a preset produces. It
+ * covers exactly the keys returned by `getPresetVars(name, mode)` (the base
+ * shadcn palette plus the synthesized extended tokens: card/chart/content-area/
+ * sidebar-*). The list is intentionally hand-maintained and verified by
+ * `token-registry.test.ts` against the live `getPresetVars('oxy', 'light')`
+ * output, so any drift in the preset shape fails CI.
+ *
+ * Order mirrors `getPresetVars`'s insertion order: base tokens first (in the
+ * order they appear in the preset data), then the synthesized extended tokens.
+ */
+export declare const CANONICAL_TOKENS: readonly ["background", "foreground", "surface", "surface-foreground", "popover", "popover-foreground", "primary", "primary-foreground", "secondary", "secondary-foreground", "muted", "muted-foreground", "accent", "accent-foreground", "destructive", "border", "input", "ring", "sidebar", "card", "card-foreground", "chart-1", "chart-2", "chart-3", "chart-4", "chart-5", "content-area", "sidebar-foreground", "sidebar-primary", "sidebar-primary-foreground", "sidebar-accent", "sidebar-accent-foreground", "sidebar-border", "sidebar-ring"];
+/** A canonical token name (no leading `--`). */
+export type CanonicalToken = (typeof CANONICAL_TOKENS)[number];
+/**
+ * Convert a shadcn-style HSL triple (`'H S% L%'`, optionally with an alpha tail
+ * `'H S% L% / A'`) into an sRGB `rgb(...)` string.
+ *
+ * Standard HSL→sRGB math with integer-rounded channels and modern
+ * space-separated output (`rgb(r g b)` / `rgb(r g b / a)`). This is the SINGLE
+ * conversion the whole library uses — web document writes, web scope vars, and
+ * native `rootVariables` all flow through `getResolvedTokens`, which calls this.
+ * The byte-for-byte output is frozen by the golden parity fixture
+ * (`__fixtures__/golden-resolved-tokens.json`), so the visible palette cannot
+ * drift.
+ *
+ * Task 2's `oklchToSrgb` (in `color-space.ts`) stays available for a FUTURE
+ * OKLCH re-authoring of the seed palette; it is intentionally NOT used here —
+ * routing through OKLCH would shift the rounded channels off the frozen palette.
+ *
+ * Pure function — no side effects.
+ */
+export declare function hslToSrgb(triple: string): string;
+/**
+ * Resolve a preset's canonical runtime color tokens to sRGB `rgb(...)` strings.
+ *
+ * THE single source of runtime color tokens for the whole library, on BOTH web
+ * and native. Takes the raw triple map from `getPresetVars(preset, mode)` (base
+ * + extended) and converts every value that looks like an HSL triple via
+ * `hslToSrgb`. Non-triple values (already-resolved colors, length/radius tokens)
+ * pass through unchanged. Keys retain the `--` prefix, so each `--x` token IS a
+ * full CSS color — no resolved-color companion universe, no per-platform wrapping.
+ *
+ * The result is frozen by the golden parity fixture
+ * (`__fixtures__/golden-resolved-tokens.json`), guaranteeing the visible palette
+ * matches the previous resolved-color pipeline byte-for-byte.
+ */
+export declare function getResolvedTokens(preset: AppColorName, mode: 'light' | 'dark'): Record<string, string>;
+export { APP_COLOR_NAMES };
+//# sourceMappingURL=token-registry.d.ts.map

package/lib/typescript/module/theme/token-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-registry.d.ts","sourceRoot":"","sources":["../../../../src/theme/token-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAGrE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,0hBAmCnB,CAAC;AAEX,gDAAgD;AAChD,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAW/D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA+ChD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,OAAO,GAAG,MAAM,GACrB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAOxB;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/lib/typescript/module/theme/types.d.ts

@@ -0,0 +1,43 @@
+export type ThemeMode = 'light' | 'dark' | 'system' | 'adaptive';
+export interface ThemeColors {
+    background: string;
+    backgroundSecondary: string;
+    backgroundTertiary: string;
+    text: string;
+    textSecondary: string;
+    textTertiary: string;
+    border: string;
+    borderLight: string;
+    primary: string;
+    primaryForeground: string;
+    /** Legacy alias: the page surface tint (`--surface`), NOT a brand accent. */
+    primaryLight: string;
+    /** Legacy alias: the page background (`--background`), NOT the focus ring. */
+    primaryDark: string;
+    /** Legacy alias: mirrors `primary` (`--primary`) for backwards compatibility. */
+    secondary: string;
+    tint: string;
+    icon: string;
+    iconActive: string;
+    success: string;
+    error: string;
+    warning: string;
+    info: string;
+    primarySubtle: string;
+    primarySubtleForeground: string;
+    negative: string;
+    negativeForeground: string;
+    negativeSubtle: string;
+    negativeSubtleForeground: string;
+    contrast50: string;
+    card: string;
+    shadow: string;
+    overlay: string;
+}
+export interface Theme {
+    mode: 'light' | 'dark';
+    colors: ThemeColors;
+    isDark: boolean;
+    isLight: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/module/theme/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/theme/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEjE,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAE3B,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IAErB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IAEpB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAC;IAEpB,iFAAiF;IACjF,SAAS,EAAE,MAAM,CAAC;IAElB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IAEnB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IAEb,aAAa,EAAE,MAAM,CAAC;IACtB,uBAAuB,EAAE,MAAM,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,wBAAwB,EAAE,MAAM,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IAEnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB"}

package/lib/typescript/module/theme/use-isomorphic-layout-effect.d.ts

@@ -0,0 +1,8 @@
+import { useEffect } from 'react';
+/**
+ * `useLayoutEffect` on web (and native — react-native polyfills it) but falls
+ * back to `useEffect` during SSR to avoid the React warning. Bloom apps are
+ * primarily Expo (no SSR), but Next.js consumers of the web bundle need this.
+ */
+export declare const useIsomorphicLayoutEffect: typeof useEffect;
+//# sourceMappingURL=use-isomorphic-layout-effect.d.ts.map

package/lib/typescript/module/theme/use-isomorphic-layout-effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-isomorphic-layout-effect.d.ts","sourceRoot":"","sources":["../../../../src/theme/use-isomorphic-layout-effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAmB,MAAM,OAAO,CAAC;AAGnD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,kBACkD,CAAC"}

package/lib/typescript/module/theme/use-navigation-theme.d.ts

@@ -0,0 +1,31 @@
+export interface NavigationThemeFont {
+    fontFamily: string;
+    fontWeight: '400' | '500' | '700' | '900';
+}
+export interface NavigationTheme {
+    dark: boolean;
+    colors: {
+        primary: string;
+        background: string;
+        card: string;
+        text: string;
+        border: string;
+        notification: string;
+    };
+    fonts: {
+        regular: NavigationThemeFont;
+        medium: NavigationThemeFont;
+        bold: NavigationThemeFont;
+        heavy: NavigationThemeFont;
+    };
+}
+/**
+ * Projects Bloom's resolved theme into a react-navigation `Theme` POJO for
+ * expo-router's <ThemeProvider>. Keeps Bloom the single source of truth for
+ * navigator chrome (Stack headers, screen backgrounds, modal) so it tracks
+ * the active color preset. Returns a structural object — no react-navigation
+ * import — so Bloom stays decoupled. Replaces the per-app copies in
+ * test-app-expo / inbox / accounts.
+ */
+export declare function useNavigationTheme(): NavigationTheme;
+//# sourceMappingURL=use-navigation-theme.d.ts.map

package/lib/typescript/module/theme/use-navigation-theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-navigation-theme.d.ts","sourceRoot":"","sources":["../../../../src/theme/use-navigation-theme.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;CAC3C;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE;QACN,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,KAAK,EAAE;QACL,OAAO,EAAE,mBAAmB,CAAC;QAC7B,MAAM,EAAE,mBAAmB,CAAC;QAC5B,IAAI,EAAE,mBAAmB,CAAC;QAC1B,KAAK,EAAE,mBAAmB,CAAC;KAC5B,CAAC;CACH;AASD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAiBpD"}

package/lib/typescript/module/theme/use-theme.d.ts

@@ -0,0 +1,5 @@
+import type { Theme, ThemeColors } from './types';
+export declare function useTheme(): Theme;
+export declare function useThemeColor(colorKey: keyof ThemeColors): string;
+export declare function useBloomTheme(): import("./BloomThemeProvider").BloomThemeContextValue;
+//# sourceMappingURL=use-theme.d.ts.map

package/lib/typescript/module/theme/use-theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-theme.d.ts","sourceRoot":"","sources":["../../../../src/theme/use-theme.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAElD,wBAAgB,QAAQ,IAAI,KAAK,CAMhC;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,WAAW,GAAG,MAAM,CAGjE;AAED,wBAAgB,aAAa,0DAM5B"}

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

@@ -0,0 +1,23 @@
+import React from 'react';
+import { type GestureResponderEvent } from 'react-native';
+import type { ToastType } from './types';
+export declare function ToastConfigProvider({ children, id, type, }: {
+    children: React.ReactNode;
+    id: string;
+    type: ToastType;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function Outer({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function Icon({ icon }: {
+    icon?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function Text({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function Action({ children, onPress, ...rest }: {
+    children: React.ReactNode;
+    onPress?: (e: GestureResponderEvent) => void;
+    label?: string;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Toast.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Toast.d.ts","sourceRoot":"","sources":["../../../../src/toast/Toast.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA6C,MAAM,OAAO,CAAC;AAClE,OAAO,EAKL,KAAK,qBAAqB,EAC3B,MAAM,cAAc,CAAC;AAMtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAWzC,wBAAgB,mBAAmB,CAAC,EAClC,QAAQ,EACR,EAAE,EACF,IAAI,GACL,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,SAAS,CAAC;CACjB,2CAOA;AAED,wBAAgB,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,2CAiBhE;AAED,wBAAgB,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,kDAgBxD;AAED,wBAAgB,IAAI,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,2CAiB/D;AAED,wBAAgB,MAAM,CAAC,EACrB,QAAQ,EACR,OAAO,EACP,GAAG,IAAI,EACR,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,qBAAqB,KAAK,IAAI,CAAC;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,2CA0CA"}

package/lib/typescript/module/toast/const.d.ts

@@ -0,0 +1,2 @@
+export declare const DURATION = 3000;
+//# sourceMappingURL=const.d.ts.map

package/lib/typescript/module/toast/const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../../src/toast/const.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,OAAM,CAAC"}