@kbach/react-native 1.0.0-beta.7 → 1.0.0-beta.9

package/dist/chunk-X4UQCEOE.mjs

@@ -0,0 +1,186 @@
+import {
+  getGlobalDarkMode,
+  getGlobalThemeMode,
+  seedDefaultMode,
+  setGlobalThemeMode,
+  subscribeGlobalDarkMode,
+  toggleGlobalDarkMode
+} from "./chunk-Z664AKW7.mjs";
+import {
+  defaultTheme,
+  getTheme,
+  setTheme
+} from "./chunk-HK6PDJJK.mjs";
+
+// src/config.ts
+function parseHexRgb(hex) {
+  const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return null;
+  let h = m[1];
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  const n = parseInt(h, 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function applyOpacityToHex(hex, opacityText) {
+  const rgb = parseHexRgb(hex);
+  if (!rgb) return hex;
+  const a = Number(opacityText) / 100;
+  const clamped = Number.isFinite(a) ? Math.min(1, Math.max(0, a)) : 1;
+  return `rgba(${rgb.join(",")},${clamped})`;
+}
+function resolveColorEntry(value, lookup) {
+  const slash = value.indexOf("/");
+  const name = slash === -1 ? value : value.slice(0, slash);
+  const opacity = slash === -1 ? void 0 : value.slice(slash + 1);
+  const base = lookup(name);
+  if (base === void 0) return value;
+  return opacity === void 0 ? base : applyOpacityToHex(base, opacity);
+}
+function resolveColors(extend, existing) {
+  const resolved = {};
+  const lookup = (name) => {
+    const found = resolved[name] ?? existing[name];
+    return typeof found === "string" ? found : void 0;
+  };
+  for (const [name, value] of Object.entries(extend)) {
+    resolved[name] = resolveColorEntry(value, lookup);
+  }
+  return resolved;
+}
+function resolveKbachConfig(config) {
+  let theme = { ...defaultTheme, ...config.theme };
+  if (config.extend?.colors) {
+    theme = { ...theme, colors: { ...theme.colors, ...resolveColors(config.extend.colors, theme.colors) } };
+  }
+  if (config.extend?.spacing) {
+    theme = { ...theme, spacing: { ...theme.spacing, ...config.extend.spacing } };
+  }
+  if (config.extend?.screens) {
+    theme = { ...theme, screens: { ...theme.screens, ...config.extend.screens } };
+  }
+  if (config.extend?.fontFamily) {
+    theme = { ...theme, fontFamily: { ...theme.fontFamily, ...config.extend.fontFamily } };
+  }
+  if (config.extend?.container) {
+    theme = { ...theme, container: { ...theme.container, ...config.extend.container } };
+  }
+  if (config.darkMode) {
+    theme = { ...theme, darkMode: config.darkMode };
+  }
+  return theme;
+}
+function applyKbachConfig(config) {
+  const theme = resolveKbachConfig(config);
+  setTheme(theme);
+  return theme;
+}
+
+// src/useTheme.ts
+import { useMemo, useSyncExternalStore } from "react";
+function useTheme() {
+  const isDark = useSyncExternalStore(subscribeGlobalDarkMode, getGlobalDarkMode);
+  const mode = useSyncExternalStore(subscribeGlobalDarkMode, getGlobalThemeMode);
+  return useMemo(
+    () => ({ mode, isDark, setMode: setGlobalThemeMode, toggle: toggleGlobalDarkMode }),
+    [mode, isDark]
+  );
+}
+
+// src/ThemeProvider.tsx
+import { useEffect, useRef } from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+var mountedProviderCount = 0;
+var warnedMultipleProviders = false;
+function ThemeProvider({ children, defaultMode = "system" }) {
+  useEffect(() => {
+    mountedProviderCount++;
+    if (mountedProviderCount > 1 && !warnedMultipleProviders) {
+      warnedMultipleProviders = true;
+      console.warn(
+        "[kbach] Multiple <ThemeProvider> instances are mounted at once. Dark-mode state is one global store useTheme() reads everywhere, not scoped per-provider, so their defaultMode seeds will fight over the same state."
+      );
+    }
+    return () => {
+      mountedProviderCount--;
+    };
+  }, []);
+  const seeded = useRef(false);
+  useEffect(() => {
+    if (seeded.current) return;
+    seeded.current = true;
+    seedDefaultMode(defaultMode);
+  }, []);
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+
+// src/useColors.ts
+function parseHexRgb2(hex) {
+  const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return null;
+  let h = m[1];
+  if (h.length === 3) h = h.split("").map((c) => c + c).join("");
+  const n = parseInt(h, 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function applyOpacity(color, opacity) {
+  const a = Math.max(0, Math.min(1, opacity / 100));
+  if (color.startsWith("#")) {
+    const rgb = parseHexRgb2(color);
+    return rgb ? `rgba(${rgb.join(",")},${a})` : color;
+  }
+  if (color.startsWith("rgb(")) return color.replace("rgb(", "rgba(").replace(")", `,${a})`);
+  if (color.startsWith("rgba(")) return color.replace(/,\s*[\d.]+\)$/, `,${a})`);
+  return color;
+}
+function resolveEntry(entry, isDark) {
+  return typeof entry === "string" ? entry : isDark ? entry.dark : entry.light;
+}
+function makeColorsProxy(theme, isDark) {
+  const alpha = (color, opacity) => opacity === void 0 ? color : applyOpacity(color, opacity);
+  const cache = /* @__PURE__ */ new Map();
+  function resolveNamed(key) {
+    let name = key;
+    let opacity;
+    if (key.includes("/")) {
+      const slash = key.indexOf("/");
+      name = key.slice(0, slash);
+      opacity = Number(key.slice(slash + 1));
+    }
+    const entry = theme.colors[name];
+    if (entry === void 0) return void 0;
+    const value = resolveEntry(entry, isDark);
+    return opacity === void 0 ? value : applyOpacity(value, opacity);
+  }
+  function makeFamilyProxy(family) {
+    return new Proxy({}, {
+      get(_, prop) {
+        const key = String(prop);
+        if (key === "then") return void 0;
+        return resolveNamed(`${family}-${key}`);
+      }
+    });
+  }
+  return new Proxy({ alpha }, {
+    get(_, prop) {
+      const key = String(prop);
+      if (key === "then") return void 0;
+      if (key === "alpha") return alpha;
+      const direct = resolveNamed(key);
+      if (direct !== void 0) return direct;
+      if (!cache.has(key)) cache.set(key, makeFamilyProxy(key));
+      return cache.get(key);
+    }
+  });
+}
+function useColors() {
+  const { isDark } = useTheme();
+  return makeColorsProxy(getTheme(), isDark);
+}
+
+export {
+  resolveKbachConfig,
+  applyKbachConfig,
+  useTheme,
+  ThemeProvider,
+  useColors
+};

package/dist/chunk-YOC3SHF5.mjs

@@ -0,0 +1,40 @@
+import {
+  resolveClassName
+} from "./chunk-H5Z24XX5.mjs";
+
+// src/jsxRuntimeCoreWeb.ts
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment } from "react";
+function makeElement(isStaticChildren, type, props, key) {
+  return (isStaticChildren ? _jsxs : _jsx)(type, props, key);
+}
+function processElement(resolveClassName2, type, rawProps, key, isStaticChildren) {
+  if (type === null || typeof type === "symbol" || !rawProps) {
+    return makeElement(isStaticChildren, type, rawProps ?? {}, key);
+  }
+  const { className: classStrRaw, dataSet: userDataSet, ...rest } = rawProps;
+  if (typeof classStrRaw !== "string") {
+    return makeElement(isStaticChildren, type, rawProps, key);
+  }
+  const resolved = resolveClassName2(classStrRaw);
+  const dataSet = { ...userDataSet, kb: resolved };
+  return makeElement(isStaticChildren, type, { ...rest, dataSet }, key);
+}
+function createJsxFunctionsWeb(resolveClassName2) {
+  function jsx2(type, props, key) {
+    return processElement(resolveClassName2, type, props, key, false);
+  }
+  function jsxs2(type, props, key) {
+    return processElement(resolveClassName2, type, props, key, true);
+  }
+  return { jsx: jsx2, jsxs: jsxs2 };
+}
+
+// src/jsx-runtime.web.tsx
+var { jsx, jsxs } = createJsxFunctionsWeb(resolveClassName);
+
+export {
+  Fragment,
+  jsx,
+  jsxs
+};

package/dist/chunk-Z664AKW7.mjs

@@ -0,0 +1,54 @@
+// src/darkModeStore.ts
+import { Appearance } from "react-native";
+var listeners = /* @__PURE__ */ new Set();
+function systemPrefersDark() {
+  return Appearance.getColorScheme() === "dark";
+}
+function resolveIsDark(m) {
+  return m === "system" ? systemPrefersDark() : m === "dark";
+}
+var mode = "system";
+var isDark = resolveIsDark(mode);
+var hasExplicitChoice = false;
+var subscription = Appearance.addChangeListener(({ colorScheme }) => {
+  if (mode !== "system") return;
+  isDark = colorScheme === "dark";
+  notify();
+});
+function notify() {
+  for (const listener of listeners) listener();
+}
+function getGlobalDarkMode() {
+  return isDark;
+}
+function getGlobalThemeMode() {
+  return mode;
+}
+function setGlobalThemeMode(nextMode) {
+  mode = nextMode;
+  isDark = resolveIsDark(nextMode);
+  hasExplicitChoice = true;
+  notify();
+}
+function toggleGlobalDarkMode() {
+  setGlobalThemeMode(isDark ? "light" : "dark");
+}
+function subscribeGlobalDarkMode(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function seedDefaultMode(fallback) {
+  if (hasExplicitChoice || mode === fallback) return;
+  mode = fallback;
+  isDark = resolveIsDark(fallback);
+  notify();
+}
+
+export {
+  getGlobalDarkMode,
+  getGlobalThemeMode,
+  setGlobalThemeMode,
+  toggleGlobalDarkMode,
+  subscribeGlobalDarkMode,
+  seedDefaultMode
+};

package/dist/index.d.mts

@@ -1,19 +1,12 @@
-import * as react from 'react';
-import { ReactNode } from 'react';
-
-interface ThemeConfig {
-    /** Plain hex only, this pass — e.g. "blue-6" -> "#2563eb" */
-    colors: Record<string, string>;
-    spacing: Record<string, number>;
-    screens: Record<string, number>;
-    darkMode: 'attribute' | 'class' | 'media';
-}
-declare const defaultTheme: ThemeConfig;
-declare function setTheme(theme: ThemeConfig): void;
-declare function getTheme(): ThemeConfig;
+export { C as ColorEntry, a as ColorScale, b as ColorsAPI, c as ContainerConfig, K as KbachConfig, T as ThemeConfig, d as ThemeMode, e as ThemeProvider, f as ThemeProviderProps, g as ThemeState, h as applyKbachConfig, i as defaultTheme, j as getGlobalDarkMode, k as getGlobalThemeMode, l as getTheme, r as resolveKbachConfig, s as setGlobalThemeMode, m as setTheme, n as subscribeGlobalDarkMode, t as toggleGlobalDarkMode, u as useColors, o as useTheme } from './useColors-CeP5_HvM.mjs';
+import 'react';
 
+type StyleValue = string | number | {
+    width: number;
+    height: number;
+};
 interface StyleObject {
-    [key: string]: string | number;
+    [key: string]: StyleValue;
 }
 /**
  * Calls the Rust engine via the KbachModule TurboModule (see
@@ -32,10 +25,9 @@ interface StyleObject {
  * whenever the mode is `'system'` (its own default), so nothing regresses
  * for apps that never touch the override API at all. This function itself
  * has no subscription of its own, so nothing re-renders just because the
- * store's value changed — call `useGlobalDarkMode()` (or consume
- * `useTheme()`'s `isDark`) somewhere in the tree for that, NOT React
- * Native's own `useColorScheme()`, which only reflects the raw OS setting
- * and would miss an explicit override entirely.
+ * store's value changed — call `useTheme()` (its `isDark`) somewhere in
+ * the tree for that, NOT React Native's own `useColorScheme()`, which only
+ * reflects the raw OS setting and would miss an explicit override entirely.
  *
  * Phase 11 originally shipped with live in-place theme switching unverified
  * (a `uiMode` toggle triggered a re-render but `Appearance.getColorScheme()`
@@ -72,90 +64,20 @@ interface StyleObject {
  * re-render anything by itself — call RN's own `useWindowDimensions()`
  * somewhere in the tree for that (same role `useColorScheme()` plays for
  * `dark:` in apps/native-sandbox/App.tsx).
- */
-declare function resolveStyle(classString: string, pressed?: boolean): StyleObject;
-
-/**
- * Native port of @kbach/react's darkModeStore.ts — same architecture (a
- * single module-level store is the real source of truth;
- * ThemeProvider/useTheme are a thin, OPTIONAL wrapper around it; every
- * function here works standalone with no provider mounted anywhere), with
- * two real platform differences from the web version:
  *
- * 1. No persistence. There's no React-Native-builtin equivalent of
- *    localStorage — adding one would mean forcing a real native dependency
- *    (e.g. @react-native-async-storage/async-storage) on every consumer,
- *    even ones that don't want it. The mode always starts at 'system' on a
- *    fresh app launch. If you want persistence, read your own storage at
- *    startup (before your first render) and call setGlobalThemeMode() with
- *    the result — same "seed once, no built-in write-back" shape as
- *    seedDefaultMode() below, just driven by your own storage instead of
- *    one this package picks for you.
- * 2. No DOM to "apply" the resolved mode to. On web, applyToDom() flips a
- *    class/attribute the generated CSS's `dark:` selectors match against.
- *    On native there's no CSS at all — nativeBridge.ts's resolveStyle()
- *    reads getGlobalDarkMode() directly on every call instead of querying
- *    Appearance.getColorScheme() itself, which is what actually makes an
- *    explicit override affect rendering (previously that function always
- *    read the raw OS setting, so it had no way to reflect a user choice —
- *    see nativeBridge.ts's own comment on this for why that's the one
- *    genuinely fixed bug this change introduces, not just a new feature).
- */
-type ThemeMode = 'light' | 'dark' | 'system';
-declare function getGlobalDarkMode(): boolean;
-declare function getGlobalThemeMode(): ThemeMode;
-/** Explicit user choice — takes priority over any later `<ThemeProvider defaultMode>` seed (see `seedDefaultMode` below). Not persisted; see this module's own doc comment. */
-declare function setGlobalThemeMode(nextMode: ThemeMode): void;
-declare function toggleGlobalDarkMode(): void;
-declare function subscribeGlobalDarkMode(listener: () => void): () => void;
-
-/**
- * Reactive read of the global dark-mode store — works with or without a
- * `<ThemeProvider>` mounted anywhere in the tree, since it subscribes to
- * `darkModeStore.ts` directly. No server-snapshot argument (unlike
- * @kbach/react's web version) — React Native has no SSR concept at all,
- * so there's no third argument for `useSyncExternalStore` to need.
+ * Falls back to `./jsEngine` (a pure-JS, no-WASM/no-native reimplementation
+ * of this same resolution logic — see that directory's own doc comments)
+ * when `KbachModule` isn't registered at all — Expo Go, which can never
+ * load ANY custom native module (not even Expo's own Modules API), so the
+ * TurboModule this file otherwise depends on simply doesn't exist there.
+ * `TurboModuleRegistry.get` (not `.getEnforcing`, which throws) is what
+ * makes this detectable at all — `get` returns `null`/`undefined` instead.
+ * A real dev-client/CLI build always has the module registered, so this
+ * fallback only ever activates in Expo Go itself; everywhere else behaves
+ * exactly as before. The JS engine covers a strict subset of what the
+ * native/WASM engines resolve (see jsEngine/resolveUtilityNative.ts) — an
+ * intentional, documented parity gap, not a bug.
  */
-declare function useGlobalDarkMode(): boolean;
-
-interface ThemeProviderProps {
-    children: ReactNode;
-    /**
-     * Applied once, on this provider's first mount, but ONLY if nothing has
-     * made an explicit mode choice yet (see
-     * `darkModeStore.ts::seedDefaultMode`) — an explicit prior choice always
-     * wins over a component's own default. Unlike @kbach/react's web
-     * version, there's no persisted value to check here — see
-     * darkModeStore.ts's own doc comment on why this package doesn't persist
-     * the mode across app launches.
-     */
-    defaultMode?: ThemeMode;
-}
-/**
- * Native port of @kbach/react's `ThemeProvider` — a thin, OPTIONAL React
- * Context wrapper around `darkModeStore.ts`'s single global store, not the
- * source of truth itself. Because the store is global, MULTIPLE mounted
- * providers share the exact same `mode`/`isDark` state rather than each
- * getting their own scoped value — mounting more than one is very likely a
- * mistake (each fighting over the same state via a different
- * `defaultMode`), so this warns once in dev, matching the web version's
- * identical guard.
- */
-declare function ThemeProvider({ children, defaultMode }: ThemeProviderProps): react.JSX.Element;
-
-interface ThemeContextValue {
-    mode: ThemeMode;
-    isDark: boolean;
-    setMode: (mode: ThemeMode) => void;
-    toggle: () => void;
-}
-/**
- * Requires a `<ThemeProvider>` ancestor — throws otherwise, since a
- * component that destructures `{ mode, setMode }` genuinely needs Context
- * (unlike a component that just wants the dark/light boolean, which should
- * reach for `useGlobalDarkMode()` instead and never needs a provider at
- * all).
- */
-declare function useTheme(): ThemeContextValue;
+declare function resolveStyle(classString: string, pressed?: boolean): StyleObject;
 
-export { type StyleObject, type ThemeConfig, type ThemeContextValue, type ThemeMode, ThemeProvider, type ThemeProviderProps, defaultTheme, getGlobalDarkMode, getGlobalThemeMode, getTheme, resolveStyle, setGlobalThemeMode, setTheme, subscribeGlobalDarkMode, toggleGlobalDarkMode, useGlobalDarkMode, useTheme };
+export { type StyleObject, resolveStyle };

package/dist/index.d.ts

@@ -1,19 +1,12 @@
-import * as react from 'react';
-import { ReactNode } from 'react';
-
-interface ThemeConfig {
-    /** Plain hex only, this pass — e.g. "blue-6" -> "#2563eb" */
-    colors: Record<string, string>;
-    spacing: Record<string, number>;
-    screens: Record<string, number>;
-    darkMode: 'attribute' | 'class' | 'media';
-}
-declare const defaultTheme: ThemeConfig;
-declare function setTheme(theme: ThemeConfig): void;
-declare function getTheme(): ThemeConfig;
+export { C as ColorEntry, a as ColorScale, b as ColorsAPI, c as ContainerConfig, K as KbachConfig, T as ThemeConfig, d as ThemeMode, e as ThemeProvider, f as ThemeProviderProps, g as ThemeState, h as applyKbachConfig, i as defaultTheme, j as getGlobalDarkMode, k as getGlobalThemeMode, l as getTheme, r as resolveKbachConfig, s as setGlobalThemeMode, m as setTheme, n as subscribeGlobalDarkMode, t as toggleGlobalDarkMode, u as useColors, o as useTheme } from './useColors-CeP5_HvM.js';
+import 'react';
 
+type StyleValue = string | number | {
+    width: number;
+    height: number;
+};
 interface StyleObject {
-    [key: string]: string | number;
+    [key: string]: StyleValue;
 }
 /**
  * Calls the Rust engine via the KbachModule TurboModule (see
@@ -32,10 +25,9 @@ interface StyleObject {
  * whenever the mode is `'system'` (its own default), so nothing regresses
  * for apps that never touch the override API at all. This function itself
  * has no subscription of its own, so nothing re-renders just because the
- * store's value changed — call `useGlobalDarkMode()` (or consume
- * `useTheme()`'s `isDark`) somewhere in the tree for that, NOT React
- * Native's own `useColorScheme()`, which only reflects the raw OS setting
- * and would miss an explicit override entirely.
+ * store's value changed — call `useTheme()` (its `isDark`) somewhere in
+ * the tree for that, NOT React Native's own `useColorScheme()`, which only
+ * reflects the raw OS setting and would miss an explicit override entirely.
  *
  * Phase 11 originally shipped with live in-place theme switching unverified
  * (a `uiMode` toggle triggered a re-render but `Appearance.getColorScheme()`
@@ -72,90 +64,20 @@ interface StyleObject {
  * re-render anything by itself — call RN's own `useWindowDimensions()`
  * somewhere in the tree for that (same role `useColorScheme()` plays for
  * `dark:` in apps/native-sandbox/App.tsx).
- */
-declare function resolveStyle(classString: string, pressed?: boolean): StyleObject;
-
-/**
- * Native port of @kbach/react's darkModeStore.ts — same architecture (a
- * single module-level store is the real source of truth;
- * ThemeProvider/useTheme are a thin, OPTIONAL wrapper around it; every
- * function here works standalone with no provider mounted anywhere), with
- * two real platform differences from the web version:
  *
- * 1. No persistence. There's no React-Native-builtin equivalent of
- *    localStorage — adding one would mean forcing a real native dependency
- *    (e.g. @react-native-async-storage/async-storage) on every consumer,
- *    even ones that don't want it. The mode always starts at 'system' on a
- *    fresh app launch. If you want persistence, read your own storage at
- *    startup (before your first render) and call setGlobalThemeMode() with
- *    the result — same "seed once, no built-in write-back" shape as
- *    seedDefaultMode() below, just driven by your own storage instead of
- *    one this package picks for you.
- * 2. No DOM to "apply" the resolved mode to. On web, applyToDom() flips a
- *    class/attribute the generated CSS's `dark:` selectors match against.
- *    On native there's no CSS at all — nativeBridge.ts's resolveStyle()
- *    reads getGlobalDarkMode() directly on every call instead of querying
- *    Appearance.getColorScheme() itself, which is what actually makes an
- *    explicit override affect rendering (previously that function always
- *    read the raw OS setting, so it had no way to reflect a user choice —
- *    see nativeBridge.ts's own comment on this for why that's the one
- *    genuinely fixed bug this change introduces, not just a new feature).
- */
-type ThemeMode = 'light' | 'dark' | 'system';
-declare function getGlobalDarkMode(): boolean;
-declare function getGlobalThemeMode(): ThemeMode;
-/** Explicit user choice — takes priority over any later `<ThemeProvider defaultMode>` seed (see `seedDefaultMode` below). Not persisted; see this module's own doc comment. */
-declare function setGlobalThemeMode(nextMode: ThemeMode): void;
-declare function toggleGlobalDarkMode(): void;
-declare function subscribeGlobalDarkMode(listener: () => void): () => void;
-
-/**
- * Reactive read of the global dark-mode store — works with or without a
- * `<ThemeProvider>` mounted anywhere in the tree, since it subscribes to
- * `darkModeStore.ts` directly. No server-snapshot argument (unlike
- * @kbach/react's web version) — React Native has no SSR concept at all,
- * so there's no third argument for `useSyncExternalStore` to need.
+ * Falls back to `./jsEngine` (a pure-JS, no-WASM/no-native reimplementation
+ * of this same resolution logic — see that directory's own doc comments)
+ * when `KbachModule` isn't registered at all — Expo Go, which can never
+ * load ANY custom native module (not even Expo's own Modules API), so the
+ * TurboModule this file otherwise depends on simply doesn't exist there.
+ * `TurboModuleRegistry.get` (not `.getEnforcing`, which throws) is what
+ * makes this detectable at all — `get` returns `null`/`undefined` instead.
+ * A real dev-client/CLI build always has the module registered, so this
+ * fallback only ever activates in Expo Go itself; everywhere else behaves
+ * exactly as before. The JS engine covers a strict subset of what the
+ * native/WASM engines resolve (see jsEngine/resolveUtilityNative.ts) — an
+ * intentional, documented parity gap, not a bug.
  */
-declare function useGlobalDarkMode(): boolean;
-
-interface ThemeProviderProps {
-    children: ReactNode;
-    /**
-     * Applied once, on this provider's first mount, but ONLY if nothing has
-     * made an explicit mode choice yet (see
-     * `darkModeStore.ts::seedDefaultMode`) — an explicit prior choice always
-     * wins over a component's own default. Unlike @kbach/react's web
-     * version, there's no persisted value to check here — see
-     * darkModeStore.ts's own doc comment on why this package doesn't persist
-     * the mode across app launches.
-     */
-    defaultMode?: ThemeMode;
-}
-/**
- * Native port of @kbach/react's `ThemeProvider` — a thin, OPTIONAL React
- * Context wrapper around `darkModeStore.ts`'s single global store, not the
- * source of truth itself. Because the store is global, MULTIPLE mounted
- * providers share the exact same `mode`/`isDark` state rather than each
- * getting their own scoped value — mounting more than one is very likely a
- * mistake (each fighting over the same state via a different
- * `defaultMode`), so this warns once in dev, matching the web version's
- * identical guard.
- */
-declare function ThemeProvider({ children, defaultMode }: ThemeProviderProps): react.JSX.Element;
-
-interface ThemeContextValue {
-    mode: ThemeMode;
-    isDark: boolean;
-    setMode: (mode: ThemeMode) => void;
-    toggle: () => void;
-}
-/**
- * Requires a `<ThemeProvider>` ancestor — throws otherwise, since a
- * component that destructures `{ mode, setMode }` genuinely needs Context
- * (unlike a component that just wants the dark/light boolean, which should
- * reach for `useGlobalDarkMode()` instead and never needs a provider at
- * all).
- */
-declare function useTheme(): ThemeContextValue;
+declare function resolveStyle(classString: string, pressed?: boolean): StyleObject;
 
-export { type StyleObject, type ThemeConfig, type ThemeContextValue, type ThemeMode, ThemeProvider, type ThemeProviderProps, defaultTheme, getGlobalDarkMode, getGlobalThemeMode, getTheme, resolveStyle, setGlobalThemeMode, setTheme, subscribeGlobalDarkMode, toggleGlobalDarkMode, useGlobalDarkMode, useTheme };
+export { type StyleObject, resolveStyle };