everkit-ui 0.1.0

package/dist/module/internal/avatarFallback.js

@@ -0,0 +1,97 @@
+"use strict";
+
+/**
+ * Pure prop-resolution for `<Avatar/>`'s initials disc — deriving the initials
+ * string and a deterministic `{ disc, ink }` colour PAIR from the theme.
+ *
+ * The pilot consumer (tea-companion) read a tea-specific `colors.avatarFallback`
+ * palette token that is NOT part of everkit's `ThemeColors` contract. To stay
+ * self-contained, the library instead hashes the stable id (FNV-1a) to pick one
+ * of the SIX theme ramps every theme already exposes — the three `brand.*` ramps
+ * plus three `semantic.*` colours — and pairs a light disc with a dark ink (or
+ * vice-versa) drawn from those tokens. No hardcoded hex, no app palette, and the
+ * disc still varies deterministically per user.
+ *
+ * Keeping this outside the React component makes it cheap to unit-test under
+ * `node:test` without a renderer.
+ */
+
+/**
+ * Up to two uppercase letters from display name, then the email local part.
+ * Returns `null` when nothing letter-like is available — the caller then renders
+ * a fallback glyph. Unicode-aware (`\p{L}`), so accented names work.
+ */
+export function deriveInitials(displayName, email) {
+  const fromName = initialsFromDisplayName(displayName);
+  if (fromName) return fromName;
+  const fromEmail = initialsFromEmail(email);
+  if (fromEmail) return fromEmail;
+  return null;
+}
+function initialsFromDisplayName(name) {
+  if (!name) return null;
+  const tokens = name.split(/\s+/).map(t => t.replace(/[^\p{L}]/gu, '')).filter(Boolean);
+  if (tokens.length === 0) return null;
+  if (tokens.length === 1) {
+    const only = tokens[0].slice(0, 2).toUpperCase();
+    return only.length > 0 ? only : null;
+  }
+  const first = tokens[0].charAt(0);
+  const second = tokens[1].charAt(0);
+  return (first + second).toUpperCase();
+}
+function initialsFromEmail(email) {
+  if (!email) return null;
+  const local = email.split('@')[0] ?? '';
+  const letters = local.replace(/^[^\p{L}]+/u, '').replace(/[^\p{L}]/gu, '');
+  if (!letters) return null;
+  return letters.slice(0, 2).toUpperCase();
+}
+
+/**
+ * FNV-1a 32-bit hash of the stable id, modulo the ramp count. Returns `0` (the
+ * first ramp) when the id is missing, so an avatar with no id is still stable.
+ */
+export function hashToRampIndex(stableId, rampCount) {
+  if (!stableId) return 0;
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < stableId.length; i++) {
+    hash ^= stableId.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash % rampCount;
+}
+
+/**
+ * Resolve the deterministic `{ disc, ink }` pair for the fallback disc, picking
+ * a ramp by hashing `stableId` over the theme's own tokens.
+ *
+ * Each ramp pairs a LIGHT fill with a DARK ink so the initials stay legible:
+ * the three `brand` ramps use their `*Light` / `*Dark` stops, and the three
+ * `semantic` colours derive a tint over the colour with the colour itself as
+ * ink. No literal colour is introduced — everything is read from the injected
+ * {@link ThemeColors}.
+ */
+export function resolveAvatarColors(colors, stableId) {
+  const ramps = [{
+    disc: colors.brand.primaryLight,
+    ink: colors.brand.primaryDark
+  }, {
+    disc: colors.brand.secondaryLight,
+    ink: colors.brand.secondaryDark
+  }, {
+    disc: colors.brand.accentLight,
+    ink: colors.brand.accentDark
+  }, {
+    disc: colors.brand.primaryLight,
+    ink: colors.semantic.info
+  }, {
+    disc: colors.brand.secondaryLight,
+    ink: colors.semantic.success
+  }, {
+    disc: colors.brand.accentLight,
+    ink: colors.semantic.warning
+  }];
+  return ramps[hashToRampIndex(stableId, ramps.length)];
+}
+//# sourceMappingURL=avatarFallback.js.map

package/dist/module/internal/avatarFallback.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["deriveInitials","displayName","email","fromName","initialsFromDisplayName","fromEmail","initialsFromEmail","name","tokens","split","map","t","replace","filter","Boolean","length","only","slice","toUpperCase","first","charAt","second","local","letters","hashToRampIndex","stableId","rampCount","hash","i","charCodeAt","Math","imul","resolveAvatarColors","colors","ramps","disc","brand","primaryLight","ink","primaryDark","secondaryLight","secondaryDark","accentLight","accentDark","semantic","info","success","warning"],"sourceRoot":"../../../src","sources":["internal/avatarFallback.ts"],"mappings":"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","ignoreList":[]}

package/dist/module/internal/chipStyle.js

@@ -0,0 +1,84 @@
+"use strict";
+
+/**
+ * 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.
+ */
+
+import { hexToRgba } from "./hexToRgba.js";
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export 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
+      };
+  }
+}
+export 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: hexToRgba(colors.semantic.info, isDark ? 0.18 : 0.12),
+        fg: colors.semantic.info
+      };
+    case 'warning':
+      return {
+        bg: hexToRgba(colors.semantic.warning, isDark ? 0.18 : 0.15),
+        fg: colors.semantic.warning
+      };
+  }
+}
+//# sourceMappingURL=chipStyle.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["hexToRgba","resolveChipSize","size","paddingHorizontal","paddingVertical","textVariant","iconSize","emojiFontSize","gap","resolveChipColors","variant","options","colors","isDark","bg","tertiary","fg","text","secondary","brand","primaryLight","primaryDark","semantic","info","warning"],"sourceRoot":"../../../src","sources":["internal/chipStyle.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,SAASA,SAAS,QAAQ,gBAAa;AA+BvC;AACA;AACA;;AAEA,OAAO,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;AAEA,OAAO,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,EAAEd,SAAS,CAACY,MAAM,CAACU,QAAQ,CAACC,IAAI,EAAEV,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;QACzDG,EAAE,EAAEJ,MAAM,CAACU,QAAQ,CAACC;MACtB,CAAC;IAEH,KAAK,SAAS;MACZ,OAAO;QACLT,EAAE,EAAEd,SAAS,CAACY,MAAM,CAACU,QAAQ,CAACE,OAAO,EAAEX,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;QAC5DG,EAAE,EAAEJ,MAAM,CAACU,QAAQ,CAACE;MACtB,CAAC;EACL;AACF","ignoreList":[]}

package/dist/module/internal/detailScreenState.js

@@ -0,0 +1,27 @@
+"use strict";
+
+/**
+ * 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).
+ */
+
+export function resolveDetailScreenState(input) {
+  if (input.isLoading) return 'loading';
+  if (input.error != null) return 'error';
+  return 'content';
+}
+//# sourceMappingURL=detailScreenState.js.map

package/dist/module/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;;AAQA,OAAO,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/module/internal/haptics.js

@@ -0,0 +1,46 @@
+"use strict";
+
+/**
+ * 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.
+ */
+export 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/module/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;AACA,OAAO,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/module/internal/hexToRgba.js

@@ -0,0 +1,24 @@
+"use strict";
+
+/**
+ * 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.
+ */
+export 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/module/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;AACA,OAAO,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/module/internal/inputStyle.js

@@ -0,0 +1,48 @@
+"use strict";
+
+/**
+ * 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.
+ */
+
+export 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/module/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;;AAeA,OAAO,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/module/internal/keyboardAwareProps.js

@@ -0,0 +1,34 @@
+"use strict";
+
+/**
+ * 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.
+ */
+
+export 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/module/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;;AAkBA,OAAO,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/module/internal/keyboardScrollViewProps.js

@@ -0,0 +1,60 @@
+"use strict";
+
+/**
+ * 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.
+ */
+
+export 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.
+ */
+export const 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).
+ */
+export 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/module/internal/keyboardScrollViewProps.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["resolveKeyboardScrollViewProps","input","enableKeyboardAvoidance","keyboardShouldPersistTaps","keyboardDismissMode","KEYBOARD_INPUT_GAP","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;;AAeA,OAAO,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;AACA,OAAO,MAAMC,kBAAkB,GAAG,EAAE;AAapC;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,8BAA8BA,CAC5CL,KAA0C,EAC3B;EACf,MAAMM,GAAG,GAAGN,KAAK,CAACM,GAAG,IAAIF,kBAAkB;EAC3C,MAAMG,OAAO,GAAGP,KAAK,CAACQ,YAAY,GAAGF,GAAG,GAAGN,KAAK,CAACS,YAAY;EAC7D,IAAIF,OAAO,IAAI,CAAC,EAAE,OAAO,IAAI;EAC7B,OAAOP,KAAK,CAACU,cAAc,GAAGH,OAAO;AACvC","ignoreList":[]}

package/dist/module/internal/overlay.js

@@ -0,0 +1,32 @@
+"use strict";
+
+/**
+ * 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.
+ */
+
+import { hexToRgba } from "./hexToRgba.js";
+
+/** Default backdrop opacity — matches the pilot consumers' `0.4` scrim. */
+export const 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}.
+ */
+export function scrimColor(inkHex, alpha = SCRIM_ALPHA) {
+  return hexToRgba(inkHex, alpha);
+}
+//# sourceMappingURL=overlay.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["hexToRgba","SCRIM_ALPHA","scrimColor","inkHex","alpha"],"sourceRoot":"../../../src","sources":["internal/overlay.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,SAAS,QAAQ,gBAAa;;AAEvC;AACA,OAAO,MAAMC,WAAW,GAAG,GAAG;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,UAAUA,CAACC,MAAc,EAAEC,KAAa,GAAGH,WAAW,EAAU;EAC9E,OAAOD,SAAS,CAACG,MAAM,EAAEC,KAAK,CAAC;AACjC","ignoreList":[]}

package/dist/module/internal/parseInlineMarkdown.js

@@ -0,0 +1,114 @@
+"use strict";
+
+/**
+ * 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'
+}];
+export 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/module/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/module/internal/refCounter.js

@@ -0,0 +1,29 @@
+"use strict";
+
+/**
+ * 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.
+ */
+
+export 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/module/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;;AAMA,OAAO,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":[]}