@btndprojects/loam-ui-native 0.0.0-stage → 0.1.0

package/dist/chunk-H6NIOQHK.js

@@ -0,0 +1,346 @@
+import { DRAG_CURSOR } from './chunk-KTAC4MGE.js';
+import { haptics } from './chunk-NY2U3PBI.js';
+import { useResolvedMotion } from './chunk-6N33LFQA.js';
+import * as React from 'react';
+import { Animated, Easing, PanResponder, View, Text } from 'react-native';
+import { createStyleSheet, useStyles, useLoamTheme } from '@btndprojects/loam-theme-native';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var GEOMETRY = {
+  sm: { thumb: 18, track: 4, height: 32 },
+  // loam-allow-raw: ramp keys, read via theme.space
+  md: { thumb: 24, track: 6, height: 40 }
+  // loam-allow-raw: ramp keys, read via theme.space
+};
+var THUMB_ACTIVE_SCALE = 1.18;
+var MAX_TICKS = 20;
+var BUBBLE_BOTTOM = 28;
+function clamp(n, lo, hi) {
+  return Math.max(lo, Math.min(hi, n));
+}
+function Slider({
+  min = 0,
+  max = 100,
+  step = 1,
+  value,
+  defaultValue,
+  onValueChange,
+  disabled = false,
+  size = "md",
+  motion = "full",
+  showValue = false,
+  showReadout = false,
+  showTicks = false,
+  accessibilityLabel
+}) {
+  const animateScale = useResolvedMotion(motion) === "full";
+  const isControlled = value !== void 0;
+  const [internal, setInternal] = React.useState(defaultValue ?? min);
+  const current = clamp(isControlled ? value : internal, min, max);
+  const { styles } = useStyles(sheet, { size, disabled });
+  const theme = useLoamTheme();
+  const fraction = max > min ? (current - min) / (max - min) : 0;
+  const pct = `${fraction * 100}%`;
+  const [trackWidth, setTrackWidth] = React.useState(0);
+  const containerRef = React.useRef(null);
+  const widthRef = React.useRef(0);
+  const leftRef = React.useRef(0);
+  const currentRef = React.useRef(current);
+  currentRef.current = current;
+  const disabledRef = React.useRef(disabled);
+  disabledRef.current = disabled;
+  const setValue = React.useCallback(
+    (next) => {
+      if (next === currentRef.current) return;
+      currentRef.current = next;
+      if (!isControlled) setInternal(next);
+      onValueChange?.(next);
+    },
+    [isControlled, onValueChange]
+  );
+  const handleRef = React.useRef(() => {
+  });
+  handleRef.current = (pageX) => {
+    const width = widthRef.current;
+    if (!width) return;
+    const frac = clamp((pageX - leftRef.current) / width, 0, 1);
+    const raw = min + frac * (max - min);
+    const stepped = step > 0 ? Math.round(raw / step) * step : raw;
+    const next = clamp(Number(stepped.toFixed(6)), min, max);
+    setValue(next);
+  };
+  const thumbScale = React.useRef(new Animated.Value(1)).current;
+  const swellRef = React.useRef(() => {
+  });
+  swellRef.current = (to) => {
+    if (!animateScale) {
+      thumbScale.setValue(to);
+      return;
+    }
+    Animated.timing(thumbScale, {
+      toValue: to,
+      duration: theme.duration.base,
+      easing: Easing.bezier(...theme.easing.spring),
+      useNativeDriver: true
+    }).start();
+  };
+  const bubbleScale = React.useRef(new Animated.Value(0)).current;
+  const bubbleRef = React.useRef(() => {
+  });
+  bubbleRef.current = (to) => {
+    if (!animateScale) {
+      bubbleScale.setValue(to);
+      return;
+    }
+    Animated.timing(bubbleScale, {
+      toValue: to,
+      duration: theme.duration.base,
+      easing: Easing.bezier(...theme.easing.spring),
+      useNativeDriver: true
+    }).start();
+  };
+  const steppedRef = React.useRef(step > 0);
+  steppedRef.current = step > 0;
+  const pan = React.useRef(
+    PanResponder.create({
+      onStartShouldSetPanResponder: () => !disabledRef.current,
+      onMoveShouldSetPanResponder: () => !disabledRef.current,
+      onPanResponderGrant: (e) => {
+        swellRef.current(THUMB_ACTIVE_SCALE);
+        bubbleRef.current(1);
+        haptics.impact("light");
+        handleRef.current(e.nativeEvent.pageX);
+      },
+      onPanResponderMove: (e) => {
+        const before = currentRef.current;
+        handleRef.current(e.nativeEvent.pageX);
+        if (steppedRef.current && currentRef.current !== before) haptics.impact("light");
+      },
+      onPanResponderRelease: () => {
+        swellRef.current(1);
+        bubbleRef.current(0);
+        if (steppedRef.current) haptics.impact("medium");
+      },
+      onPanResponderTerminate: () => {
+        swellRef.current(1);
+        bubbleRef.current(0);
+      }
+    })
+  ).current;
+  const onLayout = (e) => {
+    const w = e.nativeEvent.layout.width;
+    widthRef.current = w;
+    setTrackWidth(w);
+    containerRef.current?.measureInWindow?.((x) => {
+      leftRef.current = x;
+    });
+  };
+  const thumbSize = theme.space[GEOMETRY[size].thumb];
+  const thumbTranslateX = fraction * trackWidth - thumbSize / 2;
+  const stepCount = step > 0 && max > min ? Math.round((max - min) / step) : 0;
+  const showTickMarks = showTicks && stepCount > 0 && stepCount <= MAX_TICKS;
+  const tickIndices = showTickMarks ? Array.from({ length: stepCount + 1 }, (_, i) => i) : [];
+  const bubbleLabel = step > 0 ? String(current) : `${Math.round(fraction * 100)}%`;
+  const readoutText = `${min} \xB7 ${Math.round(fraction * 100)}% \xB7 ${max}`;
+  return /* @__PURE__ */ jsxs(View, { style: styles.wrap, children: [
+    /* @__PURE__ */ jsxs(View, { style: styles.trackRow, children: [
+      /* @__PURE__ */ jsxs(
+        View,
+        {
+          ref: containerRef,
+          accessibilityRole: "adjustable",
+          accessibilityLabel,
+          accessibilityValue: { min, max, now: current },
+          accessibilityState: { disabled },
+          "aria-valuemin": min,
+          "aria-valuemax": max,
+          "aria-valuenow": current,
+          onLayout,
+          style: [styles.container, !disabled && DRAG_CURSOR],
+          ...disabled ? {} : pan.panHandlers,
+          children: [
+            /* @__PURE__ */ jsxs(View, { style: styles.track, children: [
+              /* @__PURE__ */ jsx(View, { style: [styles.fill, { width: pct }] }),
+              showTickMarks && /* @__PURE__ */ jsx(View, { style: styles.ticks, children: tickIndices.map((i) => /* @__PURE__ */ jsx(View, { testID: `slider-tick-${i}`, style: styles.tick }, i)) })
+            ] }),
+            /* @__PURE__ */ jsx(
+              View,
+              {
+                style: [styles.bubbleAnchor, { transform: [{ translateX: fraction * trackWidth }] }],
+                children: /* @__PURE__ */ jsx(
+                  Animated.View,
+                  {
+                    testID: "slider-bubble",
+                    style: [styles.bubbleCard, { transform: [{ scale: bubbleScale }] }],
+                    children: /* @__PURE__ */ jsx(Text, { style: styles.bubbleText, children: bubbleLabel })
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              Animated.View,
+              {
+                testID: "slider-thumb",
+                style: [
+                  styles.thumb,
+                  {
+                    transform: [{ translateX: thumbTranslateX }, { scale: thumbScale }]
+                  }
+                ]
+              }
+            )
+          ]
+        }
+      ),
+      showValue ? /* @__PURE__ */ jsx(Text, { style: styles.value, children: current }) : null
+    ] }),
+    showReadout ? /* @__PURE__ */ jsx(Text, { style: styles.readout, children: readoutText }) : null
+  ] });
+}
+var sheet = createStyleSheet((theme) => ({
+  // Outer column: stacks the track row and (optional) read-out below it.
+  wrap: {
+    flexDirection: "column",
+    alignSelf: "stretch",
+    gap: theme.space.s2
+  },
+  // Track row: slider container + optional side-label.
+  trackRow: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: theme.space.s3
+  },
+  container: {
+    flex: 1,
+    justifyContent: "center",
+    variants: {
+      size: {
+        sm: { height: theme.space[GEOMETRY.sm.height] },
+        md: { height: theme.space[GEOMETRY.md.height] }
+      },
+      disabled: {
+        true: { opacity: theme.state.disabledOpacity },
+        false: {}
+      }
+    }
+  },
+  track: {
+    width: "100%",
+    borderRadius: theme.radius.full,
+    backgroundColor: theme.color.surface3,
+    overflow: "hidden",
+    variants: {
+      size: {
+        sm: { height: theme.space[GEOMETRY.sm.track] },
+        md: { height: theme.space[GEOMETRY.md.track] }
+      },
+      disabled: {}
+    }
+  },
+  fill: {
+    position: "absolute",
+    left: 0,
+    top: 0,
+    bottom: 0,
+    borderRadius: theme.radius.full,
+    backgroundColor: theme.color.accent,
+    variants: { size: {}, disabled: {} }
+  },
+  // Tick marks overlaid inside the track (reference sliderCtl line 2294).
+  // `overflow: 'hidden'` on `track` keeps them clipped to the track bounds.
+  ticks: {
+    position: "absolute",
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0,
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center"
+  },
+  tick: {
+    width: theme.space[4],
+    height: theme.space[4],
+    borderRadius: theme.radius.full,
+    backgroundColor: theme.color.surface,
+    borderWidth: theme.borderWidth.thin,
+    borderColor: theme.color.border
+  },
+  // Bubble anchor: zero-width column pinned to the bottom of the drag zone.
+  // `alignItems: 'center'` centres the bubble card over the zero-width axis
+  // without knowing the card's intrinsic width.
+  bubbleAnchor: {
+    position: "absolute",
+    bottom: BUBBLE_BOTTOM,
+    width: 0,
+    alignItems: "center"
+  },
+  // The pill-shaped card that floats above the thumb during drag.
+  // Reference sliderCtl line 2292: background var(--text), color var(--bg),
+  // font-size 12px, font-weight 700, padding 4px 9px, border-radius 8px.
+  bubbleCard: {
+    backgroundColor: theme.color.text,
+    borderRadius: theme.radius.sm,
+    paddingVertical: theme.space.s1,
+    paddingHorizontal: theme.space[9]
+  },
+  bubbleText: {
+    color: theme.color.bg,
+    fontFamily: theme.font.sans,
+    fontSize: theme.type.caption1.fontSize,
+    fontWeight: theme.fontWeight.bold,
+    lineHeight: theme.type.caption1.lineHeight
+  },
+  thumb: {
+    position: "absolute",
+    top: "50%",
+    backgroundColor: theme.color.surface,
+    borderRadius: theme.radius.full,
+    // `0 0 0 1px var(--border)` — a 1px ring that is part of the drawing, so it
+    // uses the static `w1` weight rather than the contrast-reactive hairline.
+    borderWidth: theme.borderWidth.thin,
+    borderColor: theme.color.border,
+    // The reference asks for `0 2px 8px rgba(…,.25)` (`sliderCtl()`, reference
+    // line 2290). That is `shadow.knob` with a wider blur, so only the radius
+    // is overridden — and the *colour* now comes from the theme, which carries
+    // the accent tint `--sh-*` carries on the web. A hardcoded `#000000` here
+    // made the thumb one of the only shadows in the system to ignore the tint.
+    ...theme.shadow.knob,
+    shadowRadius: theme.space[8],
+    elevation: 3,
+    // loam-allow-raw: Android depth between shadow.knob (2) and shadow.md (4).
+    variants: {
+      size: {
+        sm: {
+          width: theme.space[GEOMETRY.sm.thumb],
+          height: theme.space[GEOMETRY.sm.thumb],
+          // Vertical centring only — horizontal offset comes from translateX.
+          marginTop: -theme.space[GEOMETRY.sm.thumb] / 2
+        },
+        md: {
+          width: theme.space[GEOMETRY.md.thumb],
+          height: theme.space[GEOMETRY.md.thumb],
+          // Vertical centring only — horizontal offset comes from translateX.
+          marginTop: -theme.space[GEOMETRY.md.thumb] / 2
+        }
+      },
+      disabled: {}
+    }
+  },
+  value: {
+    minWidth: theme.space[36],
+    textAlign: "right",
+    fontFamily: theme.font.mono,
+    fontSize: theme.fontSize[14],
+    color: theme.color.text2
+  },
+  // Read-out row: mono `min · value% · max` below the track.
+  readout: {
+    fontFamily: theme.font.mono,
+    fontSize: theme.fontSize[12],
+    color: theme.color.text3,
+    textAlign: "center"
+  }
+}));
+
+export { Slider };

package/dist/chunk-H6PC7RDA.js

@@ -0,0 +1 @@
+

package/dist/chunk-HPPW424V.js

@@ -0,0 +1,334 @@
+import { Icon } from './chunk-TKVFVF5D.js';
+import * as React2 from 'react';
+import { Platform, Easing, Keyboard, Animated, View, Pressable, Text, useWindowDimensions, ScrollView } from 'react-native';
+import { createStyleSheet, useLoamTheme, useStyles } from '@btndprojects/loam-theme-native';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+function keyboardEventNames(os = Platform.OS) {
+  return os === "ios" ? { show: "keyboardWillShow", hide: "keyboardWillHide" } : { show: "keyboardDidShow", hide: "keyboardDidHide" };
+}
+function eventDuration(event, fallback) {
+  const reported = event?.duration;
+  return typeof reported === "number" && reported > 0 ? reported : fallback;
+}
+function eventEasing(event) {
+  const reported = event?.easing;
+  return reported && reported !== "keyboard" ? reported : void 0;
+}
+function keyboardEasing(easing, fallback) {
+  switch (easing) {
+    case "linear":
+      return Easing.linear;
+    case "easeIn":
+      return Easing.in(Easing.ease);
+    case "easeOut":
+      return Easing.out(Easing.ease);
+    case "easeInEaseOut":
+      return Easing.inOut(Easing.ease);
+    default:
+      return Easing.bezier(...fallback);
+  }
+}
+function useKeyboardInset() {
+  const theme = useLoamTheme();
+  const enterDuration = theme.motion.enter.duration;
+  const exitDuration = theme.motion.exit.duration;
+  const [state, setState] = React2.useState(() => ({
+    height: 0,
+    visible: false,
+    duration: enterDuration,
+    easing: void 0
+  }));
+  React2.useEffect(() => {
+    const { show, hide } = keyboardEventNames();
+    const onShow = (event) => setState({
+      height: event?.endCoordinates?.height ?? 0,
+      visible: true,
+      duration: eventDuration(event, enterDuration),
+      easing: eventEasing(event)
+    });
+    const onHide = (event) => setState({
+      height: 0,
+      visible: false,
+      // Closing is an exit: faster than the open, per the motion contract.
+      duration: eventDuration(event, exitDuration),
+      easing: eventEasing(event)
+    });
+    const subscriptions = [Keyboard.addListener(show, onShow), Keyboard.addListener(hide, onHide)];
+    return () => {
+      for (const subscription of subscriptions) subscription.remove();
+    };
+  }, [enterDuration, exitDuration]);
+  return state;
+}
+function useAnimatedKeyboardInset(extra = 0) {
+  const theme = useLoamTheme();
+  const state = useKeyboardInset();
+  const inset = React2.useRef(new Animated.Value(0)).current;
+  const fallbackCurve = state.visible ? theme.motion.enter.easing : theme.motion.exit.easing;
+  const target = state.visible ? state.height + extra : 0;
+  React2.useEffect(() => {
+    Animated.timing(inset, {
+      toValue: target,
+      duration: state.duration,
+      easing: keyboardEasing(state.easing, fallbackCurve),
+      // A reserved gap is layout, so this one cannot ride the native driver; it
+      // is a single value per keyboard transition, not a per-frame loop.
+      useNativeDriver: false
+    }).start();
+  }, [inset, target, state.duration, state.easing, fallbackCurve]);
+  return { inset, state };
+}
+var PREVIOUS_ICON = "arrow-up";
+var NEXT_ICON = "arrow-down";
+var ACCESSORY_NAV_MIN_FIELDS = 3;
+function KeyboardSpacer({
+  extra = 0,
+  enabled = true,
+  testID
+}) {
+  const { inset } = useAnimatedKeyboardInset(extra);
+  return /* @__PURE__ */ jsx(
+    Animated.View,
+    {
+      accessibilityElementsHidden: true,
+      importantForAccessibility: "no-hide-descendants",
+      style: { height: enabled ? inset : 0 },
+      testID
+    }
+  );
+}
+function KeyboardStickyView({
+  children,
+  offset = 0,
+  enabled = true,
+  style,
+  testID
+}) {
+  const { styles } = useStyles(sheet);
+  const { inset } = useAnimatedKeyboardInset(offset);
+  const lift = inset.interpolate({ inputRange: [0, 1], outputRange: [0, -1] });
+  return /* @__PURE__ */ jsx(
+    Animated.View,
+    {
+      style: [styles.stickyBar, { transform: [{ translateY: enabled ? lift : 0 }] }, style],
+      testID,
+      children
+    }
+  );
+}
+function KeyboardAccessoryBar({
+  navigable = true,
+  fieldCount,
+  canGoPrevious = true,
+  canGoNext = true,
+  onPrevious,
+  onNext,
+  onDone,
+  doneLabel = "Done",
+  previousLabel = "Previous field",
+  nextLabel = "Next field",
+  children,
+  sticky = false,
+  style,
+  testID
+}) {
+  const { styles } = useStyles(sheet);
+  const showNav = navigable && (fieldCount == null || fieldCount > ACCESSORY_NAV_MIN_FIELDS);
+  const bar = /* @__PURE__ */ jsxs(View, { accessibilityRole: "toolbar", style: [styles.accessoryBar, style], testID, children: [
+    showNav ? /* @__PURE__ */ jsxs(View, { style: styles.accessoryNav, children: [
+      /* @__PURE__ */ jsx(
+        AccessoryButton,
+        {
+          icon: PREVIOUS_ICON,
+          label: previousLabel,
+          disabled: !canGoPrevious,
+          onPress: onPrevious
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        AccessoryButton,
+        {
+          icon: NEXT_ICON,
+          label: nextLabel,
+          disabled: !canGoNext,
+          onPress: onNext
+        }
+      )
+    ] }) : /* @__PURE__ */ jsx(View, {}),
+    children ? /* @__PURE__ */ jsx(View, { style: styles.accessoryMiddle, children }) : null,
+    /* @__PURE__ */ jsx(
+      Pressable,
+      {
+        accessibilityRole: "button",
+        accessibilityLabel: doneLabel,
+        onPress: onDone,
+        style: styles.accessoryDone,
+        children: /* @__PURE__ */ jsx(Text, { style: styles.accessoryDoneLabel, children: doneLabel })
+      }
+    )
+  ] });
+  return sticky ? /* @__PURE__ */ jsx(KeyboardStickyView, { children: bar }) : bar;
+}
+function AccessoryButton({
+  icon,
+  label,
+  disabled,
+  onPress
+}) {
+  const theme = useLoamTheme();
+  const { styles } = useStyles(sheet, { disabled });
+  return /* @__PURE__ */ jsx(
+    Pressable,
+    {
+      accessibilityRole: "button",
+      accessibilityLabel: label,
+      accessibilityState: { disabled },
+      disabled,
+      onPress: disabled ? void 0 : onPress,
+      style: ({ pressed }) => [
+        styles.accessoryButton,
+        pressed && !disabled ? { backgroundColor: theme.state.pressed } : null
+      ],
+      children: /* @__PURE__ */ jsx(Icon, { name: icon, size: theme.icon.md, color: disabled ? theme.color.text3 : theme.color.text2 })
+    }
+  );
+}
+var KeyboardScrollContext = React2.createContext(null);
+function KeyboardAvoidingScrollView({
+  children,
+  extraBottom,
+  keyboardDismissMode = "on-drag",
+  contentContainerStyle,
+  onScroll,
+  testID,
+  ...rest
+}) {
+  const theme = useLoamTheme();
+  const inset = useKeyboardInset();
+  const { height: windowHeight } = useWindowDimensions();
+  const clearance = extraBottom ?? theme.layout.screenPad;
+  const scrollRef = React2.useRef(null);
+  const offset = React2.useRef(0);
+  const restoreTo = React2.useRef(null);
+  const pendingNode = React2.useRef(null);
+  const latest = React2.useRef({ inset, windowHeight, clearance });
+  latest.current = { inset, windowHeight, clearance };
+  const handleScroll = React2.useCallback(
+    (event) => {
+      offset.current = event.nativeEvent.contentOffset.y;
+      onScroll?.(event);
+    },
+    [onScroll]
+  );
+  const bringIntoView = React2.useCallback((node) => {
+    if (!node || typeof node.measureInWindow !== "function") return;
+    const { inset: kbd, windowHeight: winH, clearance: pad } = latest.current;
+    if (!kbd.visible) {
+      pendingNode.current = node;
+      return;
+    }
+    node.measureInWindow((_x, y, _width, height) => {
+      const visibleBottom = winH - kbd.height - pad;
+      const covered = y + height - visibleBottom;
+      if (covered > 0) {
+        scrollRef.current?.scrollTo({ y: offset.current + covered, animated: true });
+      }
+    });
+  }, []);
+  React2.useEffect(() => {
+    if (inset.visible) {
+      restoreTo.current = offset.current;
+      const node = pendingNode.current;
+      pendingNode.current = null;
+      if (node) bringIntoView(node);
+      return;
+    }
+    pendingNode.current = null;
+    const target = restoreTo.current;
+    restoreTo.current = null;
+    if (target != null) scrollRef.current?.scrollTo({ y: target, animated: true });
+  }, [inset.visible, bringIntoView]);
+  const context = React2.useMemo(
+    () => ({ scrollIntoView: bringIntoView }),
+    [bringIntoView]
+  );
+  return /* @__PURE__ */ jsx(KeyboardScrollContext.Provider, { value: context, children: /* @__PURE__ */ jsx(
+    ScrollView,
+    {
+      ref: scrollRef,
+      keyboardDismissMode,
+      keyboardShouldPersistTaps: "handled",
+      scrollEventThrottle: 16,
+      onScroll: handleScroll,
+      contentContainerStyle: [{ paddingBottom: inset.height + clearance }, contentContainerStyle],
+      testID,
+      ...rest,
+      children
+    }
+  ) });
+}
+function useScrollIntoView() {
+  const context = React2.useContext(KeyboardScrollContext);
+  const ref = React2.useRef(null);
+  const onFocus = React2.useCallback(() => {
+    context?.scrollIntoView(ref.current);
+  }, [context]);
+  return { ref, onFocus };
+}
+var sheet = createStyleSheet((theme) => ({
+  // The reference draws the accessory bar 42 dp tall; `toolbarH` (44) is the
+  // token for exactly this surface and also clears `tapMin`.
+  accessoryBar: {
+    minHeight: theme.layout.toolbarH,
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    paddingHorizontal: theme.space.s3,
+    backgroundColor: theme.color.surface2,
+    borderTopWidth: theme.borderWidth.base,
+    borderTopColor: theme.color.border
+  },
+  accessoryNav: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: theme.space.s2
+  },
+  accessoryMiddle: { flex: 1, alignItems: "center" },
+  accessoryButton: {
+    minWidth: theme.tapMin,
+    minHeight: theme.tapMin,
+    alignItems: "center",
+    justifyContent: "center",
+    borderRadius: theme.radius.sm,
+    variants: {
+      disabled: {
+        true: { opacity: theme.state.disabledOpacity },
+        false: {}
+      }
+    }
+  },
+  accessoryDone: {
+    minHeight: theme.tapMin,
+    minWidth: theme.tapMin,
+    alignItems: "flex-end",
+    justifyContent: "center",
+    paddingHorizontal: theme.space.s1
+  },
+  accessoryDoneLabel: {
+    fontFamily: theme.font.sans,
+    fontWeight: theme.fontWeight.bold,
+    fontSize: theme.type.footnote.fontSize,
+    lineHeight: theme.type.footnote.lineHeight,
+    letterSpacing: theme.type.footnote.letterSpacing,
+    color: theme.color.accentStrong
+  },
+  stickyBar: {
+    flexDirection: "column",
+    backgroundColor: theme.color.surface,
+    borderTopWidth: theme.borderWidth.base,
+    borderTopColor: theme.color.border
+  }
+}));
+
+export { ACCESSORY_NAV_MIN_FIELDS, KeyboardAccessoryBar, KeyboardAvoidingScrollView, KeyboardSpacer, KeyboardStickyView, keyboardEasing, keyboardEventNames, useAnimatedKeyboardInset, useKeyboardInset, useScrollIntoView };

package/dist/chunk-HQOQIBJI.js

@@ -0,0 +1 @@
+