@vuer-ai/vuer-uikit 0.0.45 → 0.0.48

package/dist/chunk-JBQP2CBI.mjs

@@ -0,0 +1,136 @@
+import { createContext, useState, useRef, useCallback, useEffect, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/ui/drag-selectable/DragSelectProvider.tsx
+var DragSelectContext = createContext(void 0);
+var DragSelectProvider = ({ children }) => {
+  const [selectedItems, setSelectedItems] = useState(/* @__PURE__ */ new Set());
+  const [isDragging, setIsDragging] = useState(false);
+  const dragStartId = useRef(null);
+  const dragMode = useRef("replace");
+  const dragStartSelection = useRef(/* @__PURE__ */ new Set());
+  const registeredItems = useRef(/* @__PURE__ */ new Map());
+  const registerItem = useCallback((id, index) => {
+    registeredItems.current.set(id, index);
+  }, []);
+  const unregisterItem = useCallback((id) => {
+    registeredItems.current.delete(id);
+  }, []);
+  const startDrag = useCallback(
+    (startId, mode = "replace") => {
+      setIsDragging(true);
+      dragStartId.current = startId;
+      dragMode.current = mode;
+      dragStartSelection.current = new Set(selectedItems);
+      if (mode === "replace") {
+        setSelectedItems(/* @__PURE__ */ new Set([startId]));
+      } else if (mode === "add") {
+        setSelectedItems((prev) => new Set(Array.from(prev).concat([startId])));
+      } else if (mode === "toggle") {
+        setSelectedItems((prev) => {
+          const newSelection = new Set(prev);
+          if (newSelection.has(startId)) {
+            newSelection.delete(startId);
+          } else {
+            newSelection.add(startId);
+          }
+          return newSelection;
+        });
+      }
+    },
+    [selectedItems]
+  );
+  const updateSelection = useCallback(
+    (currentId) => {
+      if (!isDragging || !dragStartId.current) return;
+      const startIndex = registeredItems.current.get(dragStartId.current);
+      const currentIndex = registeredItems.current.get(currentId);
+      if (startIndex === void 0 || currentIndex === void 0) return;
+      const minIndex = Math.min(startIndex, currentIndex);
+      const maxIndex = Math.max(startIndex, currentIndex);
+      const dragSelection = /* @__PURE__ */ new Set();
+      Array.from(registeredItems.current.entries()).forEach(([itemId, itemIndex]) => {
+        if (itemIndex >= minIndex && itemIndex <= maxIndex) {
+          dragSelection.add(itemId);
+        }
+      });
+      if (dragMode.current === "replace") {
+        setSelectedItems(dragSelection);
+      } else if (dragMode.current === "add") {
+        setSelectedItems(
+          () => new Set(Array.from(dragStartSelection.current).concat(Array.from(dragSelection)))
+        );
+      } else if (dragMode.current === "toggle") {
+        setSelectedItems(() => {
+          const newSelection = new Set(dragStartSelection.current);
+          Array.from(dragSelection).forEach((itemId) => {
+            if (newSelection.has(itemId)) {
+              newSelection.delete(itemId);
+            } else {
+              newSelection.add(itemId);
+            }
+          });
+          return newSelection;
+        });
+      }
+    },
+    [isDragging]
+  );
+  const endDrag = useCallback(() => {
+    setIsDragging(false);
+    dragStartId.current = null;
+  }, []);
+  const clearSelection = useCallback(() => {
+    setSelectedItems(/* @__PURE__ */ new Set());
+  }, []);
+  const isSelected = useCallback(
+    (id) => {
+      return selectedItems.has(id);
+    },
+    [selectedItems]
+  );
+  useEffect(() => {
+    const handleMouseUp = () => {
+      if (isDragging) {
+        endDrag();
+      }
+    };
+    const handleKeyDown = (e) => {
+      if (e.key === "Escape") {
+        clearSelection();
+      }
+    };
+    document.addEventListener("mouseup", handleMouseUp);
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      document.removeEventListener("mouseup", handleMouseUp);
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [isDragging, endDrag, clearSelection]);
+  return /* @__PURE__ */ jsx(
+    DragSelectContext.Provider,
+    {
+      value: {
+        selectedItems,
+        isDragging,
+        registerItem,
+        unregisterItem,
+        startDrag,
+        updateSelection,
+        endDrag,
+        clearSelection,
+        isSelected
+      },
+      children
+    }
+  );
+};
+var useDragSelectContext = () => {
+  const context = useContext(DragSelectContext);
+  if (context === void 0) {
+    throw new Error("useDragSelectContext must be used within a DragSelectProvider");
+  }
+  return context;
+};
+
+export { DragSelectProvider, useDragSelectContext };

package/dist/chunk-KYWKRMXK.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var chunk7KYAICHB_js = require('./chunk-7KYAICHB.js');
+var SeparatorPrimitive = require('@radix-ui/react-separator');
+var jsxRuntime = require('react/jsx-runtime');
+
+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 SeparatorPrimitive__namespace = /*#__PURE__*/_interopNamespace(SeparatorPrimitive);
+
+function Separator({
+  className,
+  orientation = "horizontal",
+  decorative = true,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SeparatorPrimitive__namespace.Root,
+    {
+      "data-slot": "separator-root",
+      decorative,
+      orientation,
+      className: chunk7KYAICHB_js.cn(
+        "bg-line-primary shrink-0 data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px",
+        className
+      ),
+      ...props
+    }
+  );
+}
+
+exports.Separator = Separator;

package/dist/chunk-N6DZ364I.mjs

@@ -0,0 +1,15 @@
+import { cn } from './chunk-WM2VP7MI.mjs';
+import { jsx } from 'react/jsx-runtime';
+
+function Skeleton({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "skeleton",
+      className: cn("bg-bg-secondary rounded-uk-sm animate-pulse", className),
+      ...props
+    }
+  );
+}
+
+export { Skeleton };

package/dist/chunk-NXTGTCPA.mjs

@@ -0,0 +1,19 @@
+import * as React from 'react';
+
+// src/hooks/use-mobile.ts
+var MOBILE_BREAKPOINT = 768;
+function useIsMobile() {
+  const [isMobile, setIsMobile] = React.useState(void 0);
+  React.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;
+}
+
+export { useIsMobile };

package/dist/{chunk-MFXAWZIK.mjs → chunk-PDXJXH4A.mjs}

@@ -1,4 +1,4 @@
-import { TreeView } from './chunk-LD654LL2.mjs';
+import { TreeView } from './chunk-VSYSYSVQ.mjs';
 import { TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from './chunk-TCN3UDQE.mjs';
 import { cn } from './chunk-WM2VP7MI.mjs';
 import { Magnet, ChevronLeft, ChevronRight } from 'lucide-react';