everkit-ui 0.1.0

package/dist/commonjs/internal/chipStyle.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveChipColors = resolveChipColors;
+exports.resolveChipSize = resolveChipSize;
+var _hexToRgba = require("./hexToRgba.js");
+/**
+ * Pure prop-resolution for `<Chip/>` — variant + size mapping, unit-testable
+ * without a React renderer.
+ *
+ * GENERIC ONLY. The pilot consumers each layer their own domain variants on top
+ * of this (tea-companion's `'tea-type'`, espresso's diag chips); those read from
+ * per-app palettes (`colors.tea.*`) that the theme-agnostic library does not
+ * own, so they stay per app. Here we ship only the four brand/semantic-routed
+ * variants both apps share:
+ *
+ *   default — neutral pill on `bg.tertiary` with `text.secondary` foreground.
+ *   info    — light wash over `semantic.info` with `semantic.info` foreground.
+ *   success — `brand.primaryLight` bg with `brand.primaryDark` foreground.
+ *   warning — light wash over `semantic.warning` with `semantic.warning` fg.
+ *
+ * Every colour is read from the injected {@link ThemeColors} — no hardcoded hex.
+ * The two washes go through {@link hexToRgba}, lifted verbatim from both apps.
+ *
+ * `isDark` is an optional input that nudges the wash opacity up on dark
+ * backgrounds (the apps pass their `useTheme().isDark`). The library's theme is
+ * brand-agnostic and carries no light/dark signal, so the {@link Chip} component
+ * leaves it at its `false` default; an app that knows its scheme can still call
+ * this helper directly with `isDark`. Sizes are byte-identical in both apps.
+ */
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+function resolveChipSize(size) {
+  switch (size) {
+    case 'sm':
+      return {
+        paddingHorizontal: 8,
+        paddingVertical: 2,
+        textVariant: 'label-sm',
+        iconSize: 12,
+        emojiFontSize: 10,
+        gap: 4
+      };
+    case 'md':
+      return {
+        paddingHorizontal: 12,
+        paddingVertical: 4,
+        textVariant: 'label-md',
+        iconSize: 14,
+        emojiFontSize: 12,
+        gap: 6
+      };
+  }
+}
+function resolveChipColors(variant, options) {
+  const {
+    colors,
+    isDark = false
+  } = options;
+  switch (variant) {
+    case 'default':
+      return {
+        bg: colors.bg.tertiary,
+        fg: colors.text.secondary
+      };
+    case 'success':
+      return {
+        bg: colors.brand.primaryLight,
+        fg: colors.brand.primaryDark
+      };
+    case 'info':
+      return {
+        // Tinted wash over the info colour — kept readable on light and dark.
+        bg: (0, _hexToRgba.hexToRgba)(colors.semantic.info, isDark ? 0.18 : 0.12),
+        fg: colors.semantic.info
+      };
+    case 'warning':
+      return {
+        bg: (0, _hexToRgba.hexToRgba)(colors.semantic.warning, isDark ? 0.18 : 0.15),
+        fg: colors.semantic.warning
+      };
+  }
+}
+//# sourceMappingURL=chipStyle.js.map

package/dist/commonjs/internal/chipStyle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hexToRgba","require","resolveChipSize","size","paddingHorizontal","paddingVertical","textVariant","iconSize","emojiFontSize","gap","resolveChipColors","variant","options","colors","isDark","bg","tertiary","fg","text","secondary","brand","primaryLight","primaryDark","hexToRgba","semantic","info","warning"],"sourceRoot":"../../../src","sources":["internal/chipStyle.ts"],"mappings":";;;;;;;AA0BA,IAAAA,UAAA,GAAAC,OAAA;AA1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAkCA;AACA;AACA;;AAEO,SAASC,eAAeA,CAACC,IAAc,EAAoB;EAChE,QAAQA,IAAI;IACV,KAAK,IAAI;MACP,OAAO;QACLC,iBAAiB,EAAE,CAAC;QACpBC,eAAe,EAAE,CAAC;QAClBC,WAAW,EAAE,UAAU;QACvBC,QAAQ,EAAE,EAAE;QACZC,aAAa,EAAE,EAAE;QACjBC,GAAG,EAAE;MACP,CAAC;IACH,KAAK,IAAI;MACP,OAAO;QACLL,iBAAiB,EAAE,EAAE;QACrBC,eAAe,EAAE,CAAC;QAClBC,WAAW,EAAE,UAAU;QACvBC,QAAQ,EAAE,EAAE;QACZC,aAAa,EAAE,EAAE;QACjBC,GAAG,EAAE;MACP,CAAC;EACL;AACF;AAEO,SAASC,iBAAiBA,CAC/BC,OAAoB,EACpBC,OAAiC,EACb;EACpB,MAAM;IAAEC,MAAM;IAAEC,MAAM,GAAG;EAAM,CAAC,GAAGF,OAAO;EAE1C,QAAQD,OAAO;IACb,KAAK,SAAS;MACZ,OAAO;QAAEI,EAAE,EAAEF,MAAM,CAACE,EAAE,CAACC,QAAQ;QAAEC,EAAE,EAAEJ,MAAM,CAACK,IAAI,CAACC;MAAU,CAAC;IAE9D,KAAK,SAAS;MACZ,OAAO;QAAEJ,EAAE,EAAEF,MAAM,CAACO,KAAK,CAACC,YAAY;QAAEJ,EAAE,EAAEJ,MAAM,CAACO,KAAK,CAACE;MAAY,CAAC;IAExE,KAAK,MAAM;MACT,OAAO;QACL;QACAP,EAAE,EAAE,IAAAQ,oBAAS,EAACV,MAAM,CAACW,QAAQ,CAACC,IAAI,EAAEX,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;QACzDG,EAAE,EAAEJ,MAAM,CAACW,QAAQ,CAACC;MACtB,CAAC;IAEH,KAAK,SAAS;MACZ,OAAO;QACLV,EAAE,EAAE,IAAAQ,oBAAS,EAACV,MAAM,CAACW,QAAQ,CAACE,OAAO,EAAEZ,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;QAC5DG,EAAE,EAAEJ,MAAM,CAACW,QAAQ,CAACE;MACtB,CAAC;EACL;AACF","ignoreList":[]}

package/dist/commonjs/internal/detailScreenState.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveDetailScreenState = resolveDetailScreenState;
+/**
+ * Pure resolver that picks which body `<DetailScreen>` / `<FormScreen>` renders.
+ *
+ * Lifted verbatim from the pilot consumers (espresso-dialin / tea-companion);
+ * byte-identical in both. Pure + theme-free — unit-testable without a renderer.
+ *
+ * The rule:
+ *   1. While the underlying query is loading, render the loading body — even if
+ *      a previous response was an error. A data layer like React Query reports
+ *      both `isLoading: true` and the last `error` during a refetch; showing the
+ *      error state in that window flashes the wrong UI.
+ *   2. If there is an error and we are not loading, render the error body.
+ *   3. Otherwise, render the children.
+ *
+ * The header itself is ALWAYS painted by the scaffold, regardless of the verdict
+ * this helper returns — that is the whole point (the back chevron must not vanish
+ * while a screen's load query is in flight).
+ */
+
+function resolveDetailScreenState(input) {
+  if (input.isLoading) return 'loading';
+  if (input.error != null) return 'error';
+  return 'content';
+}
+//# sourceMappingURL=detailScreenState.js.map

package/dist/commonjs/internal/detailScreenState.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["resolveDetailScreenState","input","isLoading","error"],"sourceRoot":"../../../src","sources":["internal/detailScreenState.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAQO,SAASA,wBAAwBA,CACtCC,KAAoC,EACb;EACvB,IAAIA,KAAK,CAACC,SAAS,EAAE,OAAO,SAAS;EACrC,IAAID,KAAK,CAACE,KAAK,IAAI,IAAI,EAAE,OAAO,OAAO;EACvC,OAAO,SAAS;AAClB","ignoreList":[]}

package/dist/commonjs/internal/haptics.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.triggerLightHaptic = triggerLightHaptic;
+/**
+ * Optional, dependency-light haptic trigger.
+ *
+ * `expo-haptics` is an OPTIONAL peer of everkit-ui — components that offer a
+ * `haptic` affordance (currently {@link AnimatedPressable}) must work whether or
+ * not it is installed. This helper loads it behind a `require` in a `try/catch`
+ * (the same pattern `AppImage` / `EmptyState` use for `expo-linear-gradient`) and
+ * fires a single light "tap" impact, swallowing any error so a missing peer — or
+ * a platform without haptics (web) — is a silent no-op and never crashes a
+ * render.
+ *
+ * The module reference is resolved once and memoised. Pure of theme/colour.
+ */
+
+let expoHaptics;
+function loadHaptics() {
+  if (expoHaptics !== undefined) return expoHaptics;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    expoHaptics = require('expo-haptics');
+  } catch {
+    expoHaptics = null;
+  }
+  return expoHaptics;
+}
+
+/**
+ * Fire a single light "tap" impact if `expo-haptics` is available. Fire-and-
+ * forget — never throws, never returns a promise the caller has to await.
+ */
+function triggerLightHaptic() {
+  const haptics = loadHaptics();
+  if (!haptics?.impactAsync) return;
+  try {
+    const p = haptics.impactAsync(haptics.ImpactFeedbackStyle?.Light);
+    if (p && typeof p.catch === 'function') {
+      ;
+      p.catch(() => {});
+    }
+  } catch {
+    // A failed haptic must never crash a render.
+  }
+}
+//# sourceMappingURL=haptics.js.map

package/dist/commonjs/internal/haptics.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["expoHaptics","loadHaptics","undefined","require","triggerLightHaptic","haptics","impactAsync","p","ImpactFeedbackStyle","Light","catch"],"sourceRoot":"../../../src","sources":["internal/haptics.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAOA,IAAIA,WAA+C;AAEnD,SAASC,WAAWA,CAAA,EAA2B;EAC7C,IAAID,WAAW,KAAKE,SAAS,EAAE,OAAOF,WAAW;EACjD,IAAI;IACF;IACAA,WAAW,GAAGG,OAAO,CAAC,cAAc,CAAoB;EAC1D,CAAC,CAAC,MAAM;IACNH,WAAW,GAAG,IAAI;EACpB;EACA,OAAOA,WAAW;AACpB;;AAEA;AACA;AACA;AACA;AACO,SAASI,kBAAkBA,CAAA,EAAS;EACzC,MAAMC,OAAO,GAAGJ,WAAW,CAAC,CAAC;EAC7B,IAAI,CAACI,OAAO,EAAEC,WAAW,EAAE;EAC3B,IAAI;IACF,MAAMC,CAAC,GAAGF,OAAO,CAACC,WAAW,CAACD,OAAO,CAACG,mBAAmB,EAAEC,KAAK,CAAC;IACjE,IAAIF,CAAC,IAAI,OAAQA,CAAC,CAAmBG,KAAK,KAAK,UAAU,EAAE;MACzD;MAAEH,CAAC,CAAmBG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IACvC;EACF,CAAC,CAAC,MAAM;IACN;EAAA;AAEJ","ignoreList":[]}

package/dist/commonjs/internal/hexToRgba.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hexToRgba = hexToRgba;
+/**
+ * Convert a hex colour (`#RRGGBB`) to an `rgba(...)` string at the given alpha.
+ *
+ * Pure + theme-free — safe to unit-test in node. Lifted verbatim from the pilot
+ * consumers (espresso-dialin / tea-companion), where it was the byte-identical
+ * private helper behind the chip washes. It now lives here as the SINGLE shared
+ * implementation: {@link Chip} (info/warning washes), `ScreenGradient` (the
+ * brand wash overlay), and `EmptyState` (the mascot-circle tint) all derive
+ * their translucent tints from an injected theme colour through this one helper,
+ * so no component carries a literal `rgba(...)` brand value.
+ *
+ * Use `rgba(...)` rather than an 8-digit `#RRGGBBAA` hex on purpose — RN renders
+ * `rgba()` reliably across platforms, while alpha-hex support has historically
+ * been spotty on Android.
+ */
+function hexToRgba(hex, alpha) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+//# sourceMappingURL=hexToRgba.js.map

package/dist/commonjs/internal/hexToRgba.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["hexToRgba","hex","alpha","r","parseInt","slice","g","b"],"sourceRoot":"../../../src","sources":["internal/hexToRgba.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,SAASA,CAACC,GAAW,EAAEC,KAAa,EAAU;EAC5D,MAAMC,CAAC,GAAGC,QAAQ,CAACH,GAAG,CAACI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;EACvC,MAAMC,CAAC,GAAGF,QAAQ,CAACH,GAAG,CAACI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;EACvC,MAAME,CAAC,GAAGH,QAAQ,CAACH,GAAG,CAACI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;EACvC,OAAO,QAAQF,CAAC,KAAKG,CAAC,KAAKC,CAAC,KAAKL,KAAK,GAAG;AAC3C","ignoreList":[]}

package/dist/commonjs/internal/inputStyle.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveInputStyle = resolveInputStyle;
+/**
+ * Pure resolver for the multiline-vs-single-line layout of `<Input>`.
+ *
+ * Lifted verbatim from the pilot consumers (espresso-dialin / tea-companion);
+ * byte-identical in both. Pure + theme-free — it carries layout geometry only.
+ *
+ * Returns inline STYLE objects (not className strings) on purpose: the field
+ * height is what matters most, and NativeWind doesn't reliably apply an
+ * arbitrary `min-h-[100px]` utility — which silently collapses the multiline
+ * field to a single row. A plain `style={{ minHeight: 100 }}` always applies.
+ *
+ * The decision: for a multiline field the min-height + vertical padding live on
+ * the TextInput itself (`field`), so the whole box is the input's native hit
+ * area (tapping below the first line still focuses it) and it renders at full
+ * height. Single-line keeps a fixed 48px container height, vertically centered.
+ */
+
+function resolveInputStyle({
+  multiline
+}) {
+  if (multiline) {
+    return {
+      // No fixed container height — the field's min-height drives it.
+      container: {
+        alignItems: 'flex-start'
+      },
+      field: {
+        minHeight: 100,
+        paddingTop: 12,
+        paddingBottom: 12
+      },
+      textAlignVertical: 'top'
+    };
+  }
+  return {
+    container: {
+      alignItems: 'center',
+      height: 48
+    },
+    field: {
+      paddingVertical: 0
+    },
+    textAlignVertical: 'center'
+  };
+}
+//# sourceMappingURL=inputStyle.js.map

package/dist/commonjs/internal/inputStyle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["resolveInputStyle","multiline","container","alignItems","field","minHeight","paddingTop","paddingBottom","textAlignVertical","height","paddingVertical"],"sourceRoot":"../../../src","sources":["internal/inputStyle.ts"],"mappings":";;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAeO,SAASA,iBAAiBA,CAAC;EAAEC;AAAkC,CAAC,EAAsB;EAC3F,IAAIA,SAAS,EAAE;IACb,OAAO;MACL;MACAC,SAAS,EAAE;QAAEC,UAAU,EAAE;MAAa,CAAC;MACvCC,KAAK,EAAE;QAAEC,SAAS,EAAE,GAAG;QAAEC,UAAU,EAAE,EAAE;QAAEC,aAAa,EAAE;MAAG,CAAC;MAC5DC,iBAAiB,EAAE;IACrB,CAAC;EACH;EACA,OAAO;IACLN,SAAS,EAAE;MAAEC,UAAU,EAAE,QAAQ;MAAEM,MAAM,EAAE;IAAG,CAAC;IAC/CL,KAAK,EAAE;MAAEM,eAAe,EAAE;IAAE,CAAC;IAC7BF,iBAAiB,EAAE;EACrB,CAAC;AACH","ignoreList":[]}

package/dist/commonjs/internal/keyboardAwareProps.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveKeyboardAwareProps = resolveKeyboardAwareProps;
+/**
+ * Pure resolver that decides which props to feed `KeyboardAvoidingView` for
+ * `<KeyboardAware>`.
+ *
+ * Lifted from the pilot consumers (espresso-dialin / tea-companion); this is the
+ * superset form. Pure + theme-free — unit-testable without booting RN.
+ *
+ * The rule:
+ *   - On iOS, `behavior` is always `'padding'`.
+ *   - On every other platform (Android etc.), `behavior` is `undefined` — let
+ *     the OS resize the window. `'padding'` on Android stacks with the system
+ *     adjustment and causes a double-shift.
+ *   - The default style is `{ flex: 1 }`; callers may pass a `style` to override
+ *     (e.g. bottom-sheet hosts that must hug their content rather than flex).
+ *   - `enabled` defaults to `true`; pass `false` to make the avoider a no-op.
+ *
+ * `platform` is a parameter (not read from `Platform.OS` here) so tests can
+ * inject `'ios'` / `'android'` directly.
+ */
+
+function resolveKeyboardAwareProps(input) {
+  const behavior = input.platform === 'ios' ? 'padding' : undefined;
+  return {
+    behavior,
+    style: input.style ?? {
+      flex: 1
+    },
+    keyboardVerticalOffset: input.keyboardVerticalOffset,
+    enabled: input.enabled ?? true
+  };
+}
+//# sourceMappingURL=keyboardAwareProps.js.map

package/dist/commonjs/internal/keyboardAwareProps.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["resolveKeyboardAwareProps","input","behavior","platform","undefined","style","flex","keyboardVerticalOffset","enabled"],"sourceRoot":"../../../src","sources":["internal/keyboardAwareProps.ts"],"mappings":";;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAkBO,SAASA,yBAAyBA,CACvCC,KAAqC,EACT;EAC5B,MAAMC,QAA+C,GACnDD,KAAK,CAACE,QAAQ,KAAK,KAAK,GAAG,SAAS,GAAGC,SAAS;EAElD,OAAO;IACLF,QAAQ;IACRG,KAAK,EAAEJ,KAAK,CAACI,KAAK,IAAI;MAAEC,IAAI,EAAE;IAAE,CAAC;IACjCC,sBAAsB,EAAEN,KAAK,CAACM,sBAAsB;IACpDC,OAAO,EAAEP,KAAK,CAACO,OAAO,IAAI;EAC5B,CAAC;AACH","ignoreList":[]}

package/dist/commonjs/internal/keyboardScrollViewProps.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KEYBOARD_INPUT_GAP = void 0;
+exports.resolveKeyboardGapScrollTarget = resolveKeyboardGapScrollTarget;
+exports.resolveKeyboardScrollViewProps = resolveKeyboardScrollViewProps;
+/**
+ * Pure resolvers for `<KeyboardScrollView>`.
+ *
+ * Lifted from the pilot consumers (espresso-dialin / tea-companion); this is the
+ * superset form (tea-companion's, which additionally carries the iOS
+ * keyboard-gap fix). Pure + theme-free — unit-testable without booting RN.
+ *
+ * What {@link resolveKeyboardScrollViewProps} encodes — the HARD contract of the
+ * component (these two scroll-view knobs are NOT exposed on the public API):
+ *
+ *  1. `keyboardShouldPersistTaps` is ALWAYS `'always'`. Under React Native's New
+ *     Architecture, `'handled'` swallows the FIRST tap on a `<TextInput>` — the
+ *     user has to tap twice before the keyboard opens. `'always'` lets the first
+ *     tap reach the input.
+ *  2. `keyboardDismissMode` is ALWAYS `'interactive'`. iOS users drag the scroll
+ *     body down through the top of the keyboard and it rides the gesture
+ *     off-screen (the iMessage / WhatsApp pattern). Normal upward scroll does
+ *     NOT dismiss. On Android, `'interactive'` falls back to `'none'`.
+ *  3. `enableKeyboardAvoidance` defaults to `true`; only nested screens already
+ *     inside a `<KeyboardAware>` pass `false` to avoid a double-shift.
+ */
+
+function resolveKeyboardScrollViewProps(input = {}) {
+  return {
+    enableKeyboardAvoidance: input.enableKeyboardAvoidance ?? true,
+    keyboardShouldPersistTaps: 'always',
+    keyboardDismissMode: 'interactive'
+  };
+}
+
+/**
+ * Guaranteed breathing space (points) between the bottom edge of the focused
+ * input and the top of the keyboard frame (which includes the iOS QuickType
+ * suggestion bar).
+ *
+ * Why this exists — iOS `automaticallyAdjustKeyboardInsets` leaves the focused
+ * input FLUSH against the keyboard: the native code scrolls so the focus rect's
+ * bottom lands exactly at the keyboard top (zero margin), and for MULTILINE
+ * inputs the focus rect is the caret line, so the input's own bottom
+ * padding/border sits underneath the QuickType bar. A static `contentInset`
+ * cannot fix it (the native code applies `MAX(keyboardInset, contentInset)` — it
+ * replaces, never adds). So `<KeyboardScrollView>` measures the focused input
+ * after the keyboard settles and nudges the scroll position until this gap holds.
+ * 12pt — visibly clear of the QuickType bar without the nudge feeling like a jump.
+ */
+const KEYBOARD_INPUT_GAP = exports.KEYBOARD_INPUT_GAP = 12;
+/**
+ * Returns the scroll offset that restores the gap between the focused input and
+ * the keyboard, or `null` when the gap already holds (never scrolls content
+ * DOWN — an input sitting well above the keyboard stays put).
+ */
+function resolveKeyboardGapScrollTarget(input) {
+  const gap = input.gap ?? KEYBOARD_INPUT_GAP;
+  const overlap = input.inputBottomY + gap - input.keyboardTopY;
+  if (overlap <= 0) return null;
+  return input.currentScrollY + overlap;
+}
+//# sourceMappingURL=keyboardScrollViewProps.js.map

package/dist/commonjs/internal/keyboardScrollViewProps.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["resolveKeyboardScrollViewProps","input","enableKeyboardAvoidance","keyboardShouldPersistTaps","keyboardDismissMode","KEYBOARD_INPUT_GAP","exports","resolveKeyboardGapScrollTarget","gap","overlap","inputBottomY","keyboardTopY","currentScrollY"],"sourceRoot":"../../../src","sources":["internal/keyboardScrollViewProps.ts"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAeO,SAASA,8BAA8BA,CAC5CC,KAA0C,GAAG,CAAC,CAAC,EACd;EACjC,OAAO;IACLC,uBAAuB,EAAED,KAAK,CAACC,uBAAuB,IAAI,IAAI;IAC9DC,yBAAyB,EAAE,QAAQ;IACnCC,mBAAmB,EAAE;EACvB,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,GAAG,EAAE;AAapC;AACA;AACA;AACA;AACA;AACO,SAASE,8BAA8BA,CAC5CN,KAA0C,EAC3B;EACf,MAAMO,GAAG,GAAGP,KAAK,CAACO,GAAG,IAAIH,kBAAkB;EAC3C,MAAMI,OAAO,GAAGR,KAAK,CAACS,YAAY,GAAGF,GAAG,GAAGP,KAAK,CAACU,YAAY;EAC7D,IAAIF,OAAO,IAAI,CAAC,EAAE,OAAO,IAAI;EAC7B,OAAOR,KAAK,CAACW,cAAc,GAAGH,OAAO;AACvC","ignoreList":[]}

package/dist/commonjs/internal/overlay.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SCRIM_ALPHA = void 0;
+exports.scrimColor = scrimColor;
+var _hexToRgba = require("./hexToRgba.js");
+/**
+ * Theme-derived modal scrim colour.
+ *
+ * A speed-dial / sheet backdrop is a neutral darkening layer rather than a brand
+ * surface, so it cannot read a single brand token. The pilot consumers hardcoded
+ * a literal `'rgba(0,0,0,0.4)'`; here we DERIVE it from the theme's darkest ink
+ * (`colors.text.primary`) through {@link hexToRgba}, so the library carries no
+ * literal `rgba(...)` value and the scrim still tracks any injected palette
+ * (a near-black ink on light themes, the light ink on dark themes — both read as
+ * a dimming wash over the content behind the menu).
+ *
+ * Pure + theme-free at the call boundary (takes a hex string, returns a string),
+ * so it is unit-testable in node like its neighbours.
+ */
+
+/** Default backdrop opacity — matches the pilot consumers' `0.4` scrim. */
+const SCRIM_ALPHA = exports.SCRIM_ALPHA = 0.4;
+
+/**
+ * Build the speed-dial / modal scrim colour from a theme ink hex.
+ *
+ * @param inkHex   A `#RRGGBB` colour — pass `colors.text.primary`.
+ * @param alpha    Opacity, defaults to {@link SCRIM_ALPHA}.
+ */
+function scrimColor(inkHex, alpha = SCRIM_ALPHA) {
+  return (0, _hexToRgba.hexToRgba)(inkHex, alpha);
+}
+//# sourceMappingURL=overlay.js.map

package/dist/commonjs/internal/overlay.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_hexToRgba","require","SCRIM_ALPHA","exports","scrimColor","inkHex","alpha","hexToRgba"],"sourceRoot":"../../../src","sources":["internal/overlay.ts"],"mappings":";;;;;;;AAeA,IAAAA,UAAA,GAAAC,OAAA;AAfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA;AACO,MAAMC,WAAW,GAAAC,OAAA,CAAAD,WAAA,GAAG,GAAG;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,UAAUA,CAACC,MAAc,EAAEC,KAAa,GAAGJ,WAAW,EAAU;EAC9E,OAAO,IAAAK,oBAAS,EAACF,MAAM,EAAEC,KAAK,CAAC;AACjC","ignoreList":[]}

package/dist/commonjs/internal/parseInlineMarkdown.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseInlineMarkdown = parseInlineMarkdown;
+/**
+ * Inline-only markdown tokenizer for chat bubbles — the parsing logic behind
+ * {@link FormattedText}.
+ *
+ * It turns inline emphasis a bot reply may contain (`**bold**`, `_italic_`,
+ * `` `code` ``, `~~strike~~`) into styled segments WITHOUT pulling in a full
+ * markdown engine (and its native-incompatible dependencies). Block markdown is
+ * intentionally NOT supported — chat bubbles render a single paragraph and a
+ * typical bot prompt forbids headers/lists/tables; user-typed messages stay
+ * plain. Anything unmatched renders as literal text, so a stray marker can never
+ * swallow the rest of the message.
+ *
+ * Supported emphasis: bold (double asterisk or underscore), italic (single
+ * asterisk or underscore), bold+italic (triple or nested), inline code
+ * (backticks — kept literal), and strikethrough (double tilde).
+ *
+ * Pure + theme-free — no React, no colors, no fonts — so it is unit-testable in
+ * node like its neighbours. Lifted verbatim from the pilot consumer's chat.
+ */
+
+const BASE = {
+  bold: false,
+  italic: false,
+  code: false,
+  strike: false
+};
+
+// Delimiters in match order: longest first so `***` wins over `**` over `*`.
+// Each (apart from code) recurses into its content with one flag turned on.
+const DELIMITERS = [{
+  open: '***',
+  flag: 'bold',
+  alsoFlag: 'italic'
+}, {
+  open: '___',
+  flag: 'bold',
+  alsoFlag: 'italic'
+}, {
+  open: '~~',
+  flag: 'strike'
+}, {
+  open: '**',
+  flag: 'bold'
+}, {
+  open: '__',
+  flag: 'bold'
+}, {
+  open: '*',
+  flag: 'italic'
+}, {
+  open: '_',
+  flag: 'italic'
+}];
+function parseInlineMarkdown(input) {
+  return parse(input, BASE);
+}
+function parse(text, flags) {
+  const tokens = [];
+  let buffer = '';
+  let i = 0;
+  const flush = () => {
+    if (buffer) {
+      tokens.push({
+        text: buffer,
+        ...flags
+      });
+      buffer = '';
+    }
+  };
+  while (i < text.length) {
+    // Inline code: content is literal, never re-parsed.
+    if (text[i] === '`') {
+      const close = text.indexOf('`', i + 1);
+      if (close !== -1) {
+        flush();
+        tokens.push({
+          text: text.slice(i + 1, close),
+          ...flags,
+          code: true
+        });
+        i = close + 1;
+        continue;
+      }
+    }
+    const delimiter = DELIMITERS.find(d => text.startsWith(d.open, i));
+    if (delimiter) {
+      const contentStart = i + delimiter.open.length;
+      const close = text.indexOf(delimiter.open, contentStart);
+      if (close !== -1) {
+        flush();
+        const inner = text.slice(contentStart, close);
+        const innerFlags = {
+          ...flags,
+          [delimiter.flag]: true
+        };
+        if (delimiter.alsoFlag) innerFlags[delimiter.alsoFlag] = true;
+        tokens.push(...parse(inner, innerFlags));
+        i = close + delimiter.open.length;
+        continue;
+      }
+      // No closing marker — emit the opener as literal text and move past it.
+      buffer += delimiter.open;
+      i = contentStart;
+      continue;
+    }
+    buffer += text[i];
+    i += 1;
+  }
+  flush();
+  return tokens;
+}
+//# sourceMappingURL=parseInlineMarkdown.js.map

package/dist/commonjs/internal/parseInlineMarkdown.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BASE","bold","italic","code","strike","DELIMITERS","open","flag","alsoFlag","parseInlineMarkdown","input","parse","text","flags","tokens","buffer","i","flush","push","length","close","indexOf","slice","delimiter","find","d","startsWith","contentStart","inner","innerFlags"],"sourceRoot":"../../../src","sources":["internal/parseInlineMarkdown.ts"],"mappings":"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","ignoreList":[]}

package/dist/commonjs/internal/refCounter.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRefCounter = createRefCounter;
+/**
+ * Refcounted start/stop for a shared resource: `onFirst` fires when the count
+ * goes 0 → 1, `onLast` when it returns to 0. Unbalanced releases are no-ops
+ * (StrictMode / Fast Refresh safe).
+ *
+ * Lifted verbatim from the pilot consumer (tea-companion) where it backs
+ * {@link Skeleton}: all shimmer sweeps on screen share ONE UI-thread animation
+ * loop instead of starting one per instance (mounting a screen full of
+ * skeletons otherwise spun up dozens of `withRepeat` loops and froze the tab
+ * transition). Pure + theme-free.
+ */
+
+function createRefCounter(onFirst, onLast) {
+  let count = 0;
+  return {
+    retain() {
+      count += 1;
+      if (count === 1) onFirst();
+    },
+    release() {
+      if (count === 0) return;
+      count -= 1;
+      if (count === 0) onLast();
+    }
+  };
+}
+//# sourceMappingURL=refCounter.js.map

package/dist/commonjs/internal/refCounter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createRefCounter","onFirst","onLast","count","retain","release"],"sourceRoot":"../../../src","sources":["internal/refCounter.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAMO,SAASA,gBAAgBA,CAACC,OAAmB,EAAEC,MAAkB,EAAc;EACpF,IAAIC,KAAK,GAAG,CAAC;EACb,OAAO;IACLC,MAAMA,CAAA,EAAG;MACPD,KAAK,IAAI,CAAC;MACV,IAAIA,KAAK,KAAK,CAAC,EAAEF,OAAO,CAAC,CAAC;IAC5B,CAAC;IACDI,OAAOA,CAAA,EAAG;MACR,IAAIF,KAAK,KAAK,CAAC,EAAE;MACjBA,KAAK,IAAI,CAAC;MACV,IAAIA,KAAK,KAAK,CAAC,EAAED,MAAM,CAAC,CAAC;IAC3B;EACF,CAAC;AACH","ignoreList":[]}