@xaui/native 0.9.1-alpha.9 → 0.9.1-alpha.91

package/dist/chunk-OD6H7ANY.js

@@ -0,0 +1,333 @@
+import {
+  CHECK_SPAN,
+  checkGlyph
+} from "./chunk-BTKWPEOF.js";
+import {
+  SelectionFill
+} from "./chunk-BA2DBSAN.js";
+import {
+  useControllableState
+} from "./chunk-F6W3JQ7K.js";
+import {
+  PressableFeedback
+} from "./chunk-2AFA5HA2.js";
+import {
+  usePressState
+} from "./chunk-423RQBOX.js";
+import {
+  childrenToString
+} from "./chunk-WFZDAXDI.js";
+import {
+  createRecipe,
+  radiusAxis
+} from "./chunk-DKVXTMIJ.js";
+import {
+  createSlotContext
+} from "./chunk-TTZOIXKE.js";
+import {
+  useXAUITheme
+} from "./chunk-Z6JBWRPL.js";
+import {
+  useStyleProps
+} from "./chunk-M63GFNKV.js";
+
+// src/components/checkbox/checkbox-indicator.tsx
+import { forwardRef } from "react";
+import { View } from "react-native";
+
+// src/components/checkbox/checkbox.context.ts
+var [CheckboxProvider, useCheckbox] = createSlotContext("Checkbox");
+
+// src/components/checkbox/checkbox-indicator.tsx
+import { jsx } from "react/jsx-runtime";
+var CheckboxIndicator = forwardRef(
+  function CheckboxIndicator2({ children, animation = true, style, ...props }, ref) {
+    const { indicatorStyle, fillStyle, isSelected, isIndeterminate } = useCheckbox();
+    const [styleProps, rest] = useStyleProps(props);
+    const isFilled = isSelected || isIndeterminate;
+    const mark = children ?? (isIndeterminate ? /* @__PURE__ */ jsx(Dash, {}) : /* @__PURE__ */ jsx(Check, {}));
+    return /* @__PURE__ */ jsx(View, { ref, ...rest, style: [indicatorStyle, styleProps, style], children: /* @__PURE__ */ jsx(SelectionFill, { isVisible: isFilled, style: fillStyle, animation, children: mark }) });
+  }
+);
+CheckboxIndicator.displayName = "XAUI.Checkbox.Indicator";
+function Check() {
+  const { checkStyle } = useCheckbox();
+  return /* @__PURE__ */ jsx(View, { style: checkStyle });
+}
+function Dash() {
+  const { dashStyle } = useCheckbox();
+  return /* @__PURE__ */ jsx(View, { style: dashStyle });
+}
+
+// src/components/checkbox/checkbox-label.tsx
+import { forwardRef as forwardRef2 } from "react";
+import { Text } from "react-native";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var CheckboxLabel = forwardRef2(
+  function CheckboxLabel2({ children, style, ...props }, ref) {
+    const { labelStyle } = useCheckbox();
+    const [styleProps, rest] = useStyleProps(props);
+    return /* @__PURE__ */ jsx2(Text, { ref, style: [labelStyle, styleProps, style], ...rest, children });
+  }
+);
+CheckboxLabel.displayName = "XAUI.Checkbox.Label";
+
+// src/components/checkbox/checkbox.tsx
+import { forwardRef as forwardRef3, useCallback, useMemo } from "react";
+
+// src/components/checkbox/checkbox.recipe.ts
+var SLOTS = ["root", "indicator", "fill", "check", "dash", "label"];
+var VARIANT_TOKENS = {
+  primary: {
+    bg: "fieldBackground",
+    border: "fieldBorder",
+    bgSelected: "accent",
+    fgSelected: "accentForeground"
+  },
+  // `bg: 'default'` is the neutral *token*, not this variant's name — the two namespaces
+  // meet here as they do on the `Input`, and for the same reason: on a card,
+  // `fieldBackground` is the card's own colour and the box would vanish into it.
+  secondary: {
+    bg: "default",
+    border: "fieldBorder",
+    bgSelected: "accent",
+    fgSelected: "accentForeground"
+  },
+  tertiary: {
+    border: "fieldBorder",
+    bgSelected: "accent",
+    fgSelected: "accentForeground"
+  }
+};
+function sizeAxis(step) {
+  const { box, radius, label, gap, stroke } = step;
+  return (theme) => {
+    const side = theme.spacing(box);
+    return {
+      root: { gap: theme.spacing(gap) },
+      indicator: { width: side, height: side, borderRadius: theme.radius[radius] },
+      // The tick is `utils/check-glyph`, shared with the completed step of a `Stepper`:
+      // both mark a box they fill, and both have to work with no icon set installed.
+      check: checkGlyph(side, stroke),
+      // The third state's mark: the check's long stroke, on its own and level.
+      dash: {
+        width: side * CHECK_SPAN,
+        height: stroke,
+        borderRadius: stroke / 2
+      },
+      label: {
+        fontSize: theme.fontSizes[label],
+        lineHeight: theme.lineHeights[label]
+      }
+    };
+  };
+}
+var SIZES = {
+  sm: { box: 5, radius: "sm", gap: 2, label: "sm", stroke: 2 },
+  md: { box: 6, radius: "md", gap: 2, label: "md", stroke: 2 },
+  lg: { box: 7, radius: "md", gap: 2.5, label: "lg", stroke: 2.5 }
+};
+var checkboxRecipe = createRecipe({
+  slots: SLOTS,
+  base: (theme) => ({
+    root: { flexDirection: "row", alignItems: "center", alignSelf: "flex-start" },
+    indicator: {
+      alignItems: "center",
+      justifyContent: "center",
+      borderWidth: theme.borderWidth.field,
+      borderCurve: "continuous",
+      // The fill is laid inside the box and has to stop at its corners.
+      overflow: "hidden"
+    },
+    // Laid over the box rather than sized to it: the two corners are the indicator's, and
+    // an inset of zero is what keeps the fill inside the border it is clipped by.
+    fill: {
+      position: "absolute",
+      top: 0,
+      bottom: 0,
+      start: 0,
+      end: 0,
+      alignItems: "center",
+      justifyContent: "center"
+    },
+    label: {
+      fontFamily: theme.fontFamilies.body,
+      color: theme.colors.foreground
+    }
+  }),
+  variantTokens: VARIANT_TOKENS,
+  /**
+   * Where the variant's colours land. The border width follows the *presence* of the
+   * border role, exactly as on the `Input`.
+   *
+   * `bgSelected` and `fgSelected` are painted unconditionally, on two slots the indicator
+   * only mounts while it is ticked — which is what keeps selection out of the cache key
+   * and inside the tint pass at the same time. An axis would have given up the second.
+   */
+  paint: (theme, colors) => ({
+    indicator: {
+      backgroundColor: colors.bg,
+      borderColor: colors.border,
+      borderWidth: colors.border ? theme.borderWidth.field : 0
+    },
+    fill: { backgroundColor: colors.bgSelected },
+    check: { borderColor: colors.fgSelected },
+    dash: { backgroundColor: colors.fgSelected }
+  }),
+  variants: {
+    size: {
+      sm: sizeAxis(SIZES.sm),
+      md: sizeAxis(SIZES.md),
+      lg: sizeAxis(SIZES.lg)
+    },
+    radius: radiusAxis("indicator"),
+    /**
+     * Declared after `size` so its border wins. The resting fill is dropped rather than
+     * repainted — `undefined` over a colour is what RN reads as "no background" — because
+     * a box that is wrong should read as an outline, not as a filled control that happens
+     * to be red at the edge. HeroUI reaches the same shape with a compound.
+     */
+    isInvalid: {
+      true: (theme) => ({
+        indicator: { borderColor: theme.colors.danger, backgroundColor: void 0 },
+        fill: { backgroundColor: theme.colors.danger },
+        check: { borderColor: theme.colors.dangerForeground },
+        dash: { backgroundColor: theme.colors.dangerForeground },
+        // The label turns with it: on a long form the field that is wrong has to be
+        // findable without reading every message.
+        label: { color: theme.colors.danger }
+      })
+    }
+  },
+  /** What `primary` adds to a filled box — the `Input`'s compound, on a smaller field. */
+  compoundVariants: [
+    {
+      when: { variant: "primary" },
+      style: (theme) => ({ indicator: theme.shadows.field })
+    }
+  ],
+  states: {
+    disabled: (theme) => ({ root: { opacity: theme.opacity.disabled } })
+  },
+  defaultVariants: { variant: "secondary", size: "md" }
+});
+
+// src/components/checkbox/checkbox.tsx
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+var CheckboxRoot = forwardRef3(function Checkbox({
+  children,
+  variant,
+  size,
+  radius,
+  color,
+  isSelected,
+  defaultSelected = false,
+  onSelectedChange,
+  isIndeterminate = false,
+  isInvalid = false,
+  isDisabled = false,
+  asChild = false,
+  accessibilityRole,
+  accessibilityState,
+  animation,
+  style,
+  onPress,
+  onPressIn,
+  onPressOut,
+  ...props
+}, ref) {
+  const theme = useXAUITheme();
+  const [styleProps, rest] = useStyleProps(props);
+  const [isPressed, press] = usePressState({ onPressIn, onPressOut });
+  const [selected, setSelected] = useControllableState({
+    value: isSelected,
+    defaultValue: defaultSelected,
+    onChange: onSelectedChange
+  });
+  const handlePress = useCallback(
+    (event) => {
+      setSelected((current) => isIndeterminate ? true : !current);
+      onPress?.(event);
+    },
+    [setSelected, isIndeterminate, onPress]
+  );
+  const selection = {
+    variant,
+    size,
+    radius,
+    isInvalid: isInvalid ? "true" : void 0
+  };
+  const states = { pressed: isPressed, disabled: isDisabled };
+  const styles = checkboxRecipe.resolve({ theme, selection, states });
+  const tint = color && !isInvalid ? checkboxRecipe.tint({ theme, color, selection, states }) : void 0;
+  const context = useMemo(
+    () => ({
+      // The tint never reaches the box **at rest**, only the two nodes that say the box
+      // is ticked. `paint` writes the resting fill from `bg` and the tint pass re-runs
+      // `paint`, so applying `tint.indicator` here would paint an unticked box in the
+      // caller's brand colour — which reads as ticked, which is the one thing it is not.
+      indicatorStyle: styles.indicator,
+      fillStyle: tint ? [styles.fill, tint.fill] : styles.fill,
+      checkStyle: tint ? [styles.check, tint.check] : styles.check,
+      dashStyle: tint ? [styles.dash, tint.dash] : styles.dash,
+      labelStyle: styles.label,
+      isSelected: selected,
+      isIndeterminate,
+      isDisabled,
+      isInvalid
+    }),
+    [styles, tint, selected, isIndeterminate, isDisabled, isInvalid]
+  );
+  const rootStyle = [
+    styles.root,
+    tint?.root,
+    styleProps,
+    typeof style === "function" ? style({ pressed: isPressed }) : style
+  ];
+  const text = childrenToString(children);
+  const content = text !== null ? /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx3(CheckboxIndicator, {}),
+    /* @__PURE__ */ jsx3(CheckboxLabel, { children: text })
+  ] }) : children ?? /* @__PURE__ */ jsx3(CheckboxIndicator, {});
+  return /* @__PURE__ */ jsx3(CheckboxProvider, { value: context, children: /* @__PURE__ */ jsx3(
+    PressableFeedback,
+    {
+      ref,
+      isPressed,
+      isDisabled,
+      asChild,
+      animation,
+      accessibilityRole: accessibilityRole ?? "checkbox",
+      accessibilityState: {
+        // `'mixed'` is the platform's own word for the third state, and it is the only
+        // thing that tells a screen reader this box speaks for rows it cannot see.
+        checked: isIndeterminate ? "mixed" : selected,
+        disabled: isDisabled,
+        ...accessibilityState
+      },
+      "aria-invalid": isInvalid,
+      ...rest,
+      style: rootStyle,
+      onPress: handlePress,
+      onPressIn: press.onPressIn,
+      onPressOut: press.onPressOut,
+      children: asChild ? children : content
+    }
+  ) });
+});
+CheckboxRoot.displayName = "XAUI.Checkbox.Root";
+
+// src/components/checkbox/index.ts
+var Checkbox2 = Object.assign(CheckboxRoot, {
+  Indicator: CheckboxIndicator,
+  Label: CheckboxLabel
+});
+
+export {
+  useCheckbox,
+  CheckboxIndicator,
+  CheckboxLabel,
+  checkboxRecipe,
+  CheckboxRoot,
+  Checkbox2 as Checkbox
+};

package/dist/chunk-ODQHAPQW.js

@@ -0,0 +1,351 @@
+import { EMPTY_RANGE, RangeCalendar } from "./chunk-P7OHZCU3.js";
+import { BottomSheet2 as BottomSheet } from "./chunk-LECYGVIH.js";
+import { selectRecipe } from "./chunk-E4FWGZH2.js";
+import { INDICATOR_ROTATION, INDICATOR_SPRING } from "./chunk-64MXEVT3.js";
+import { useControllableState } from "./chunk-F6W3JQ7K.js";
+import { PressableFeedback } from "./chunk-2AFA5HA2.js";
+import { usePressState } from "./chunk-423RQBOX.js";
+import { ChevronDownIcon, Icon, IconContext } from "./chunk-JN6IRT2M.js";
+import { createSlotContext } from "./chunk-TTZOIXKE.js";
+import { useXAUITheme } from "./chunk-Z6JBWRPL.js";
+import { useStyleProps } from "./chunk-M63GFNKV.js";
+
+// src/components/date-range-picker/date-range-picker.tsx
+import { useCallback, useMemo } from "react";
+import { StyleSheet } from "react-native";
+
+// src/components/date-range-picker/date-range-picker.context.ts
+var [DateRangePickerProvider, useDateRangePicker] = createSlotContext("DateRangePicker");
+
+// src/components/date-range-picker/date-range-picker.tsx
+import { jsx } from "react/jsx-runtime";
+var DEFAULT_FORMAT = {
+  dateStyle: "medium"
+};
+var DEFAULT_SEPARATOR = " \u2013 ";
+function DateRangePicker({
+  children,
+  variant,
+  size = "md",
+  radius,
+  color,
+  calendarVariant,
+  value: controlledValue,
+  defaultValue,
+  onValueChange,
+  isOpen: controlledOpen,
+  defaultOpen = false,
+  onOpenChange,
+  minValue,
+  maxValue,
+  firstDayOfWeek,
+  locale,
+  formatOptions = DEFAULT_FORMAT,
+  separator = DEFAULT_SEPARATOR,
+  closeOnSelect = true,
+  isDisabled = false,
+  isInvalid = false
+}) {
+  const theme = useXAUITheme();
+  const [value, setValue] = useControllableState({
+    value: controlledValue,
+    defaultValue: defaultValue ?? EMPTY_RANGE,
+    onChange: onValueChange
+  });
+  const [isOpen, setOpen] = useControllableState({
+    value: controlledOpen,
+    defaultValue: defaultOpen,
+    onChange: onOpenChange
+  });
+  const selection = {
+    variant,
+    size,
+    radius,
+    isOpen: isOpen ? "true" : void 0,
+    isInvalid: isInvalid ? "true" : void 0
+  };
+  const field = selectRecipe.resolve({
+    theme,
+    selection,
+    states: {
+      disabled: isDisabled
+    }
+  });
+  const fieldPressed = selectRecipe.resolve({
+    theme,
+    selection,
+    states: {
+      pressed: true
+    }
+  });
+  const tint = color ? selectRecipe.tint({
+    theme,
+    color,
+    selection
+  }) : void 0;
+  const onPickRange = useCallback(next => {
+    setValue(next);
+    if (closeOnSelect && next.start !== null && next.end !== null) setOpen(false);
+  }, [closeOnSelect, setOpen, setValue]);
+  const toggle = useCallback(() => {
+    if (isDisabled) return;
+    setOpen(!isOpen);
+  }, [isDisabled, isOpen, setOpen]);
+  const text = useMemo(() => {
+    if (value.start === null) return void 0;
+    const format = new Intl.DateTimeFormat(locale, formatOptions);
+    const start = format.format(value.start);
+    return value.end === null ? start : `${start}${separator}${format.format(value.end)}`;
+  }, [value, locale, formatOptions, separator]);
+  const glyph = useMemo(() => {
+    const flat = StyleSheet.flatten([field.indicator, tint?.indicator]);
+    return {
+      size: flat.fontSize,
+      color: typeof flat.color === "string" ? flat.color : void 0
+    };
+  }, [field.indicator, tint]);
+  const context = useMemo(() => ({
+    triggerStyle: [field.trigger, tint?.trigger],
+    triggerPressedStyle: fieldPressed.trigger,
+    valueStyle: [field.value, tint?.value],
+    placeholderStyle: tint ? [field.placeholder, {
+      color: StyleSheet.flatten([tint.value]).color
+    }] : field.placeholder,
+    indicatorStyle: field.indicator,
+    glyph,
+    value,
+    text,
+    onPickRange,
+    calendar: {
+      variant: calendarVariant,
+      size,
+      color,
+      minValue,
+      maxValue,
+      firstDayOfWeek,
+      locale
+    },
+    isOpen,
+    setOpen,
+    toggle,
+    isDisabled,
+    isInvalid
+  }), [field, fieldPressed, tint, glyph, value, text, onPickRange, calendarVariant, size, color, minValue, maxValue, firstDayOfWeek, locale, isOpen, setOpen, toggle, isDisabled, isInvalid]);
+  return /* @__PURE__ */jsx(DateRangePickerProvider, {
+    value: context,
+    children
+  });
+}
+DateRangePicker.displayName = "XAUI.DateRangePicker.Root";
+
+// src/components/date-range-picker/date-range-picker-sheet.tsx
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+function DateRangePickerSheet({
+  children,
+  previousLabel,
+  nextLabel,
+  ...props
+}) {
+  const picker = useDateRangePicker();
+  return /* @__PURE__ */jsxs(BottomSheet, {
+    isOpen: picker.isOpen,
+    onOpenChange: picker.setOpen,
+    ...props,
+    children: [/* @__PURE__ */jsx2(BottomSheet.Overlay, {}), /* @__PURE__ */jsx2(BottomSheet.Content, {
+      children: /* @__PURE__ */jsx2(DateRangePickerProvider, {
+        value: picker,
+        children: children ?? /* @__PURE__ */jsxs(Fragment, {
+          children: [/* @__PURE__ */jsx2(BottomSheet.Handle, {}), /* @__PURE__ */jsx2(DateRangePickerCalendar, {
+            previousLabel,
+            nextLabel
+          })]
+        })
+      })
+    })]
+  });
+}
+DateRangePickerSheet.displayName = "XAUI.DateRangePicker.Sheet";
+function DateRangePickerCalendar({
+  previousLabel,
+  nextLabel,
+  ...props
+}) {
+  const {
+    value,
+    onPickRange,
+    calendar
+  } = useDateRangePicker();
+  return /* @__PURE__ */jsxs(RangeCalendar, {
+    variant: calendar.variant,
+    size: calendar.size,
+    color: calendar.color,
+    locale: calendar.locale,
+    minValue: calendar.minValue,
+    maxValue: calendar.maxValue,
+    firstDayOfWeek: calendar.firstDayOfWeek,
+    value,
+    onValueChange: onPickRange,
+    ...props,
+    children: [/* @__PURE__ */jsxs(RangeCalendar.Header, {
+      children: [/* @__PURE__ */jsx2(RangeCalendar.PreviousButton, {
+        accessibilityLabel: previousLabel
+      }), /* @__PURE__ */jsx2(RangeCalendar.Title, {}), /* @__PURE__ */jsx2(RangeCalendar.NextButton, {
+        accessibilityLabel: nextLabel
+      })]
+    }), /* @__PURE__ */jsx2(RangeCalendar.Weekdays, {}), /* @__PURE__ */jsx2(RangeCalendar.Grid, {})]
+  });
+}
+DateRangePickerCalendar.displayName = "XAUI.DateRangePicker.Calendar";
+
+// src/components/date-range-picker/date-range-picker-indicator.tsx
+import { useEffect } from "react";
+import Animated, { interpolate, useAnimatedStyle, useSharedValue, withSpring } from "react-native-reanimated";
+import { jsx as jsx3 } from "react/jsx-runtime";
+const _worklet_16418829714549_init_data = {
+  code: "function chunkODQHAPQWJs1(){const{interpolate,progress,INDICATOR_ROTATION}=this.__closure;return{transform:[{rotate:interpolate(progress.get(),[0,1],[INDICATOR_ROTATION[0],INDICATOR_ROTATION[1]])+\"deg\"}]};}",
+  location: "/home/runner/work/xaui/xaui/packages/native/dist/chunk-ODQHAPQW.js",
+  sourceMap: "{\"version\":3,\"names\":[\"chunkODQHAPQWJs1\",\"interpolate\",\"progress\",\"INDICATOR_ROTATION\",\"__closure\",\"transform\",\"rotate\",\"get\"],\"sources\":[\"/home/runner/work/xaui/xaui/packages/native/dist/chunk-ODQHAPQW.js\"],\"mappings\":\"AA6PoC,SAAAA,iBAAA,QAAAC,WAAA,CAAAC,QAAA,CAAAC,kBAAA,OAAAC,SAAA,OAAO,CACvCC,SAAS,CAAE,CACT,CACEC,MAAM,CAAKL,WAAW,CAACC,QAAQ,CAACK,GAAG,CAAC,CAAC,CAAE,CAAC,CAAC,CAAE,CAAC,CAAC,CAAE,CAACJ,kBAAkB,CAAC,CAAC,CAAC,CAAEA,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,MAChG,CAAC,CAEL,CAAC\",\"ignoreList\":[]}"
+};
+function DateRangePickerIndicator(props) {
+  const {
+    as = ChevronDownIcon
+  } = props;
+  const {
+    indicatorStyle,
+    isOpen
+  } = useDateRangePicker();
+  const progress = useSharedValue(isOpen ? 1 : 0);
+  useEffect(() => {
+    progress.set(withSpring(isOpen ? 1 : 0, INDICATOR_SPRING));
+  }, [isOpen, progress]);
+  const rotation = useAnimatedStyle(function chunkODQHAPQWJs1Factory({
+    _worklet_16418829714549_init_data,
+    interpolate,
+    progress,
+    INDICATOR_ROTATION
+  }) {
+    const _e = [new global.Error(), -4, -27];
+    const chunkODQHAPQWJs1 = () => ({
+      transform: [{
+        rotate: `${interpolate(progress.get(), [0, 1], [INDICATOR_ROTATION[0], INDICATOR_ROTATION[1]])}deg`
+      }]
+    });
+    chunkODQHAPQWJs1.__closure = {
+      interpolate,
+      progress,
+      INDICATOR_ROTATION
+    };
+    chunkODQHAPQWJs1.__workletHash = 16418829714549;
+    chunkODQHAPQWJs1.__pluginVersion = "0.7.4";
+    chunkODQHAPQWJs1.__initData = _worklet_16418829714549_init_data;
+    chunkODQHAPQWJs1.__stackDetails = _e;
+    return chunkODQHAPQWJs1;
+  }({
+    _worklet_16418829714549_init_data,
+    interpolate,
+    progress,
+    INDICATOR_ROTATION
+  }));
+  return /* @__PURE__ */jsx3(Animated.View, {
+    style: [indicatorStyle, rotation],
+    children: /* @__PURE__ */jsx3(Icon, {
+      as
+    })
+  });
+}
+DateRangePickerIndicator.displayName = "XAUI.DateRangePicker.Indicator";
+
+// src/components/date-range-picker/date-range-picker-trigger.tsx
+import { forwardRef } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var DateRangePickerTrigger = forwardRef(function DateRangePickerTrigger2({
+  children,
+  asChild = false,
+  accessibilityRole = "button",
+  accessibilityState,
+  style,
+  onPressIn,
+  onPressOut,
+  onPress,
+  ...props
+}, ref) {
+  const {
+    triggerStyle,
+    triggerPressedStyle,
+    glyph,
+    isOpen,
+    isDisabled,
+    isInvalid,
+    toggle
+  } = useDateRangePicker();
+  const [styleProps, rest] = useStyleProps(props);
+  const [isPressed, press] = usePressState({
+    onPressIn,
+    onPressOut
+  });
+  return /* @__PURE__ */jsx4(IconContext.Provider, {
+    value: glyph,
+    children: /* @__PURE__ */jsx4(PressableFeedback, {
+      ref,
+      isPressed,
+      asChild,
+      accessibilityRole,
+      accessibilityState: {
+        expanded: isOpen,
+        disabled: isDisabled,
+        ...accessibilityState
+      },
+      "aria-invalid": isInvalid || void 0,
+      isDisabled,
+      ...rest,
+      style: [isPressed ? triggerPressedStyle : triggerStyle, styleProps, typeof style === "function" ? style({
+        pressed: isPressed
+      }) : style],
+      onPress: event => {
+        onPress?.(event);
+        toggle();
+      },
+      onPressIn: press.onPressIn,
+      onPressOut: press.onPressOut,
+      children
+    })
+  });
+});
+DateRangePickerTrigger.displayName = "XAUI.DateRangePicker.Trigger";
+
+// src/components/date-range-picker/date-range-picker-value.tsx
+import { forwardRef as forwardRef2 } from "react";
+import { Text } from "react-native";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var DateRangePickerValue = forwardRef2(function DateRangePickerValue2({
+  children,
+  placeholder,
+  style,
+  ...props
+}, ref) {
+  const {
+    text,
+    valueStyle,
+    placeholderStyle
+  } = useDateRangePicker();
+  const [styleProps, rest] = useStyleProps(props);
+  const isEmpty = children === void 0 && text === void 0;
+  return /* @__PURE__ */jsx5(Text, {
+    ref,
+    numberOfLines: 1,
+    ...rest,
+    style: [isEmpty ? placeholderStyle : valueStyle, styleProps, style],
+    children: children ?? text ?? placeholder
+  });
+});
+DateRangePickerValue.displayName = "XAUI.DateRangePicker.Value";
+
+// src/components/date-range-picker/index.ts
+var DateRangePicker2 = Object.assign(DateRangePicker, {
+  Trigger: DateRangePickerTrigger,
+  Value: DateRangePickerValue,
+  Indicator: DateRangePickerIndicator,
+  Sheet: DateRangePickerSheet,
+  Calendar: DateRangePickerCalendar
+});
+export { useDateRangePicker, DateRangePicker, DateRangePickerSheet, DateRangePickerCalendar, DateRangePickerIndicator, DateRangePickerTrigger, DateRangePickerValue, DateRangePicker2 };

package/dist/chunk-OE5T7LJQ.cjs

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/check-glyph.ts
+var CHECK_SPAN = 0.5;
+var CHECK_RISE = 0.25;
+function checkGlyph(side, stroke) {
+  const rise = side * CHECK_RISE;
+  return {
+    width: side * CHECK_SPAN,
+    height: rise,
+    borderStartWidth: stroke,
+    borderBottomWidth: stroke,
+    transform: [
+      { translateY: -((rise - stroke) * Math.SQRT2) / 4 },
+      { rotate: "-45deg" }
+    ]
+  };
+}
+
+
+
+
+exports.CHECK_SPAN = CHECK_SPAN; exports.checkGlyph = checkGlyph;