@cmdniels/uikit 1.0.0

package/out/components/select/SelectContent.js

@@ -0,0 +1,21 @@
+"use client";
+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, jsxs as _jsxs } from "react/jsx-runtime";
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+import cn from "../../cn";
+import SelectScrollDownButton from "./SelectScrollDownButton";
+import SelectScrollUpButton from "./SelectScrollUpButton";
+export default function SelectContent(_a) {
+    var { className, children, side = "bottom", sideOffset = 4, align = "center", alignOffset = 0, alignItemWithTrigger = true } = _a, props = __rest(_a, ["className", "children", "side", "sideOffset", "align", "alignOffset", "alignItemWithTrigger"]);
+    return (_jsx(SelectPrimitive.Portal, { children: _jsx(SelectPrimitive.Positioner, { side: side, sideOffset: sideOffset, align: align, alignOffset: alignOffset, alignItemWithTrigger: alignItemWithTrigger, className: "isolate z-50", children: _jsxs(SelectPrimitive.Popup, Object.assign({ "data-slot": "select-content", className: cn("relative isolate z-50 max-h-(--available-height) w-(--anchor-width) min-w-36 origin-(--transform-origin) overflow-x-hidden overflow-y-auto rounded-md bg-popover text-popover-foreground shadow-md ring-1 ring-foreground/10 duration-100 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95", className) }, props, { children: [_jsx(SelectScrollUpButton, {}), _jsx(SelectPrimitive.List, { children: children }), _jsx(SelectScrollDownButton, {})] })) }) }));
+}

package/out/components/select/SelectGroup.d.ts

@@ -0,0 +1,2 @@
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+export default function SelectGroup({ className, ...props }: SelectPrimitive.Group.Props): import("react/jsx-runtime").JSX.Element;

package/out/components/select/SelectGroup.js

@@ -0,0 +1,19 @@
+"use client";
+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 { Select as SelectPrimitive } from "@base-ui/react/select";
+import cn from "../../cn";
+export default function SelectGroup(_a) {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return _jsx(SelectPrimitive.Group, Object.assign({ "data-slot": "select-group", className: cn("scroll-my-1 p-1", className) }, props));
+}

package/out/components/select/SelectItem.d.ts

@@ -0,0 +1,2 @@
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+export default function SelectItem({ className, children, ...props }: SelectPrimitive.Item.Props): import("react/jsx-runtime").JSX.Element;

package/out/components/select/SelectItem.js

@@ -0,0 +1,20 @@
+"use client";
+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, jsxs as _jsxs } from "react/jsx-runtime";
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+import { IconCheck } from "@tabler/icons-react";
+import cn from "../../cn";
+export default function SelectItem(_a) {
+    var { className, children } = _a, props = __rest(_a, ["className", "children"]);
+    return (_jsxs(SelectPrimitive.Item, Object.assign({ "data-slot": "select-item", className: cn("relative flex w-full cursor-default items-center gap-2 rounded-sm py-1.5 pr-8 pl-2 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2", className) }, props, { children: [_jsx(SelectPrimitive.ItemText, { className: "flex flex-1 shrink-0 gap-2 whitespace-nowrap", children: children }), _jsx(SelectPrimitive.ItemIndicator, { render: _jsx("span", { className: "pointer-events-none absolute right-2 flex size-4 items-center justify-center" }), children: _jsx(IconCheck, { className: "pointer-events-none" }) })] })));
+}

package/out/components/select/SelectLabel.d.ts

@@ -0,0 +1,2 @@
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+export default function SelectLabel({ className, ...props }: SelectPrimitive.GroupLabel.Props): import("react/jsx-runtime").JSX.Element;

package/out/components/select/SelectLabel.js

@@ -0,0 +1,19 @@
+"use client";
+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 { Select as SelectPrimitive } from "@base-ui/react/select";
+import cn from "../../cn";
+export default function SelectLabel(_a) {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return (_jsx(SelectPrimitive.GroupLabel, Object.assign({ "data-slot": "select-label", className: cn("px-2 py-1.5 text-xs text-muted-foreground", className) }, props)));
+}

package/out/components/select/SelectScrollDownButton.d.ts

@@ -0,0 +1,3 @@
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+import type { ComponentProps } from "react";
+export default function SelectScrollDownButton({ className, ...props }: ComponentProps<typeof SelectPrimitive.ScrollDownArrow>): import("react/jsx-runtime").JSX.Element;

package/out/components/select/SelectScrollDownButton.js

@@ -0,0 +1,20 @@
+"use client";
+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 { Select as SelectPrimitive } from "@base-ui/react/select";
+import { IconChevronDown } from "@tabler/icons-react";
+import cn from "../../cn";
+export default function SelectScrollDownButton(_a) {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return (_jsx(SelectPrimitive.ScrollDownArrow, Object.assign({ "data-slot": "select-scroll-down-button", className: cn("bottom-0 z-10 flex w-full cursor-default items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4", className) }, props, { children: _jsx(IconChevronDown, {}) })));
+}

package/out/components/select/SelectScrollUpButton.d.ts

@@ -0,0 +1,3 @@
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+import type { ComponentProps } from "react";
+export default function SelectScrollUpButton({ className, ...props }: ComponentProps<typeof SelectPrimitive.ScrollUpArrow>): import("react/jsx-runtime").JSX.Element;

package/out/components/select/SelectScrollUpButton.js

@@ -0,0 +1,20 @@
+"use client";
+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 { Select as SelectPrimitive } from "@base-ui/react/select";
+import { IconChevronUp } from "@tabler/icons-react";
+import cn from "../../cn";
+export default function SelectScrollUpButton(_a) {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return (_jsx(SelectPrimitive.ScrollUpArrow, Object.assign({ "data-slot": "select-scroll-up-button", className: cn("top-0 z-10 flex w-full cursor-default items-center justify-center bg-popover py-1 [&_svg:not([class*='size-'])]:size-4", className) }, props, { children: _jsx(IconChevronUp, {}) })));
+}

package/out/components/select/SelectSeparator.d.ts

@@ -0,0 +1,2 @@
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+export default function SelectSeparator({ className, ...props }: SelectPrimitive.Separator.Props): import("react/jsx-runtime").JSX.Element;

package/out/components/select/SelectSeparator.js

@@ -0,0 +1,19 @@
+"use client";
+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 { Select as SelectPrimitive } from "@base-ui/react/select";
+import cn from "../../cn";
+export default function SelectSeparator(_a) {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return (_jsx(SelectPrimitive.Separator, Object.assign({ "data-slot": "select-separator", className: cn("pointer-events-none -mx-1 my-1 h-px bg-border", className) }, props)));
+}

package/out/components/select/SelectTrigger.d.ts

@@ -0,0 +1,4 @@
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+export default function SelectTrigger({ className, size, children, ...props }: SelectPrimitive.Trigger.Props & {
+    size?: "sm" | "default";
+}): import("react/jsx-runtime").JSX.Element;

package/out/components/select/SelectTrigger.js

@@ -0,0 +1,20 @@
+"use client";
+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, jsxs as _jsxs } from "react/jsx-runtime";
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+import { IconSelector } from "@tabler/icons-react";
+import cn from "../../cn";
+export default function SelectTrigger(_a) {
+    var { className, size = "default", children } = _a, props = __rest(_a, ["className", "size", "children"]);
+    return (_jsxs(SelectPrimitive.Trigger, Object.assign({ "data-slot": "select-trigger", "data-size": size, className: cn("flex w-fit items-center justify-between gap-1.5 rounded-md border border-input bg-transparent py-2 pr-2 pl-2.5 text-sm whitespace-nowrap shadow-xs transition-[color,box-shadow] outline-none focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:cursor-not-allowed disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-[3px] aria-invalid:ring-destructive/20 data-placeholder:text-muted-foreground data-[size=default]:h-9 data-[size=sm]:h-8 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center *:data-[slot=select-value]:gap-1.5 dark:bg-input/30 dark:hover:bg-input/50 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40  [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className) }, props, { children: [children, _jsx(SelectPrimitive.Icon, { render: _jsx(IconSelector, { className: "pointer-events-none size-4 text-muted-foreground" }) })] })));
+}

package/out/components/select/SelectValue.d.ts

@@ -0,0 +1,2 @@
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+export default function SelectValue({ className, ...props }: SelectPrimitive.Value.Props): import("react/jsx-runtime").JSX.Element;

package/out/components/select/SelectValue.js

@@ -0,0 +1,19 @@
+"use client";
+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 { Select as SelectPrimitive } from "@base-ui/react/select";
+import cn from "../../cn";
+export default function SelectValue(_a) {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return (_jsx(SelectPrimitive.Value, Object.assign({ "data-slot": "select-value", className: cn("flex flex-1 text-left ", className) }, props)));
+}

package/out/components/separator/Separator.d.ts

@@ -0,0 +1,2 @@
+import { Separator as SeparatorPrimitive } from "@base-ui/react/separator";
+export default function Separator({ className, orientation, ...props }: SeparatorPrimitive.Props): import("react/jsx-runtime").JSX.Element;

package/out/components/separator/Separator.js

@@ -0,0 +1,19 @@
+"use client";
+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 { Separator as SeparatorPrimitive } from "@base-ui/react/separator";
+import cn from "../../cn";
+export default function Separator(_a) {
+    var { className, orientation = "horizontal" } = _a, props = __rest(_a, ["className", "orientation"]);
+    return (_jsx(SeparatorPrimitive, Object.assign({ "data-slot": "separator", orientation: orientation, className: cn("shrink-0 bg-border data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:w-px data-[orientation=vertical]:self-stretch", className) }, props)));
+}

package/out/components/skeleton/Skeleton.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentProps } from "react";
+export default function Skeleton({ className, ...props }: ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;

package/out/components/skeleton/Skeleton.js

@@ -0,0 +1,17 @@
+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 cn from "../../cn";
+export default function Skeleton(_a) {
+    var { className } = _a, props = __rest(_a, ["className"]);
+    return _jsx("div", Object.assign({ "data-slot": "skeleton", className: cn("animate-pulse rounded-md bg-muted", className) }, props));
+}

package/out/components/sonner/Toaster.d.ts

@@ -0,0 +1,2 @@
+import { type ToasterProps } from "sonner";
+export default function Toaster({ ...props }: ToasterProps): import("react/jsx-runtime").JSX.Element;

package/out/components/sonner/Toaster.js

@@ -0,0 +1,37 @@
+/* eslint-disable better-tailwindcss/no-unregistered-classes */
+"use client";
+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 { IconCircleCheck, IconInfoCircle, IconAlertTriangle, IconAlertOctagon, IconLoader } from "@tabler/icons-react";
+import { useTheme } from "next-themes";
+import { Toaster as Sonner } from "sonner";
+export default function Toaster(_a) {
+    var props = __rest(_a, []);
+    const { theme = "system" } = useTheme();
+    return (_jsx(Sonner, Object.assign({ theme: theme, className: "toaster group", icons: {
+            success: _jsx(IconCircleCheck, { className: "size-4" }),
+            info: _jsx(IconInfoCircle, { className: "size-4" }),
+            warning: _jsx(IconAlertTriangle, { className: "size-4" }),
+            error: _jsx(IconAlertOctagon, { className: "size-4" }),
+            loading: _jsx(IconLoader, { className: "size-4 animate-spin" }),
+        }, style: {
+            "--normal-bg": "var(--popover)",
+            "--normal-text": "var(--popover-foreground)",
+            "--normal-border": "var(--border)",
+            "--border-radius": "var(--radius)",
+        }, toastOptions: {
+            classNames: {
+                toast: "cn-toast",
+            },
+        } }, props)));
+}

package/out/components/sortable/Sortable.d.ts

@@ -0,0 +1,48 @@
+import { type DndContextProps, type DragEndEvent, DragOverlay, type UniqueIdentifier } from "@dnd-kit/core";
+import { type SortableContextProps } from "@dnd-kit/sortable";
+import { type ComponentProps, type ComponentPropsWithRef, type ElementType, type ReactElement, type ReactNode } from "react";
+interface GetItemValue<T> {
+    /**
+     * Callback that returns a unique identifier for each sortable item. Required for array of objects.
+     * @example getItemValue={(item) => item.id}
+     */
+    getItemValue: (item: T) => UniqueIdentifier;
+}
+type SortableProps<T> = DndContextProps & (T extends object ? GetItemValue<T> : Partial<GetItemValue<T>>) & {
+    value: T[];
+    onValueChange?: (items: T[]) => void;
+    onMove?: (event: DragEndEvent & {
+        activeIndex: number;
+        overIndex: number;
+    }) => void;
+    strategy?: SortableContextProps["strategy"];
+    orientation?: "vertical" | "horizontal" | "mixed";
+    flatCursor?: boolean;
+};
+declare function Sortable<T>(props: SortableProps<T>): import("react/jsx-runtime").JSX.Element;
+interface SortableContentProps<T extends ElementType = "div"> {
+    strategy?: SortableContextProps["strategy"];
+    children: ReactNode;
+    render?: ReactElement<T>;
+    withoutSlot?: boolean;
+}
+declare function SortableContent<T extends ElementType = "div">(props: SortableContentProps<T> & ComponentPropsWithRef<T>): import("react/jsx-runtime").JSX.Element;
+interface SortableItemProps<T extends ElementType = "div"> {
+    value: UniqueIdentifier;
+    asHandle?: boolean;
+    render?: ReactElement<T>;
+    disabled?: boolean;
+}
+declare function SortableItem<T extends ElementType = "div">(props: SortableItemProps<T> & ComponentPropsWithRef<T>): import("react/jsx-runtime").JSX.Element;
+interface SortableItemHandleProps<T extends ElementType = "button"> {
+    render?: ReactElement<T>;
+}
+declare function SortableItemHandle<T extends ElementType = "button">(props: SortableItemHandleProps<T> & ComponentPropsWithRef<T>): import("react/jsx-runtime").JSX.Element;
+interface SortableOverlayProps extends Omit<ComponentProps<typeof DragOverlay>, "children"> {
+    container?: Element | DocumentFragment | null;
+    children?: ((params: {
+        value: UniqueIdentifier;
+    }) => ReactNode) | ReactNode;
+}
+declare function SortableOverlay(props: SortableOverlayProps): import("react").ReactPortal | null;
+export { Sortable, SortableContent, SortableItem, SortableItemHandle, SortableOverlay, type SortableProps, };

package/out/components/sortable/Sortable.js

@@ -0,0 +1,263 @@
+"use client";
+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 { closestCenter, closestCorners, defaultDropAnimationSideEffects, DndContext, DragOverlay, KeyboardSensor, MouseSensor, TouchSensor, useSensor, useSensors, } from "@dnd-kit/core";
+import { restrictToHorizontalAxis, restrictToParentElement, restrictToVerticalAxis } from "@dnd-kit/modifiers";
+import { arrayMove, horizontalListSortingStrategy, SortableContext, sortableKeyboardCoordinates, useSortable, verticalListSortingStrategy, } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import { useComposedRefs } from "motion/react";
+import { createContext, useCallback, cloneElement, useContext, useId, useLayoutEffect, useMemo, useState, } from "react";
+import * as ReactDOM from "react-dom";
+import cn from "../../cn";
+const orientationConfig = {
+    vertical: {
+        modifiers: [restrictToVerticalAxis, restrictToParentElement],
+        strategy: verticalListSortingStrategy,
+        collisionDetection: closestCenter,
+    },
+    horizontal: {
+        modifiers: [restrictToHorizontalAxis, restrictToParentElement],
+        strategy: horizontalListSortingStrategy,
+        collisionDetection: closestCenter,
+    },
+    mixed: {
+        modifiers: [restrictToParentElement],
+        strategy: undefined,
+        collisionDetection: closestCorners,
+    },
+};
+const ROOT_NAME = "Sortable";
+const CONTENT_NAME = "SortableContent";
+const ITEM_NAME = "SortableItem";
+const ITEM_HANDLE_NAME = "SortableItemHandle";
+const OVERLAY_NAME = "SortableOverlay";
+const SortableRootContext = createContext(null);
+function useSortableContext(consumerName) {
+    const context = useContext(SortableRootContext);
+    if (!context) {
+        throw new Error(`\`${consumerName}\` must be used within \`${ROOT_NAME}\``);
+    }
+    return context;
+}
+function Sortable(props) {
+    const { value, onValueChange, collisionDetection, modifiers, strategy, onMove, orientation = "vertical", flatCursor = false, getItemValue: getItemValueProp, accessibility, onDragStart: onDragStartProp, onDragEnd: onDragEndProp, onDragCancel: onDragCancelProp } = props, sortableProps = __rest(props, ["value", "onValueChange", "collisionDetection", "modifiers", "strategy", "onMove", "orientation", "flatCursor", "getItemValue", "accessibility", "onDragStart", "onDragEnd", "onDragCancel"]);
+    const id = useId();
+    const [activeId, setActiveId] = useState(null);
+    const sensors = useSensors(useSensor(MouseSensor), useSensor(TouchSensor), useSensor(KeyboardSensor, {
+        coordinateGetter: sortableKeyboardCoordinates,
+    }));
+    const config = useMemo(() => orientationConfig[orientation], [orientation]);
+    const getItemValue = useCallback((item) => {
+        if (typeof item === "object" && !getItemValueProp) {
+            throw new Error("`getItemValue` is required when using array of objects");
+        }
+        return getItemValueProp ? getItemValueProp(item) : item;
+    }, [getItemValueProp]);
+    const items = useMemo(() => value.map((item) => getItemValue(item)), [value, getItemValue]);
+    const onDragStart = useCallback((event) => {
+        onDragStartProp === null || onDragStartProp === void 0 ? void 0 : onDragStartProp(event);
+        if (event.activatorEvent.defaultPrevented) {
+            return;
+        }
+        setActiveId(event.active.id);
+    }, [onDragStartProp]);
+    const onDragEnd = useCallback((event) => {
+        onDragEndProp === null || onDragEndProp === void 0 ? void 0 : onDragEndProp(event);
+        if (event.activatorEvent.defaultPrevented) {
+            return;
+        }
+        const { active, over } = event;
+        if (over && active.id !== (over === null || over === void 0 ? void 0 : over.id)) {
+            const activeIndex = value.findIndex((item) => getItemValue(item) === active.id);
+            const overIndex = value.findIndex((item) => getItemValue(item) === over.id);
+            if (onMove) {
+                onMove(Object.assign(Object.assign({}, event), { activeIndex, overIndex }));
+            }
+            else {
+                onValueChange === null || onValueChange === void 0 ? void 0 : onValueChange(arrayMove(value, activeIndex, overIndex));
+            }
+        }
+        setActiveId(null);
+    }, [value, onValueChange, onMove, getItemValue, onDragEndProp]);
+    const onDragCancel = useCallback((event) => {
+        onDragCancelProp === null || onDragCancelProp === void 0 ? void 0 : onDragCancelProp(event);
+        if (event.activatorEvent.defaultPrevented) {
+            return;
+        }
+        setActiveId(null);
+    }, [onDragCancelProp]);
+    const announcements = useMemo(() => ({
+        onDragStart({ active }) {
+            var _a;
+            const activeValue = active.id.toString();
+            return `Grabbed sortable item "${activeValue}". Current position is ${((_a = active.data.current) === null || _a === void 0 ? void 0 : _a.sortable.index) + 1} of ${value.length}. Use arrow keys to move, space to drop.`;
+        },
+        onDragOver({ active, over }) {
+            var _a, _b, _c, _d;
+            if (over) {
+                const overIndex = (_b = (_a = over.data.current) === null || _a === void 0 ? void 0 : _a.sortable.index) !== null && _b !== void 0 ? _b : 0;
+                const activeIndex = (_d = (_c = active.data.current) === null || _c === void 0 ? void 0 : _c.sortable.index) !== null && _d !== void 0 ? _d : 0;
+                const moveDirection = overIndex > activeIndex ? "down" : "up";
+                const activeValue = active.id.toString();
+                return `Sortable item "${activeValue}" moved ${moveDirection} to position ${overIndex + 1} of ${value.length}.`;
+            }
+            return "Sortable item is no longer over a droppable area. Press escape to cancel.";
+        },
+        onDragEnd({ active, over }) {
+            var _a, _b;
+            const activeValue = active.id.toString();
+            if (over) {
+                const overIndex = (_b = (_a = over.data.current) === null || _a === void 0 ? void 0 : _a.sortable.index) !== null && _b !== void 0 ? _b : 0;
+                return `Sortable item "${activeValue}" dropped at position ${overIndex + 1} of ${value.length}.`;
+            }
+            return `Sortable item "${activeValue}" dropped. No changes were made.`;
+        },
+        onDragCancel({ active }) {
+            var _a, _b;
+            const activeIndex = (_b = (_a = active.data.current) === null || _a === void 0 ? void 0 : _a.sortable.index) !== null && _b !== void 0 ? _b : 0;
+            const activeValue = active.id.toString();
+            return `Sorting cancelled. Sortable item "${activeValue}" returned to position ${activeIndex + 1} of ${value.length}.`;
+        },
+        onDragMove({ active, over }) {
+            var _a, _b, _c, _d;
+            if (over) {
+                const overIndex = (_b = (_a = over.data.current) === null || _a === void 0 ? void 0 : _a.sortable.index) !== null && _b !== void 0 ? _b : 0;
+                const activeIndex = (_d = (_c = active.data.current) === null || _c === void 0 ? void 0 : _c.sortable.index) !== null && _d !== void 0 ? _d : 0;
+                const moveDirection = overIndex > activeIndex ? "down" : "up";
+                const activeValue = active.id.toString();
+                return `Sortable item "${activeValue}" is moving ${moveDirection} to position ${overIndex + 1} of ${value.length}.`;
+            }
+            return "Sortable item is no longer over a droppable area. Press escape to cancel.";
+        },
+    }), [value]);
+    const screenReaderInstructions = useMemo(() => ({
+        draggable: `
+        To pick up a sortable item, press space or enter.
+        While dragging, use the ${orientation === "vertical" ? "up and down" : orientation === "horizontal" ? "left and right" : "arrow"} keys to move the item.
+        Press space or enter again to drop the item in its new position, or press escape to cancel.
+      `,
+    }), [orientation]);
+    const contextValue = useMemo(() => ({
+        id,
+        items,
+        modifiers: modifiers !== null && modifiers !== void 0 ? modifiers : config.modifiers,
+        strategy: strategy !== null && strategy !== void 0 ? strategy : config.strategy,
+        activeId,
+        setActiveId,
+        getItemValue,
+        flatCursor,
+    }), [id, items, modifiers, strategy, config.modifiers, config.strategy, activeId, getItemValue, flatCursor]);
+    return (_jsx(SortableRootContext.Provider, { value: contextValue, children: _jsx(DndContext, Object.assign({ collisionDetection: collisionDetection !== null && collisionDetection !== void 0 ? collisionDetection : config.collisionDetection, modifiers: modifiers !== null && modifiers !== void 0 ? modifiers : config.modifiers, sensors: sensors }, sortableProps, { id: id, onDragStart: onDragStart, onDragEnd: onDragEnd, onDragCancel: onDragCancel, accessibility: Object.assign({ announcements,
+                screenReaderInstructions }, accessibility) })) }));
+}
+const SortableContentContext = createContext(false);
+function SortableContent(props) {
+    const { strategy: strategyProp, render, withoutSlot, children } = props, contentProps = __rest(props, ["strategy", "render", "withoutSlot", "children"]);
+    const context = useSortableContext(CONTENT_NAME);
+    const element = render ? (cloneElement(render, Object.assign(Object.assign(Object.assign({}, contentProps), render.props), { children, "data-slot": "sortable-content" }))) : (_jsx("div", Object.assign({ "data-slot": "sortable-content" }, contentProps, { children: children })));
+    return (_jsx(SortableContentContext.Provider, { value: true, children: _jsx(SortableContext, { items: context.items, strategy: strategyProp !== null && strategyProp !== void 0 ? strategyProp : context.strategy, children: withoutSlot ? children : element }) }));
+}
+const SortableItemContext = createContext(null);
+function useSortableItemContext(consumerName) {
+    const context = useContext(SortableItemContext);
+    if (!context) {
+        throw new Error(`\`${consumerName}\` must be used within \`${ITEM_NAME}\``);
+    }
+    return context;
+}
+function SortableItem(props) {
+    const { value, style, asHandle, render, disabled, className, ref } = props, itemProps = __rest(props, ["value", "style", "asHandle", "render", "disabled", "className", "ref"]);
+    const inSortableContent = useContext(SortableContentContext);
+    const inSortableOverlay = useContext(SortableOverlayContext);
+    if (!inSortableContent && !inSortableOverlay) {
+        throw new Error(`\`${ITEM_NAME}\` must be used within \`${CONTENT_NAME}\` or \`${OVERLAY_NAME}\``);
+    }
+    if (value === "") {
+        throw new Error(`\`${ITEM_NAME}\` value cannot be an empty string`);
+    }
+    const context = useSortableContext(ITEM_NAME);
+    const id = useId();
+    const { attributes, listeners, setNodeRef, setActivatorNodeRef, transform, transition, isDragging } = useSortable({
+        id: value,
+        disabled,
+    });
+    const composedRef = useComposedRefs(ref, (node) => {
+        if (disabled) {
+            return;
+        }
+        setNodeRef(node);
+        if (asHandle) {
+            setActivatorNodeRef(node);
+        }
+    });
+    const composedStyle = useMemo(() => (Object.assign({ transform: CSS.Translate.toString(transform), transition }, style)), [transform, transition, style]);
+    const itemContext = useMemo(() => ({
+        id,
+        attributes,
+        listeners,
+        setActivatorNodeRef,
+        isDragging,
+        disabled,
+    }), [id, attributes, listeners, setActivatorNodeRef, isDragging, disabled]);
+    const mergedProps = Object.assign(Object.assign(Object.assign(Object.assign({ id, "data-disabled": disabled, "data-dragging": isDragging ? "" : undefined, "data-slot": "sortable-item" }, itemProps), (asHandle && !disabled ? attributes : {})), (asHandle && !disabled ? listeners : {})), { ref: composedRef, style: composedStyle, className: cn("focus-visible:ring-1 focus-visible:ring-neutral-950 focus-visible:ring-offset-1 focus-visible:outline-hidden dark:focus-visible:ring-neutral-300", {
+            "touch-none select-none": asHandle,
+            "cursor-default": context.flatCursor,
+            "data-dragging:cursor-grabbing": !context.flatCursor,
+            "cursor-grab": !isDragging && asHandle && !context.flatCursor,
+            "opacity-50": isDragging,
+            "pointer-events-none opacity-50": disabled,
+        }, className) });
+    const element = render ? cloneElement(render, mergedProps) : _jsx("div", Object.assign({}, mergedProps));
+    return _jsx(SortableItemContext.Provider, { value: itemContext, children: element });
+}
+function SortableItemHandle(props) {
+    const { render, disabled, className } = props, itemHandleProps = __rest(props, ["render", "disabled", "className"]);
+    const context = useSortableContext(ITEM_HANDLE_NAME);
+    const itemContext = useSortableItemContext(ITEM_HANDLE_NAME);
+    const isDisabled = disabled !== null && disabled !== void 0 ? disabled : itemContext.disabled;
+    const composedRef = useComposedRefs(itemHandleProps.ref, (node) => {
+        if (!isDisabled) {
+            return;
+        }
+        itemContext.setActivatorNodeRef(node);
+    });
+    const mergedProps = Object.assign(Object.assign(Object.assign(Object.assign({ type: "button", "aria-controls": itemContext.id, "data-disabled": isDisabled, "data-dragging": itemContext.isDragging ? "" : undefined, "data-slot": "sortable-item-handle" }, itemHandleProps), (isDisabled ? {} : itemContext.attributes)), (isDisabled ? {} : itemContext.listeners)), { ref: composedRef, className: cn("select-none disabled:pointer-events-none disabled:opacity-50", context.flatCursor ? "cursor-default" : "cursor-grab data-dragging:cursor-grabbing", className), disabled: isDisabled });
+    return render ? cloneElement(render, mergedProps) : _jsx("button", Object.assign({}, mergedProps));
+}
+const SortableOverlayContext = createContext(false);
+const dropAnimation = {
+    sideEffects: defaultDropAnimationSideEffects({
+        styles: {
+            active: {
+                opacity: "0.4",
+            },
+        },
+    }),
+};
+function SortableOverlay(props) {
+    var _a;
+    const { container: containerProp, children } = props, overlayProps = __rest(props, ["container", "children"]);
+    const context = useSortableContext(OVERLAY_NAME);
+    const [mounted, setMounted] = useState(false);
+    useLayoutEffect(() => setMounted(true), []);
+    const container = containerProp !== null && containerProp !== void 0 ? containerProp : (mounted ? (_a = globalThis.document) === null || _a === void 0 ? void 0 : _a.body : null);
+    if (!container) {
+        return null;
+    }
+    return ReactDOM.createPortal(_jsx(DragOverlay, Object.assign({ dropAnimation: dropAnimation, modifiers: context.modifiers, className: cn(!context.flatCursor && "cursor-grabbing") }, overlayProps, { children: _jsx(SortableOverlayContext.Provider, { value: true, children: context.activeId
+                ? typeof children === "function"
+                    ? children({ value: context.activeId })
+                    : children
+                : null }) })), container);
+}
+export { Sortable, SortableContent, SortableItem, SortableItemHandle, SortableOverlay, };