blimpui 0.0.1

package/dist/$/components/primitives/toggle.js

@@ -0,0 +1,63 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Icon } from "../../../$/components/primitives/icon";
+import { TextClassContext } from "../../../$/components/primitives/text";
+import { cn } from "../../../$/lib/utils";
+import * as TogglePrimitive from "@rn-primitives/toggle";
+import { cva } from "class-variance-authority";
+import * as React from "react";
+import { Platform } from "react-native";
+var toggleVariants = cva(cn("active:bg-muted group flex flex-row items-center justify-center gap-2 rounded-md", Platform.select({
+    web: "hover:bg-muted hover:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive inline-flex cursor-default whitespace-nowrap outline-none transition-[color,box-shadow] focus-visible:ring-[3px] disabled:pointer-events-none [&_svg]:pointer-events-none",
+})), {
+    variants: {
+        variant: {
+            default: "bg-transparent",
+            outline: cn("border-input active:bg-accent border bg-transparent shadow-sm shadow-black/5", Platform.select({
+                web: "hover:bg-accent hover:text-accent-foreground",
+            })),
+        },
+        size: {
+            default: "h-10 min-w-10 px-2.5 sm:h-9 sm:min-w-9 sm:px-2",
+            sm: "h-9 min-w-9 px-2 sm:h-8 sm:min-w-8 sm:px-1.5",
+            lg: "h-11 min-w-11 px-3 sm:h-10 sm:min-w-10 sm:px-2.5",
+        },
+    },
+    defaultVariants: {
+        variant: "default",
+        size: "default",
+    },
+});
+function Toggle(_a) {
+    var className = _a.className, variant = _a.variant, size = _a.size, props = __rest(_a, ["className", "variant", "size"]);
+    return (_jsx(TextClassContext.Provider, { value: cn("text-sm text-foreground font-medium", props.pressed
+            ? "text-accent-foreground"
+            : Platform.select({ web: "group-hover:text-muted-foreground" }), className), children: _jsx(TogglePrimitive.Root, __assign({ className: cn(toggleVariants({ variant: variant, size: size }), props.disabled && "opacity-50", props.pressed && "bg-accent", className) }, props)) }));
+}
+function ToggleIcon(_a) {
+    var className = _a.className, props = __rest(_a, ["className"]);
+    var textClass = React.useContext(TextClassContext);
+    return (_jsx(Icon, __assign({ className: cn("size-4 shrink-0", textClass, className) }, props)));
+}
+export { Toggle, ToggleIcon, toggleVariants };

package/dist/$/components/primitives/tooltip.d.ts

@@ -0,0 +1,21 @@
+import * as TooltipPrimitive from "@rn-primitives/tooltip";
+import * as React from "react";
+declare const Tooltip: React.ForwardRefExoticComponent<import("react-native").ViewProps & {
+    asChild?: boolean;
+} & {
+    onOpenChange?: (open: boolean) => void;
+    delayDuration?: number;
+    skipDelayDuration?: number;
+    disableHoverableContent?: boolean;
+} & React.RefAttributes<import("react-native").View>>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<Omit<import("react-native").PressableProps & React.RefAttributes<import("react-native").View>, "ref"> & {
+    asChild?: boolean;
+} & {
+    onKeyDown?: (ev: React.KeyboardEvent) => void;
+    onKeyUp?: (ev: React.KeyboardEvent) => void;
+} & React.RefAttributes<import("@rn-primitives/tooltip").TriggerRef>>;
+declare function TooltipContent({ className, sideOffset, portalHost, side, ...props }: TooltipPrimitive.ContentProps & React.RefAttributes<TooltipPrimitive.ContentRef> & {
+    portalHost?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipContent, TooltipTrigger };
+//# sourceMappingURL=tooltip.d.ts.map

package/dist/$/components/primitives/tooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../../../$/components/primitives/tooltip.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,gBAAgB,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,QAAA,MAAM,OAAO;;;;;;;qDAAwB,CAAC;AAEtC,QAAA,MAAM,cAAc;;;;;qEAA2B,CAAC;AAKhD,iBAAS,cAAc,CAAC,EACvB,SAAS,EACT,UAAc,EACd,UAAU,EACV,IAAY,EACZ,GAAG,KAAK,EACR,EAAE,gBAAgB,CAAC,YAAY,GAC/B,KAAK,CAAC,aAAa,CAAC,gBAAgB,CAAC,UAAU,CAAC,GAAG;IAClD,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB,2CA4CD;AAED,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC"}

package/dist/$/components/primitives/tooltip.js

@@ -0,0 +1,47 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { NativeOnlyAnimatedView } from "../../../$/components/primitives/native-only-animated-view";
+import { TextClassContext } from "../../../$/components/primitives/text";
+import { cn } from "../../../$/lib/utils";
+import * as TooltipPrimitive from "@rn-primitives/tooltip";
+import * as React from "react";
+import { Platform, StyleSheet } from "react-native";
+import { FadeInDown, FadeInUp, FadeOut } from "react-native-reanimated";
+import { FullWindowOverlay as RNFullWindowOverlay } from "react-native-screens";
+var Tooltip = TooltipPrimitive.Root;
+var TooltipTrigger = TooltipPrimitive.Trigger;
+var FullWindowOverlay = Platform.OS === "ios" ? RNFullWindowOverlay : React.Fragment;
+function TooltipContent(_a) {
+    var className = _a.className, _b = _a.sideOffset, sideOffset = _b === void 0 ? 4 : _b, portalHost = _a.portalHost, _c = _a.side, side = _c === void 0 ? "top" : _c, props = __rest(_a, ["className", "sideOffset", "portalHost", "side"]);
+    return (_jsx(TooltipPrimitive.Portal, { hostName: portalHost, children: _jsx(FullWindowOverlay, { children: _jsx(TooltipPrimitive.Overlay, { style: Platform.select({ native: StyleSheet.absoluteFill }), children: _jsx(NativeOnlyAnimatedView, { entering: side === "top"
+                        ? FadeInDown.withInitialValues({
+                            transform: [{ translateY: 3 }],
+                        }).duration(150)
+                        : FadeInUp.withInitialValues({
+                            transform: [{ translateY: -5 }],
+                        }), exiting: FadeOut, children: _jsx(TextClassContext.Provider, { value: "text-xs text-primary-foreground", children: _jsx(TooltipPrimitive.Content, __assign({ sideOffset: sideOffset, className: cn("bg-primary z-50 rounded-md px-3 py-2 sm:py-1.5", Platform.select({
+                                web: cn("animate-in fade-in-0 zoom-in-95 origin-(--radix-tooltip-content-transform-origin) w-fit text-balance", side === "bottom" && "slide-in-from-top-2", side === "left" && "slide-in-from-right-2", side === "right" && "slide-in-from-left-2", side === "top" && "slide-in-from-bottom-2"),
+                            }), className), side: side }, props)) }) }) }) }) }));
+}
+export { Tooltip, TooltipContent, TooltipTrigger };

package/dist/$/components/primitives/view.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import { View as RNView } from "react-native";
+export type ViewProps = React.ComponentPropsWithoutRef<typeof RNView> & {
+    className?: string;
+    asChild?: boolean;
+    children?: React.ReactNode;
+};
+export type View = React.ComponentRef<typeof RNView>;
+declare const View: React.ForwardRefExoticComponent<import("react-native").ViewProps & {
+    className?: string;
+    asChild?: boolean;
+    children?: React.ReactNode;
+} & React.RefAttributes<RNView>>;
+export { View };
+//# sourceMappingURL=view.d.ts.map

package/dist/$/components/primitives/view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../../../$/components/primitives/view.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,IAAI,IAAI,MAAM,EAAE,MAAM,cAAc,CAAC;AAM9C,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC,wBAAwB,CAAC,OAAO,MAAM,CAAC,GAAG;IACvE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAAC;AACF,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC,YAAY,CAAC,OAAO,MAAM,CAAC,CAAC;AAWrD,QAAA,MAAM,IAAI;gBAfG,MAAM;cACR,OAAO;eACN,KAAK,CAAC,SAAS;gCAwB1B,CAAC;AAGF,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/dist/$/components/primitives/view.js

@@ -0,0 +1,37 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { View as RNView } from "react-native";
+import { TextClassContext } from "./text";
+import { renderNode } from "../../lib/utils/renderNode";
+import { useExtractTextClasses } from "../../lib/hooks/useExtractTextClasses";
+import { cn } from "../../../$/lib/utils";
+var BaseView = RNView;
+var View = React.forwardRef(function (_a, ref) {
+    var className = _a.className, children = _a.children, rest = __rest(_a, ["className", "children"]);
+    var parent = useExtractTextClasses(className);
+    return (_jsx(TextClassContext.Provider, { value: parent, children: _jsx(BaseView, __assign({ ref: ref, className: cn(className) }, rest, { children: renderNode(children) })) }));
+});
+View.displayName = "View";
+export { View };

package/dist/$/components/primitives/wheelpicker/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./wheelpicker";
+export * from "./types";
+export * from "./use-wheel-picker-value";
+//# sourceMappingURL=index.d.ts.map

package/dist/$/components/primitives/wheelpicker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../$/components/primitives/wheelpicker/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,0BAA0B,CAAC"}

package/dist/$/components/primitives/wheelpicker/index.js

@@ -0,0 +1,3 @@
+export * from "./wheelpicker";
+export * from "./types";
+export * from "./use-wheel-picker-value";

package/dist/$/components/primitives/wheelpicker/types.d.ts

@@ -0,0 +1,7 @@
+type WheelPickerItem<TValue> = {
+    label: string;
+    value: TValue;
+    disabled?: boolean;
+};
+export type { WheelPickerItem };
+//# sourceMappingURL=types.d.ts.map

package/dist/$/components/primitives/wheelpicker/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../$/components/primitives/wheelpicker/types.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,CAAC,MAAM,IAAI;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,YAAY,EAAE,eAAe,EAAE,CAAC"}

package/dist/$/components/primitives/wheelpicker/types.js

@@ -0,0 +1 @@
+export {};

package/dist/$/components/primitives/wheelpicker/use-wheel-picker-value.d.ts

@@ -0,0 +1,16 @@
+import type { WheelPickerItem } from "./types";
+type UseWheelPickerValueOptions<TValue> = {
+    items: Array<WheelPickerItem<TValue>>;
+    value?: TValue;
+    defaultValue?: TValue;
+    onValueChange?: (value: TValue, index: number) => void;
+};
+declare function clampIndex(index: number, length: number): number;
+declare function valueIndexOf<TValue>(items: Array<WheelPickerItem<TValue>>, value: TValue): number;
+declare function useWheelPickerValue<TValue>({ items, value, defaultValue, onValueChange, }: UseWheelPickerValueOptions<TValue>): {
+    selectedIndex: number;
+    handleIndexChange: (nextIndex: number, userInitiated: boolean) => void;
+};
+export { clampIndex, useWheelPickerValue, valueIndexOf };
+export type { UseWheelPickerValueOptions };
+//# sourceMappingURL=use-wheel-picker-value.d.ts.map

package/dist/$/components/primitives/wheelpicker/use-wheel-picker-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-wheel-picker-value.d.ts","sourceRoot":"","sources":["../../../../../$/components/primitives/wheelpicker/use-wheel-picker-value.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,KAAK,0BAA0B,CAAC,MAAM,IAAI;IACzC,KAAK,EAAE,KAAK,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACvD,CAAC;AAEF,iBAAS,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAGhD;AAED,iBAAS,YAAY,CAAC,MAAM,EAC3B,KAAK,EAAE,KAAK,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,EACrC,KAAK,EAAE,MAAM,UAGb;AAED,iBAAS,mBAAmB,CAAC,MAAM,EAAE,EACpC,KAAK,EACL,KAAK,EACL,YAAY,EACZ,aAAa,GACb,EAAE,0BAA0B,CAAC,MAAM,CAAC;;mCAqBvB,MAAM,iBAAiB,OAAO;EAgB3C;AAED,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,YAAY,EAAE,CAAC;AACzD,YAAY,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/$/components/primitives/wheelpicker/use-wheel-picker-value.js

@@ -0,0 +1,43 @@
+import * as React from "react";
+function clampIndex(index, length) {
+    if (length <= 0)
+        return 0;
+    return Math.max(0, Math.min(length - 1, index));
+}
+function valueIndexOf(items, value) {
+    return items.findIndex(function (i) { return Object.is(i.value, value); });
+}
+function useWheelPickerValue(_a) {
+    var items = _a.items, value = _a.value, defaultValue = _a.defaultValue, onValueChange = _a.onValueChange;
+    var lastEmittedIndexRef = React.useRef(null);
+    var isControlled = value !== undefined;
+    var initialIndex = React.useMemo(function () {
+        if (isControlled) {
+            return clampIndex(valueIndexOf(items, value), items.length);
+        }
+        if (defaultValue !== undefined) {
+            return clampIndex(valueIndexOf(items, defaultValue), items.length);
+        }
+        return 0;
+    }, [defaultValue, isControlled, items, value]);
+    var _b = React.useState(initialIndex), uncontrolledIndex = _b[0], setUncontrolledIndex = _b[1];
+    var selectedIndex = isControlled
+        ? clampIndex(valueIndexOf(items, value), items.length)
+        : clampIndex(uncontrolledIndex, items.length);
+    var handleIndexChange = React.useCallback(function (nextIndex, userInitiated) {
+        var clamped = clampIndex(nextIndex, items.length);
+        if (lastEmittedIndexRef.current === clamped)
+            return;
+        if (!isControlled)
+            setUncontrolledIndex(clamped);
+        lastEmittedIndexRef.current = clamped;
+        var next = items[clamped];
+        if (next && onValueChange)
+            onValueChange(next.value, clamped);
+    }, [isControlled, items, onValueChange]);
+    return {
+        selectedIndex: selectedIndex,
+        handleIndexChange: handleIndexChange,
+    };
+}
+export { clampIndex, useWheelPickerValue, valueIndexOf };

package/dist/$/components/primitives/wheelpicker/wheel-picker-item.d.ts

@@ -0,0 +1,11 @@
+import type { WheelPickerItem } from "./types";
+type WheelPickerItemData<TValue> = WheelPickerItem<TValue>;
+type WheelPickerItemProps<TValue> = {
+    item: WheelPickerItemData<TValue>;
+    index: number;
+    itemHeight: number;
+    onPress: (index: number) => void;
+};
+export declare function WheelPickerItem<TValue>({ item, index, itemHeight, onPress, }: WheelPickerItemProps<TValue>): import("react/jsx-runtime").JSX.Element;
+export type { WheelPickerItemData, WheelPickerItemProps };
+//# sourceMappingURL=wheel-picker-item.d.ts.map

package/dist/$/components/primitives/wheelpicker/wheel-picker-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wheel-picker-item.d.ts","sourceRoot":"","sources":["../../../../../$/components/primitives/wheelpicker/wheel-picker-item.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,KAAK,mBAAmB,CAAC,MAAM,IAAI,eAAe,CAAC,MAAM,CAAC,CAAC;AAE3D,KAAK,oBAAoB,CAAC,MAAM,IAAI;IACnC,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,CAAC;AAEF,wBAAgB,eAAe,CAAC,MAAM,EAAE,EACvC,IAAI,EACJ,KAAK,EACL,UAAU,EACV,OAAO,GACP,EAAE,oBAAoB,CAAC,MAAM,CAAC,2CAmB9B;AAED,YAAY,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/$/components/primitives/wheelpicker/wheel-picker-item.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Pressable } from "react-native";
+import { Text } from "../../../../$/components/primitives/text";
+import { cn } from "../../../../$/lib/utils";
+export function WheelPickerItem(_a) {
+    var item = _a.item, index = _a.index, itemHeight = _a.itemHeight, onPress = _a.onPress;
+    return (_jsx(Pressable, { disabled: item.disabled, className: cn("flex-row items-center justify-center  ", item.disabled && "opacity-50"), style: { height: itemHeight }, onPress: function () { return onPress(index); }, children: _jsx(Text, { className: cn("text-base text-foreground select-none"), selectable: false, children: item.label }) }));
+}

package/dist/$/components/primitives/wheelpicker/wheel-picker-list.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import { type WheelPickerItemData } from "./wheel-picker-item";
+type WheelPickerListProps<TValue> = {
+    items: Array<WheelPickerItemData<TValue>>;
+    selectedIndex: number;
+    onIndexChange: (index: number, userInitiated: boolean) => void;
+    itemHeight: number;
+    visibleItems: number;
+    hapticFeedback: boolean;
+    className?: string;
+    overlayBgColorClassName?: string;
+};
+declare const WheelPickerList: React.ForwardRefExoticComponent<WheelPickerListProps<any> & React.RefAttributes<{
+    scrollToIndex: (index: number, animated: boolean) => void;
+}>>;
+export { WheelPickerList };
+export type { WheelPickerListProps, WheelPickerItemData };
+//# sourceMappingURL=wheel-picker-list.d.ts.map

package/dist/$/components/primitives/wheelpicker/wheel-picker-list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wheel-picker-list.d.ts","sourceRoot":"","sources":["../../../../../$/components/primitives/wheelpicker/wheel-picker-list.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,OAAO,EAAmB,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAoDhF,KAAK,oBAAoB,CAAC,MAAM,IAAI;IACnC,KAAK,EAAE,KAAK,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uBAAuB,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,QAAA,MAAM,eAAe;mBACH,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI;GAiS3D,CAAC;AAIF,OAAO,EAAE,eAAe,EAAE,CAAC;AAC3B,YAAY,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/$/components/primitives/wheelpicker/wheel-picker-list.js

@@ -0,0 +1,253 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { Platform, View } from "react-native";
+import { List } from "../../../../$/components/primitives/list";
+import { WheelPickerItem } from "./wheel-picker-item";
+import { cn } from "../../../../$/lib/utils";
+import { clampIndex } from "./use-wheel-picker-value";
+function getIndexFromOffset(offset, itemHeight, length) {
+    if (!Number.isFinite(offset) ||
+        !Number.isFinite(itemHeight) ||
+        itemHeight <= 0)
+        return 0;
+    return clampIndex(Math.round(offset / itemHeight), length);
+}
+function scrollToItem(listRef, actualIndex, itemHeight, animated, spacerCount, padding) {
+    var list = listRef.current;
+    if (!list)
+        return;
+    // Prefer scrollToIndex so the list can virtualize around the target index.
+    // (This avoids a blank window on native when jumping to large offsets.)
+    if (typeof list.scrollToIndex === "function") {
+        list.scrollToIndex({
+            index: actualIndex + spacerCount,
+            animated: animated,
+            viewPosition: 0,
+            // Align the item with the centered selection window.
+            viewOffset: padding,
+        });
+        return;
+    }
+    // Fallback: scrollToOffset.
+    if (typeof list.scrollToOffset === "function") {
+        list.scrollToOffset({
+            offset: actualIndex * itemHeight,
+            animated: animated,
+        });
+        return;
+    }
+}
+var WheelPickerList = React.forwardRef(function (_a, ref) {
+    var items = _a.items, selectedIndex = _a.selectedIndex, onIndexChange = _a.onIndexChange, itemHeight = _a.itemHeight, visibleItems = _a.visibleItems, hapticFeedback = _a.hapticFeedback, className = _a.className, overlayBgColorClassName = _a.overlayBgColorClassName;
+    var listRef = React.useRef(null);
+    var settleTimerRef = React.useRef(null);
+    var lastScrollOffsetRef = React.useRef(0);
+    var ignoreScrollEventsRef = React.useRef(false);
+    var momentumActiveRef = React.useRef(false);
+    var userInteractingRef = React.useRef(false);
+    var scrollHapticIndexRef = React.useRef(null);
+    var lastHapticAtRef = React.useRef(0);
+    var hapticsModuleRef = React.useRef(null);
+    var isWeb = Platform.OS === "web";
+    var safeVisible = Math.max(1, Math.floor(visibleItems));
+    var viewportHeight = safeVisible * itemHeight;
+    var padding = Math.max(0, (viewportHeight - itemHeight) / 2);
+    var spacerCount = Math.floor(safeVisible / 2);
+    var paddedItems = React.useMemo(function () {
+        var top = Array.from({ length: spacerCount }, function (_, i) { return ({ __type: "spacer", key: "__wheel_spacer_start_".concat(i) }); });
+        var bottom = Array.from({ length: spacerCount }, function (_, i) { return ({ __type: "spacer", key: "__wheel_spacer_end_".concat(i) }); });
+        var body = items.map(function (it) { return ({ __type: "item", data: it }); });
+        return __spreadArray(__spreadArray(__spreadArray([], top, true), body, true), bottom, true);
+    }, [items, spacerCount]);
+    React.useImperativeHandle(ref, function () { return ({
+        scrollToIndex: function (index, animated) {
+            ignoreScrollEventsRef.current = true;
+            scrollToItem(listRef, index, itemHeight, animated, spacerCount, padding);
+            setTimeout(function () {
+                ignoreScrollEventsRef.current = false;
+            }, animated ? 200 : 0);
+        },
+    }); });
+    var triggerHaptic = React.useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var now, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (!(!isWeb && hapticFeedback)) return [3 /*break*/, 6];
+                    now = Date.now();
+                    if (!(now - lastHapticAtRef.current >= 30)) return [3 /*break*/, 6];
+                    lastHapticAtRef.current = now;
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 5, , 6]);
+                    if (!!hapticsModuleRef.current) return [3 /*break*/, 3];
+                    _a = hapticsModuleRef;
+                    return [4 /*yield*/, import("expo-haptics")];
+                case 2:
+                    _a.current = _c.sent();
+                    _c.label = 3;
+                case 3: return [4 /*yield*/, hapticsModuleRef.current.selectionAsync()];
+                case 4:
+                    _c.sent();
+                    return [3 /*break*/, 6];
+                case 5:
+                    _b = _c.sent();
+                    return [3 /*break*/, 6];
+                case 6: return [2 /*return*/];
+            }
+        });
+    }); }, [hapticFeedback, isWeb]);
+    var commitIndex = React.useCallback(function (nextIndex, userInitiated) {
+        if (userInitiated) {
+            triggerHaptic();
+        }
+        onIndexChange(nextIndex, userInitiated);
+    }, [triggerHaptic, onIndexChange]);
+    var onScrollEnd = React.useCallback(function (e) {
+        var _a, _b;
+        var offsetY = (_b = (_a = e.nativeEvent.contentOffset) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : 0;
+        var nextIndex = getIndexFromOffset(offsetY, itemHeight, items.length);
+        if (ignoreScrollEventsRef.current)
+            return;
+        if (!userInteractingRef.current)
+            return;
+        // Only commit when the user actually interacted.
+        // This prevents initial layout/programmatic scroll syncing from emitting
+        // a value change (e.g. when opening an overlay).
+        commitIndex(nextIndex, true);
+    }, [commitIndex, itemHeight, items.length]);
+    var onScroll = React.useCallback(function (e) {
+        var _a, _b;
+        lastScrollOffsetRef.current = (_b = (_a = e.nativeEvent.contentOffset) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : 0;
+        if (ignoreScrollEventsRef.current)
+            return;
+        // LegendList on web doesn't reliably fire begin-drag events, so we treat
+        // the first post-mount scroll as user interaction.
+        if (isWeb && !userInteractingRef.current) {
+            userInteractingRef.current = true;
+        }
+        var nextIndex = getIndexFromOffset(lastScrollOffsetRef.current, itemHeight, items.length);
+        // While scrolling, provide haptic ticks on index changes (doesn't commit value).
+        if (userInteractingRef.current &&
+            hapticFeedback &&
+            !isWeb &&
+            scrollHapticIndexRef.current !== nextIndex) {
+            scrollHapticIndexRef.current = nextIndex;
+            triggerHaptic();
+        }
+        // Web: LegendList + CSS snap doesn't reliably fire momentum/end events.
+        // Debounce scroll and commit once it settles.
+        if (isWeb) {
+            // Avoid committing due to initial layout / programmatic scroll.
+            if (!userInteractingRef.current)
+                return;
+            if (settleTimerRef.current)
+                clearTimeout(settleTimerRef.current);
+            settleTimerRef.current = setTimeout(function () {
+                var idx = getIndexFromOffset(lastScrollOffsetRef.current, itemHeight, items.length);
+                commitIndex(idx, true);
+                userInteractingRef.current = false;
+            }, 120);
+        }
+    }, [commitIndex, hapticFeedback, isWeb, itemHeight, items.length]);
+    React.useEffect(function () {
+        // Keep the scroll position aligned with the controlled selectedIndex.
+        // Run after mount/prop changes even if scroll events are initially ignored.
+        var t = setTimeout(function () {
+            if (userInteractingRef.current || momentumActiveRef.current)
+                return;
+            ignoreScrollEventsRef.current = true;
+            scrollToItem(listRef, selectedIndex, itemHeight, false, spacerCount, padding);
+            setTimeout(function () {
+                ignoreScrollEventsRef.current = false;
+            }, 0);
+        }, 0);
+        return function () { return clearTimeout(t); };
+    }, [itemHeight, padding, selectedIndex, spacerCount]);
+    var onPressItem = React.useCallback(function (actualIndex) {
+        userInteractingRef.current = true;
+        scrollToItem(listRef, actualIndex, itemHeight, false, spacerCount, padding);
+        commitIndex(actualIndex, true);
+        setTimeout(function () {
+            userInteractingRef.current = false;
+        }, 0);
+    }, [commitIndex, itemHeight, padding, spacerCount]);
+    var renderItem = React.useCallback(function (_a) {
+        var item = _a.item, index = _a.index;
+        if (item.__type === "spacer") {
+            return _jsx(View, { pointerEvents: "none", style: { height: itemHeight } });
+        }
+        var actualIndex = index - spacerCount;
+        return (_jsx(WheelPickerItem, { item: item.data, index: actualIndex, itemHeight: itemHeight, onPress: onPressItem }));
+    }, [itemHeight, onPressItem, spacerCount]);
+    return (_jsxs(View, { className: cn("relative overflow-hidden", className), style: { height: viewportHeight }, children: [_jsx(View, { pointerEvents: "none", className: "bg-foreground/5 absolute left-0 right-0 rounded-md z-50", style: { top: padding, height: itemHeight } }), _jsx(View, { pointerEvents: "none", className: cn("bg-background/50 absolute left-0 top-0 w-full z-50", overlayBgColorClassName), style: { height: itemHeight * (safeVisible / 2.5) } }), _jsx(View, { pointerEvents: "none", className: cn("bg-background/50 absolute left-0 bottom-0 w-full z-50", overlayBgColorClassName), style: { height: itemHeight * (safeVisible / 2.5) } }), _jsx(List, { ref: listRef, data: paddedItems, renderItem: renderItem, keyExtractor: function (item) {
+                    return item.__type === "spacer" ? item.key : String(item.data.value);
+                }, initialScrollIndex: {
+                    index: selectedIndex,
+                }, estimatedListSize: { height: viewportHeight, width: 1 }, recycleItems: true, snapToInterval: itemHeight, decelerationRate: 0.7, showsVerticalScrollIndicator: Platform.OS === "web" ? true : false, contentContainerStyle: undefined, extraData: {
+                    selectedIndex: selectedIndex,
+                }, scrollEventThrottle: 16, onScroll: onScroll, onScrollBeginDrag: function () {
+                    userInteractingRef.current = true;
+                    scrollHapticIndexRef.current = null;
+                }, onMomentumScrollBegin: function () {
+                    momentumActiveRef.current = true;
+                }, onMomentumScrollEnd: function (e) {
+                    momentumActiveRef.current = false;
+                    onScrollEnd(e);
+                    userInteractingRef.current = false;
+                }, onScrollEndDrag: function (e) {
+                    if (Platform.OS !== "web")
+                        return;
+                    if (!momentumActiveRef.current) {
+                        onScrollEnd(e);
+                        userInteractingRef.current = false;
+                    }
+                }, estimatedItemSize: itemHeight })] }));
+});
+WheelPickerList.displayName = "WheelPickerList";
+export { WheelPickerList };

package/dist/$/components/primitives/wheelpicker/wheelpicker.d.ts

@@ -0,0 +1,17 @@
+import type { WheelPickerItem } from "./types";
+type WheelPickerProps<TValue> = {
+    items: Array<WheelPickerItem<TValue>>;
+    value?: TValue;
+    defaultValue?: TValue;
+    onValueChange?: (value: TValue, index: number) => void;
+    itemHeight?: number;
+    visibleItems?: number;
+    /** Enable iOS-style selection ticks while scrolling (uses expo-haptics when available). */
+    hapticFeedback?: boolean;
+    className?: string;
+    overlayBgColorClassName?: string;
+};
+declare function WheelPicker<TValue>({ items, value, defaultValue, onValueChange, itemHeight, visibleItems, hapticFeedback, className, overlayBgColorClassName, }: WheelPickerProps<TValue>): import("react/jsx-runtime").JSX.Element;
+export { WheelPicker };
+export type { WheelPickerItem, WheelPickerProps };
+//# sourceMappingURL=wheelpicker.d.ts.map

package/dist/$/components/primitives/wheelpicker/wheelpicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wheelpicker.d.ts","sourceRoot":"","sources":["../../../../../$/components/primitives/wheelpicker/wheelpicker.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,KAAK,gBAAgB,CAAC,MAAM,IAAI;IAC/B,KAAK,EAAE,KAAK,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2FAA2F;IAC3F,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uBAAuB,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,iBAAS,WAAW,CAAC,MAAM,EAAE,EAC5B,KAAK,EACL,KAAK,EACL,YAAY,EACZ,aAAa,EACb,UAAe,EACf,YAAgB,EAChB,cAAsC,EACtC,SAAS,EACT,uBAAuB,GACvB,EAAE,gBAAgB,CAAC,MAAM,CAAC,2CAmB1B;AAED,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/$/components/primitives/wheelpicker/wheelpicker.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Platform } from "react-native";
+import { WheelPickerList } from "./wheel-picker-list";
+import { useWheelPickerValue } from "./use-wheel-picker-value";
+function WheelPicker(_a) {
+    var items = _a.items, value = _a.value, defaultValue = _a.defaultValue, onValueChange = _a.onValueChange, _b = _a.itemHeight, itemHeight = _b === void 0 ? 44 : _b, _c = _a.visibleItems, visibleItems = _c === void 0 ? 5 : _c, _d = _a.hapticFeedback, hapticFeedback = _d === void 0 ? Platform.OS === "ios" : _d, className = _a.className, overlayBgColorClassName = _a.overlayBgColorClassName;
+    var _e = useWheelPickerValue({
+        items: items,
+        value: value,
+        defaultValue: defaultValue,
+        onValueChange: onValueChange,
+    }), selectedIndex = _e.selectedIndex, handleIndexChange = _e.handleIndexChange;
+    return (_jsx(WheelPickerList, { items: items, selectedIndex: selectedIndex, onIndexChange: handleIndexChange, itemHeight: itemHeight, visibleItems: visibleItems, hapticFeedback: hapticFeedback, className: className, overlayBgColorClassName: overlayBgColorClassName }));
+}
+export { WheelPicker };