@szum-tech/design-system 3.14.0 → 3.16.0

package/dist/{chunk-K5QSMTKJ.js → chunk-3DP3VMPN.js}

@@ -1,5 +1,5 @@
+import { Separator } from './chunk-A72LE53B.js';
 import { Label } from './chunk-I3RSTJP6.js';
-import { Separator } from './chunk-XJIUGEPN.js';
 import { cn } from './chunk-ZD2QRAOX.js';
 import { cva } from 'class-variance-authority';
 import { jsx, jsxs } from 'react/jsx-runtime';

package/dist/{chunk-XJIUGEPN.js → chunk-A72LE53B.js}

@@ -10,7 +10,7 @@ function Separator({ className, orientation = "horizontal", decorative = false,
       decorative,
       orientation,
       className: cn(
-        "bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px",
+        "bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:w-px data-[orientation=vertical]:self-stretch",
         className
       ),
       ...props

package/dist/chunk-BUJO4FB6.js

@@ -0,0 +1,252 @@
+import { cn } from './chunk-ZD2QRAOX.js';
+import * as React2 from 'react';
+import { Slot } from 'radix-ui';
+import { createPortal } from 'react-dom';
+import { defaultDropAnimationSideEffects, useSensors, useSensor, MouseSensor, TouchSensor, KeyboardSensor, DndContext, MeasuringStrategy, DragOverlay } from '@dnd-kit/core';
+import { sortableKeyboardCoordinates, arrayMove, SortableContext, useSortable, verticalListSortingStrategy, rectSortingStrategy, defaultAnimateLayoutChanges } from '@dnd-kit/sortable';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { CSS } from '@dnd-kit/utilities';
+
+var SORTABLE_ROOT_NAME = "Sortable";
+var SORTABLE_ITEM_NAME = "SortableItem";
+var SORTABLE_ITEM_HANDLE_NAME = "SortableItemHandle";
+var SORTABLE_OVERLAY_NAME = "SortableOverlay";
+var animateLayoutChanges = (args) => defaultAnimateLayoutChanges({ ...args, wasDragging: true });
+var dropAnimationConfig = {
+  sideEffects: defaultDropAnimationSideEffects({
+    styles: {
+      active: {
+        opacity: "0.4"
+      }
+    }
+  })
+};
+var SortableItemContext = React2.createContext(null);
+function useSortableItemContext(consumerName) {
+  const context = React2.useContext(SortableItemContext);
+  if (!context) {
+    throw new Error(`\`${consumerName}\` must be used within \`${SORTABLE_ITEM_NAME}\``);
+  }
+  return context;
+}
+var IsOverlayContext = React2.createContext(false);
+var SortableInternalContext = React2.createContext(null);
+function useSortableInternalContext(consumerName) {
+  const context = React2.useContext(SortableInternalContext);
+  if (!context) {
+    throw new Error(`\`${consumerName}\` must be used within \`${SORTABLE_ROOT_NAME}\``);
+  }
+  return context;
+}
+function Sortable({
+  value,
+  onValueChange,
+  getItemValue,
+  className,
+  asChild = false,
+  onMove,
+  strategy = "vertical",
+  onDragStart,
+  onDragEnd,
+  modifiers,
+  children,
+  ...props
+}) {
+  const [activeId, setActiveId] = React2.useState(null);
+  const [mounted, setMounted] = React2.useState(false);
+  React2.useLayoutEffect(() => setMounted(true), []);
+  const sensors = useSensors(
+    useSensor(MouseSensor, {
+      activationConstraint: {
+        distance: 10
+      }
+    }),
+    useSensor(TouchSensor, {
+      activationConstraint: {
+        delay: 250,
+        tolerance: 5
+      }
+    }),
+    useSensor(KeyboardSensor, {
+      coordinateGetter: sortableKeyboardCoordinates
+    })
+  );
+  const handleDragStart = React2.useCallback(
+    (event) => {
+      setActiveId(event.active.id);
+      onDragStart?.(event);
+    },
+    [onDragStart]
+  );
+  const handleDragEnd = React2.useCallback(
+    (event) => {
+      const { active, over } = event;
+      setActiveId(null);
+      onDragEnd?.(event);
+      if (!over) return;
+      const activeIndex = value.findIndex((item) => getItemValue(item) === active.id);
+      const overIndex = value.findIndex((item) => getItemValue(item) === over.id);
+      if (activeIndex !== overIndex) {
+        if (onMove) {
+          onMove({ event, activeIndex, overIndex });
+        } else {
+          const newValue = arrayMove(value, activeIndex, overIndex);
+          onValueChange(newValue);
+        }
+      }
+    },
+    [value, getItemValue, onValueChange, onMove, onDragEnd]
+  );
+  const handleDragCancel = React2.useCallback(() => {
+    setActiveId(null);
+  }, []);
+  const getStrategy = () => {
+    switch (strategy) {
+      case "horizontal":
+        return rectSortingStrategy;
+      case "grid":
+        return rectSortingStrategy;
+      case "vertical":
+      default:
+        return verticalListSortingStrategy;
+    }
+  };
+  const itemIds = React2.useMemo(() => value.map(getItemValue), [value, getItemValue]);
+  const contextValue = React2.useMemo(() => ({ activeId, modifiers }), [activeId, modifiers]);
+  const overlayContent = React2.useMemo(() => {
+    if (!activeId) return null;
+    let result = null;
+    React2.Children.forEach(children, (child) => {
+      if (React2.isValidElement(child) && child.props.value === activeId) {
+        result = React2.cloneElement(child, {
+          ...child.props,
+          className: cn(child.props.className, "z-50")
+        });
+      }
+    });
+    return result;
+  }, [activeId, children]);
+  const Comp = asChild ? Slot.Root : "div";
+  return /* @__PURE__ */ jsx(SortableInternalContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxs(
+    DndContext,
+    {
+      sensors,
+      modifiers,
+      measuring: {
+        droppable: {
+          strategy: MeasuringStrategy.Always
+        }
+      },
+      onDragStart: handleDragStart,
+      onDragEnd: handleDragEnd,
+      onDragCancel: handleDragCancel,
+      children: [
+        /* @__PURE__ */ jsx(SortableContext, { items: itemIds, strategy: getStrategy(), children: /* @__PURE__ */ jsx(
+          Comp,
+          {
+            "data-slot": "sortable",
+            "data-dragging": activeId !== null,
+            className: cn(activeId !== null && "cursor-grabbing!", className),
+            ...props,
+            children
+          }
+        ) }),
+        mounted && createPortal(
+          /* @__PURE__ */ jsx(
+            DragOverlay,
+            {
+              dropAnimation: dropAnimationConfig,
+              modifiers,
+              className: cn("z-50", activeId && "cursor-grabbing"),
+              children: /* @__PURE__ */ jsx(IsOverlayContext.Provider, { value: true, children: overlayContent })
+            }
+          ),
+          document.body
+        )
+      ]
+    }
+  ) });
+}
+function SortableItem({ value, className, asChild = false, disabled, children, ...props }) {
+  const isOverlay = React2.useContext(IsOverlayContext);
+  const {
+    setNodeRef,
+    transform,
+    transition,
+    attributes,
+    listeners,
+    isDragging: isSortableDragging
+  } = useSortable({
+    id: value,
+    disabled: disabled || isOverlay,
+    animateLayoutChanges
+  });
+  if (isOverlay) {
+    const Comp2 = asChild ? Slot.Root : "div";
+    return /* @__PURE__ */ jsx(SortableItemContext.Provider, { value: { listeners: void 0, isDragging: true, disabled: false }, children: /* @__PURE__ */ jsx(Comp2, { "data-slot": "sortable-item", "data-value": value, "data-dragging": true, className: cn(className), ...props, children }) });
+  }
+  const style = {
+    transition,
+    transform: CSS.Transform.toString(transform)
+  };
+  const Comp = asChild ? Slot.Root : "div";
+  return /* @__PURE__ */ jsx(SortableItemContext.Provider, { value: { listeners, isDragging: isSortableDragging, disabled }, children: /* @__PURE__ */ jsx(
+    Comp,
+    {
+      "data-slot": "sortable-item",
+      "data-value": value,
+      "data-dragging": isSortableDragging,
+      "data-disabled": disabled,
+      ref: setNodeRef,
+      style,
+      ...attributes,
+      className: cn(isSortableDragging && "z-50 opacity-50", disabled && "opacity-50", className),
+      ...props,
+      children
+    }
+  ) });
+}
+function SortableItemHandle({
+  className,
+  asChild = false,
+  cursor = true,
+  children,
+  ...props
+}) {
+  const { listeners, isDragging, disabled } = useSortableItemContext(SORTABLE_ITEM_HANDLE_NAME);
+  const Comp = asChild ? Slot.Root : "div";
+  return /* @__PURE__ */ jsx(
+    Comp,
+    {
+      "data-slot": "sortable-item-handle",
+      "data-dragging": isDragging,
+      "data-disabled": disabled,
+      ...listeners,
+      className: cn(cursor && (isDragging ? "cursor-grabbing!" : "cursor-grab!"), className),
+      ...props,
+      children
+    }
+  );
+}
+function SortableOverlay({ children, className, ...props }) {
+  const { activeId, modifiers } = useSortableInternalContext(SORTABLE_OVERLAY_NAME);
+  const [mounted, setMounted] = React2.useState(false);
+  React2.useLayoutEffect(() => setMounted(true), []);
+  const content = activeId && children ? typeof children === "function" ? children({ value: activeId }) : children : null;
+  if (!mounted) return null;
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      DragOverlay,
+      {
+        dropAnimation: dropAnimationConfig,
+        modifiers,
+        className: cn("z-50", activeId && "cursor-grabbing", className),
+        ...props,
+        children: /* @__PURE__ */ jsx(IsOverlayContext.Provider, { value: true, children: content })
+      }
+    ),
+    document.body
+  );
+}
+
+export { Sortable, SortableItem, SortableItemHandle, SortableOverlay, useSortableItemContext };

package/dist/chunk-CL2C6STG.cjs

@@ -0,0 +1,278 @@
+'use strict';
+
+var chunkH2BWO3SI_cjs = require('./chunk-H2BWO3SI.cjs');
+var React2 = require('react');
+var radixUi = require('radix-ui');
+var reactDom = require('react-dom');
+var core = require('@dnd-kit/core');
+var sortable = require('@dnd-kit/sortable');
+var jsxRuntime = require('react/jsx-runtime');
+var utilities = require('@dnd-kit/utilities');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React2__namespace = /*#__PURE__*/_interopNamespace(React2);
+
+var SORTABLE_ROOT_NAME = "Sortable";
+var SORTABLE_ITEM_NAME = "SortableItem";
+var SORTABLE_ITEM_HANDLE_NAME = "SortableItemHandle";
+var SORTABLE_OVERLAY_NAME = "SortableOverlay";
+var animateLayoutChanges = (args) => sortable.defaultAnimateLayoutChanges({ ...args, wasDragging: true });
+var dropAnimationConfig = {
+  sideEffects: core.defaultDropAnimationSideEffects({
+    styles: {
+      active: {
+        opacity: "0.4"
+      }
+    }
+  })
+};
+var SortableItemContext = React2__namespace.createContext(null);
+function useSortableItemContext(consumerName) {
+  const context = React2__namespace.useContext(SortableItemContext);
+  if (!context) {
+    throw new Error(`\`${consumerName}\` must be used within \`${SORTABLE_ITEM_NAME}\``);
+  }
+  return context;
+}
+var IsOverlayContext = React2__namespace.createContext(false);
+var SortableInternalContext = React2__namespace.createContext(null);
+function useSortableInternalContext(consumerName) {
+  const context = React2__namespace.useContext(SortableInternalContext);
+  if (!context) {
+    throw new Error(`\`${consumerName}\` must be used within \`${SORTABLE_ROOT_NAME}\``);
+  }
+  return context;
+}
+function Sortable({
+  value,
+  onValueChange,
+  getItemValue,
+  className,
+  asChild = false,
+  onMove,
+  strategy = "vertical",
+  onDragStart,
+  onDragEnd,
+  modifiers,
+  children,
+  ...props
+}) {
+  const [activeId, setActiveId] = React2__namespace.useState(null);
+  const [mounted, setMounted] = React2__namespace.useState(false);
+  React2__namespace.useLayoutEffect(() => setMounted(true), []);
+  const sensors = core.useSensors(
+    core.useSensor(core.MouseSensor, {
+      activationConstraint: {
+        distance: 10
+      }
+    }),
+    core.useSensor(core.TouchSensor, {
+      activationConstraint: {
+        delay: 250,
+        tolerance: 5
+      }
+    }),
+    core.useSensor(core.KeyboardSensor, {
+      coordinateGetter: sortable.sortableKeyboardCoordinates
+    })
+  );
+  const handleDragStart = React2__namespace.useCallback(
+    (event) => {
+      setActiveId(event.active.id);
+      onDragStart?.(event);
+    },
+    [onDragStart]
+  );
+  const handleDragEnd = React2__namespace.useCallback(
+    (event) => {
+      const { active, over } = event;
+      setActiveId(null);
+      onDragEnd?.(event);
+      if (!over) return;
+      const activeIndex = value.findIndex((item) => getItemValue(item) === active.id);
+      const overIndex = value.findIndex((item) => getItemValue(item) === over.id);
+      if (activeIndex !== overIndex) {
+        if (onMove) {
+          onMove({ event, activeIndex, overIndex });
+        } else {
+          const newValue = sortable.arrayMove(value, activeIndex, overIndex);
+          onValueChange(newValue);
+        }
+      }
+    },
+    [value, getItemValue, onValueChange, onMove, onDragEnd]
+  );
+  const handleDragCancel = React2__namespace.useCallback(() => {
+    setActiveId(null);
+  }, []);
+  const getStrategy = () => {
+    switch (strategy) {
+      case "horizontal":
+        return sortable.rectSortingStrategy;
+      case "grid":
+        return sortable.rectSortingStrategy;
+      case "vertical":
+      default:
+        return sortable.verticalListSortingStrategy;
+    }
+  };
+  const itemIds = React2__namespace.useMemo(() => value.map(getItemValue), [value, getItemValue]);
+  const contextValue = React2__namespace.useMemo(() => ({ activeId, modifiers }), [activeId, modifiers]);
+  const overlayContent = React2__namespace.useMemo(() => {
+    if (!activeId) return null;
+    let result = null;
+    React2__namespace.Children.forEach(children, (child) => {
+      if (React2__namespace.isValidElement(child) && child.props.value === activeId) {
+        result = React2__namespace.cloneElement(child, {
+          ...child.props,
+          className: chunkH2BWO3SI_cjs.cn(child.props.className, "z-50")
+        });
+      }
+    });
+    return result;
+  }, [activeId, children]);
+  const Comp = asChild ? radixUi.Slot.Root : "div";
+  return /* @__PURE__ */ jsxRuntime.jsx(SortableInternalContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsxs(
+    core.DndContext,
+    {
+      sensors,
+      modifiers,
+      measuring: {
+        droppable: {
+          strategy: core.MeasuringStrategy.Always
+        }
+      },
+      onDragStart: handleDragStart,
+      onDragEnd: handleDragEnd,
+      onDragCancel: handleDragCancel,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(sortable.SortableContext, { items: itemIds, strategy: getStrategy(), children: /* @__PURE__ */ jsxRuntime.jsx(
+          Comp,
+          {
+            "data-slot": "sortable",
+            "data-dragging": activeId !== null,
+            className: chunkH2BWO3SI_cjs.cn(activeId !== null && "cursor-grabbing!", className),
+            ...props,
+            children
+          }
+        ) }),
+        mounted && reactDom.createPortal(
+          /* @__PURE__ */ jsxRuntime.jsx(
+            core.DragOverlay,
+            {
+              dropAnimation: dropAnimationConfig,
+              modifiers,
+              className: chunkH2BWO3SI_cjs.cn("z-50", activeId && "cursor-grabbing"),
+              children: /* @__PURE__ */ jsxRuntime.jsx(IsOverlayContext.Provider, { value: true, children: overlayContent })
+            }
+          ),
+          document.body
+        )
+      ]
+    }
+  ) });
+}
+function SortableItem({ value, className, asChild = false, disabled, children, ...props }) {
+  const isOverlay = React2__namespace.useContext(IsOverlayContext);
+  const {
+    setNodeRef,
+    transform,
+    transition,
+    attributes,
+    listeners,
+    isDragging: isSortableDragging
+  } = sortable.useSortable({
+    id: value,
+    disabled: disabled || isOverlay,
+    animateLayoutChanges
+  });
+  if (isOverlay) {
+    const Comp2 = asChild ? radixUi.Slot.Root : "div";
+    return /* @__PURE__ */ jsxRuntime.jsx(SortableItemContext.Provider, { value: { listeners: void 0, isDragging: true, disabled: false }, children: /* @__PURE__ */ jsxRuntime.jsx(Comp2, { "data-slot": "sortable-item", "data-value": value, "data-dragging": true, className: chunkH2BWO3SI_cjs.cn(className), ...props, children }) });
+  }
+  const style = {
+    transition,
+    transform: utilities.CSS.Transform.toString(transform)
+  };
+  const Comp = asChild ? radixUi.Slot.Root : "div";
+  return /* @__PURE__ */ jsxRuntime.jsx(SortableItemContext.Provider, { value: { listeners, isDragging: isSortableDragging, disabled }, children: /* @__PURE__ */ jsxRuntime.jsx(
+    Comp,
+    {
+      "data-slot": "sortable-item",
+      "data-value": value,
+      "data-dragging": isSortableDragging,
+      "data-disabled": disabled,
+      ref: setNodeRef,
+      style,
+      ...attributes,
+      className: chunkH2BWO3SI_cjs.cn(isSortableDragging && "z-50 opacity-50", disabled && "opacity-50", className),
+      ...props,
+      children
+    }
+  ) });
+}
+function SortableItemHandle({
+  className,
+  asChild = false,
+  cursor = true,
+  children,
+  ...props
+}) {
+  const { listeners, isDragging, disabled } = useSortableItemContext(SORTABLE_ITEM_HANDLE_NAME);
+  const Comp = asChild ? radixUi.Slot.Root : "div";
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    Comp,
+    {
+      "data-slot": "sortable-item-handle",
+      "data-dragging": isDragging,
+      "data-disabled": disabled,
+      ...listeners,
+      className: chunkH2BWO3SI_cjs.cn(cursor && (isDragging ? "cursor-grabbing!" : "cursor-grab!"), className),
+      ...props,
+      children
+    }
+  );
+}
+function SortableOverlay({ children, className, ...props }) {
+  const { activeId, modifiers } = useSortableInternalContext(SORTABLE_OVERLAY_NAME);
+  const [mounted, setMounted] = React2__namespace.useState(false);
+  React2__namespace.useLayoutEffect(() => setMounted(true), []);
+  const content = activeId && children ? typeof children === "function" ? children({ value: activeId }) : children : null;
+  if (!mounted) return null;
+  return reactDom.createPortal(
+    /* @__PURE__ */ jsxRuntime.jsx(
+      core.DragOverlay,
+      {
+        dropAnimation: dropAnimationConfig,
+        modifiers,
+        className: chunkH2BWO3SI_cjs.cn("z-50", activeId && "cursor-grabbing", className),
+        ...props,
+        children: /* @__PURE__ */ jsxRuntime.jsx(IsOverlayContext.Provider, { value: true, children: content })
+      }
+    ),
+    document.body
+  );
+}
+
+exports.Sortable = Sortable;
+exports.SortableItem = SortableItem;
+exports.SortableItemHandle = SortableItemHandle;
+exports.SortableOverlay = SortableOverlay;
+exports.useSortableItemContext = useSortableItemContext;

package/dist/{chunk-UIOBJSKZ.cjs → chunk-DUAM4RTP.cjs}

@@ -12,7 +12,7 @@ function Separator({ className, orientation = "horizontal", decorative = false,
       decorative,
       orientation,
       className: chunkH2BWO3SI_cjs.cn(
-        "bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px",
+        "bg-border shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:w-px data-[orientation=vertical]:self-stretch",
         className
       ),
       ...props

package/dist/{chunk-XY3ZNUWR.cjs → chunk-F7NFSDOD.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var React = require('react');
+var React3 = require('react');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -20,11 +20,11 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var React3__namespace = /*#__PURE__*/_interopNamespace(React3);
 
 // src/hooks/use-validation-log.tsx
 function useValidationLog({ check, scope, message }) {
-  React__namespace.useEffect(() => {
+  React3__namespace.useEffect(() => {
     if (!check) {
       console.error(
         `%c[Szum Tech-Design System]%c
@@ -70,9 +70,22 @@ function composeRefs(...refs) {
   };
 }
 function useComposedRefs(...refs) {
-  return React__namespace.useCallback(composeRefs(...refs), refs);
+  return React3__namespace.useCallback(composeRefs(...refs), refs);
+}
+var MOBILE_BREAKPOINT = 768;
+function useIsMobile() {
+  const [isMobile, setIsMobile] = React3__namespace.useState(void 0);
+  React3__namespace.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+    const onChange = () => setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    mql.addEventListener("change", onChange);
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    return () => mql.removeEventListener("change", onChange);
+  }, []);
+  return !!isMobile;
 }
 
 exports.composeRefs = composeRefs;
 exports.useComposedRefs = useComposedRefs;
+exports.useIsMobile = useIsMobile;
 exports.useValidationLog = useValidationLog;

package/dist/{chunk-GAZLMZBH.cjs → chunk-HPICKLBZ.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
+var chunkDUAM4RTP_cjs = require('./chunk-DUAM4RTP.cjs');
 var chunkS3ANEJJ7_cjs = require('./chunk-S3ANEJJ7.cjs');
-var chunkUIOBJSKZ_cjs = require('./chunk-UIOBJSKZ.cjs');
 var chunkH2BWO3SI_cjs = require('./chunk-H2BWO3SI.cjs');
 var classVarianceAuthority = require('class-variance-authority');
 var jsxRuntime = require('react/jsx-runtime');
@@ -151,7 +151,7 @@ function FieldSeparator({ children, className, ...props }) {
       className: chunkH2BWO3SI_cjs.cn("relative -my-2 h-5 text-sm group-data-[variant=outline]/field-group:-mb-2", className),
       ...props,
       children: [
-        /* @__PURE__ */ jsxRuntime.jsx(chunkUIOBJSKZ_cjs.Separator, { className: "absolute inset-0 top-1/2" }),
+        /* @__PURE__ */ jsxRuntime.jsx(chunkDUAM4RTP_cjs.Separator, { className: "absolute inset-0 top-1/2" }),
         children ? /* @__PURE__ */ jsxRuntime.jsx(
           "span",
           {

package/dist/chunk-KTAIBRTH.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkH2BWO3SI_cjs = require('./chunk-H2BWO3SI.cjs');
+var jsxRuntime = require('react/jsx-runtime');
+
+function Skeleton({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { "data-slot": "skeleton", className: chunkH2BWO3SI_cjs.cn("bg-muted animate-pulse rounded-md", className), ...props });
+}
+
+exports.Skeleton = Skeleton;

package/dist/{chunk-KGGCA634.js → chunk-L2TRMQNN.js}

@@ -1,4 +1,4 @@
-import { Separator } from './chunk-XJIUGEPN.js';
+import { Separator } from './chunk-A72LE53B.js';
 import { cn } from './chunk-ZD2QRAOX.js';
 import { Slot } from '@radix-ui/react-slot';
 import { cva } from 'class-variance-authority';