@vuer-ai/vuer-uikit 0.0.73 → 0.0.75

package/dist/chunk-7LLDKYND.mjs

@@ -0,0 +1,243 @@
+import { ThemeScript } from './chunk-PQEAXTVY.mjs';
+import { createContext, useContext, useMemo, useState, useCallback, useEffect } from 'react';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+
+var colorSchemes = ["light", "dark"];
+var MEDIA = "(prefers-color-scheme: dark)";
+var isServer = typeof window === "undefined";
+var ThemeContext = createContext(void 0);
+var saveToLS = (key, value) => {
+  try {
+    localStorage.setItem(key, value);
+  } catch {
+  }
+};
+var getFromLS = (key, fallback) => {
+  if (isServer) return fallback;
+  try {
+    return localStorage.getItem(key) || fallback;
+  } catch {
+    return fallback;
+  }
+};
+var computeTheme = (baseTheme, isLiquid, systemIsDark) => {
+  let resolvedBase;
+  if (baseTheme === "system") {
+    resolvedBase = systemIsDark ? "dark" : "light";
+  } else {
+    resolvedBase = baseTheme;
+  }
+  return isLiquid ? `liquid-${resolvedBase}` : resolvedBase;
+};
+var parseOldTheme = (oldTheme) => {
+  if (oldTheme === "system") {
+    return { baseTheme: "system", isLiquid: false };
+  }
+  if (oldTheme.startsWith("liquid-")) {
+    const base = oldTheme.replace("liquid-", "");
+    return { baseTheme: base, isLiquid: true };
+  }
+  return { baseTheme: oldTheme, isLiquid: false };
+};
+var useTheme = () => {
+  const context = useContext(ThemeContext);
+  if (context === void 0) throw new Error("useTheme must be used within a ThemeProvider");
+  return context;
+};
+var ThemeProvider = (props) => {
+  const context = useContext(ThemeContext);
+  if (context) return /* @__PURE__ */ jsx(Fragment, { children: props.children });
+  return /* @__PURE__ */ jsx(Theme, { ...props });
+};
+var defaultThemes = ["light", "dark", "liquid-light", "liquid-dark"];
+var Theme = ({
+  forcedTheme,
+  disableTransitionOnChange = false,
+  enableSystem = true,
+  enableColorScheme = false,
+  storageKey = "vuer-uikit-theme",
+  defaultBaseTheme = enableSystem ? "system" : "light",
+  defaultIsLiquid = true,
+  attribute = "class",
+  value,
+  children,
+  nonce,
+  scriptProps
+}) => {
+  const themes = defaultThemes;
+  const initialState = useMemo(() => {
+    return { baseTheme: defaultBaseTheme, isLiquid: defaultIsLiquid };
+  }, [defaultBaseTheme, defaultIsLiquid]);
+  const [baseTheme, setBaseThemeState] = useState(() => {
+    const stored = getFromLS(`${storageKey}-base`, "");
+    if (!stored) {
+      return initialState.baseTheme;
+    }
+    return ["light", "dark", "system"].includes(stored) ? stored : initialState.baseTheme;
+  });
+  const [isLiquid, setIsLiquidState] = useState(() => {
+    const stored = getFromLS(`${storageKey}-liquid`, "");
+    if (!stored) {
+      return initialState.isLiquid;
+    }
+    return stored === "true";
+  });
+  const [systemIsDark, setSystemIsDark] = useState(() => {
+    if (isServer) {
+      return false;
+    }
+    return window.matchMedia(MEDIA).matches;
+  });
+  const attrs = !value ? themes : Object.values(value);
+  const computedTheme = useMemo(
+    () => computeTheme(baseTheme, isLiquid, systemIsDark),
+    [baseTheme, isLiquid, systemIsDark]
+  );
+  const resolvedTheme = useMemo(() => {
+    if (forcedTheme) {
+      const parsed = parseOldTheme(forcedTheme);
+      return computeTheme(parsed.baseTheme, parsed.isLiquid, systemIsDark);
+    }
+    return computedTheme;
+  }, [forcedTheme, computedTheme, systemIsDark]);
+  const applyTheme = useCallback(
+    (theme) => {
+      if (!theme) return;
+      const name = value ? value[theme] : theme;
+      const enable = disableTransitionOnChange ? disableAnimation(nonce) : null;
+      const d = document.documentElement;
+      const handleAttribute = (attr) => {
+        if (attr === "class") {
+          d.classList.remove(...attrs);
+          if (name) d.classList.add(name);
+        } else if (attr.startsWith("data-")) {
+          if (name) {
+            d.setAttribute(attr, name);
+          } else {
+            d.removeAttribute(attr);
+          }
+        }
+      };
+      if (Array.isArray(attribute)) attribute.forEach(handleAttribute);
+      else handleAttribute(attribute);
+      if (enableColorScheme) {
+        const isDark = theme.includes("dark");
+        d.style.colorScheme = isDark ? "dark" : "light";
+      }
+      enable?.();
+    },
+    [attribute, attrs, disableTransitionOnChange, enableColorScheme, nonce, value]
+  );
+  const setBaseTheme = useCallback((newBaseTheme) => {
+    setBaseThemeState(newBaseTheme);
+    saveToLS(`${storageKey}-base`, newBaseTheme);
+  }, [storageKey]);
+  const toggleLiquid = useCallback(() => {
+    setIsLiquidState((prev) => {
+      const newValue = !prev;
+      saveToLS(`${storageKey}-liquid`, String(newValue));
+      return newValue;
+    });
+  }, [storageKey]);
+  const handleMediaQuery = useCallback(
+    (e) => {
+      const isDark = e.matches;
+      setSystemIsDark(isDark);
+    },
+    []
+  );
+  useEffect(() => {
+    const media = window.matchMedia(MEDIA);
+    media.addListener(handleMediaQuery);
+    handleMediaQuery(media);
+    return () => media.removeListener(handleMediaQuery);
+  }, [handleMediaQuery]);
+  useEffect(() => {
+    const handleStorage = (e) => {
+      if (e.key === `${storageKey}-base` && e.newValue) {
+        setBaseThemeState(e.newValue);
+      } else if (e.key === `${storageKey}-liquid` && e.newValue !== null) {
+        setIsLiquidState(e.newValue === "true");
+      }
+    };
+    window.addEventListener("storage", handleStorage);
+    return () => window.removeEventListener("storage", handleStorage);
+  }, [storageKey]);
+  useEffect(() => {
+    applyTheme(resolvedTheme);
+  }, [applyTheme, resolvedTheme]);
+  const contextValue = useMemo(
+    () => ({
+      baseTheme,
+      setBaseTheme,
+      isLiquid,
+      toggleLiquid,
+      computedTheme,
+      resolvedTheme,
+      systemTheme: enableSystem ? systemIsDark ? "dark" : "light" : void 0,
+      forcedTheme,
+      storageKey
+    }),
+    [
+      baseTheme,
+      setBaseTheme,
+      isLiquid,
+      toggleLiquid,
+      computedTheme,
+      resolvedTheme,
+      systemIsDark,
+      enableSystem,
+      forcedTheme,
+      storageKey
+    ]
+  );
+  return /* @__PURE__ */ jsxs(ThemeContext.Provider, { value: contextValue, children: [
+    /* @__PURE__ */ jsx(
+      ThemeScript,
+      {
+        ...{
+          forcedTheme,
+          storageKey,
+          attribute,
+          enableSystem,
+          enableColorScheme,
+          defaultTheme: initialState.baseTheme === "system" ? "system" : initialState.isLiquid ? `liquid-${initialState.baseTheme}` : initialState.baseTheme,
+          value,
+          themes,
+          nonce,
+          scriptProps
+        }
+      }
+    ),
+    children
+  ] });
+};
+var getTheme = (key, fallback) => {
+  return getFromLS(key, fallback);
+};
+var disableAnimation = (nonce) => {
+  const css = document.createElement("style");
+  if (nonce) css.setAttribute("nonce", nonce);
+  css.appendChild(
+    document.createTextNode(
+      `*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}`
+    )
+  );
+  document.head.appendChild(css);
+  return () => {
+    (() => window.getComputedStyle(document.body))();
+    setTimeout(() => {
+      if (css && css.parentNode) {
+        css.parentNode.removeChild(css);
+      }
+    }, 1);
+  };
+};
+var getSystemTheme = (e) => {
+  if (isServer) return "liquid-light";
+  if (!e) e = window.matchMedia(MEDIA);
+  const isDark = e.matches;
+  return isDark ? "liquid-dark" : "liquid-light";
+};
+
+export { MEDIA, Theme, ThemeContext, ThemeProvider, colorSchemes, computeTheme, defaultThemes, disableAnimation, getFromLS, getSystemTheme, getTheme, isServer, parseOldTheme, saveToLS, useTheme };

package/dist/chunk-A2LWPEGE.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/ui/icons/MouseCursorIcons.tsx
+var MouseCursorIcon = ({ strokeWidth = 2.25 }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: "16",
+      height: "16",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      "stroke-width": strokeWidth,
+      "stroke-linecap": "round",
+      "stroke-linejoin": "round",
+      className: "lucide lucide-mouse-pointer2-icon lucide-mouse-pointer-2",
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4.037 4.688a.495.495 0 0 1 .651-.651l16 6.5a.5.5 0 0 1-.063.947l-6.124 1.58a2 2 0 0 0-1.438 1.435l-1.579 6.126a.5.5 0 0 1-.947.063z" })
+    }
+  );
+};
+var MouseCursorAltIcon = ({ strokeWidth = 2.25 }) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: "16",
+      height: "16",
+      viewBox: "0 0 24 24",
+      fill: "currentColor",
+      stroke: "currentColor",
+      "stroke-width": strokeWidth / 2,
+      className: "lucide lucide-mouse-pointer2-icon lucide-mouse-pointer-2",
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M4.037 4.688a.495.495 0 0 1 .651-.651l16 6.5a.5.5 0 0 1-.063.947l-6.124 1.58a2 2 0 0 0-1.438 1.435l-1.579 6.126a.5.5 0 0 1-.947.063z" })
+    }
+  );
+};
+
+exports.MouseCursorAltIcon = MouseCursorAltIcon;
+exports.MouseCursorIcon = MouseCursorIcon;

package/dist/{chunk-TCVTXU7U.cjs → chunk-A5LCX2UQ.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkDWD754BX_cjs = require('./chunk-DWD754BX.cjs');
+var chunkOHIB3TEN_cjs = require('./chunk-OHIB3TEN.cjs');
 var chunkP6DICGAV_cjs = require('./chunk-P6DICGAV.cjs');
 var react = require('react');
 var reactDom = require('react-dom');
@@ -192,7 +192,7 @@ var CursorProvider = ({
       Component,
       {
         ...props,
-        className: chunkDWD754BX_cjs.cn(className),
+        className: chunkOHIB3TEN_cjs.cn(className),
         style: {
           cursor: isMouseInside && !hoveredElementId ? "none" : "auto",
           ...props.style

package/dist/{chunk-EWAKGFQG.mjs → chunk-ABLQ4QRY.mjs}

@@ -1,5 +1,5 @@
 import { createClientOnlyComponent } from './chunk-4F2GSF2T.mjs';
-import { cn } from './chunk-KVFUDYD3.mjs';
+import { cn } from './chunk-HMN4IKTG.mjs';
 import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
 import { cva } from 'class-variance-authority';
 import { createContext, useContext } from 'react';
@@ -58,7 +58,6 @@ var toggleGroupVariants = cva(
           "bg-bg-secondary",
           "hover:bg-group-hover",
           "border-solid border border-transparent -mr-[1px]",
-          "dark:border-solid dark:border dark:-mr-[1px]",
           "data-[state=on]:text-secondary-foreground",
           "data-[state=on]:bg-group-primary",
           "data-[state=on]:border-line-secondary",

package/dist/{chunk-ERN4HL5A.mjs → chunk-AZBJB6KC.mjs}

@@ -1,4 +1,4 @@
-import { cn } from './chunk-KVFUDYD3.mjs';
+import { cn } from './chunk-HMN4IKTG.mjs';
 import * as SwitchPrimitive from '@radix-ui/react-switch';
 import { jsx } from 'react/jsx-runtime';
 

package/dist/{chunk-3GYDDYRD.mjs → chunk-B53A4WNW.mjs}

@@ -1,6 +1,6 @@
 import { useTabsCursor, TabsCursorProvider } from './chunk-XMG3IVGZ.mjs';
 import { createClientOnlyComponent } from './chunk-4F2GSF2T.mjs';
-import { cn } from './chunk-KVFUDYD3.mjs';
+import { cn } from './chunk-HMN4IKTG.mjs';
 import * as TabsPrimitive from '@radix-ui/react-tabs';
 import { cva } from 'class-variance-authority';
 import { createContext, useContext } from 'react';

package/dist/{chunk-LHQALBTX.cjs → chunk-B55SNJJM.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkDWD754BX_cjs = require('./chunk-DWD754BX.cjs');
+var chunkOHIB3TEN_cjs = require('./chunk-OHIB3TEN.cjs');
 var CheckboxPrimitive = require('@radix-ui/react-checkbox');
 var lucideReact = require('lucide-react');
 var jsxRuntime = require('react/jsx-runtime');
@@ -29,7 +29,7 @@ var Checkbox = ({ className, checkall, ...props }) => /* @__PURE__ */ jsxRuntime
   CheckboxPrimitive__namespace.Root,
   {
     "data-slot": "checkbox",
-    className: chunkDWD754BX_cjs.cn(
+    className: chunkOHIB3TEN_cjs.cn(
       "group",
       "relative",
       "w-[16px]",
@@ -59,7 +59,7 @@ var Checkbox = ({ className, checkall, ...props }) => /* @__PURE__ */ jsxRuntime
       CheckboxPrimitive__namespace.Indicator,
       {
         "data-slot": "checkbox-indicator",
-        className: chunkDWD754BX_cjs.cn(
+        className: chunkOHIB3TEN_cjs.cn(
           "absolute",
           "inset-0",
           "m-auto",
@@ -73,7 +73,7 @@ var Checkbox = ({ className, checkall, ...props }) => /* @__PURE__ */ jsxRuntime
       CheckboxPrimitive__namespace.Indicator,
       {
         "data-slot": "checkbox-indicator",
-        className: chunkDWD754BX_cjs.cn(
+        className: chunkOHIB3TEN_cjs.cn(
           "flex",
           "items-center",
           "justify-center",

package/dist/chunk-BAQY2ANP.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var chunkT2RTITL6_cjs = require('./chunk-T2RTITL6.cjs');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+var DegInput = react.forwardRef(function DegInput2({ value = 0, onChange, ...props }, ref) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    chunkT2RTITL6_cjs.InputNumbers,
+    {
+      ref,
+      value: [value],
+      onValuesChange: (values) => onChange?.(values[0]),
+      suffix: ["\xB0"],
+      ...props
+    }
+  );
+});
+
+exports.DegInput = DegInput;

package/dist/{chunk-F6VF4JAI.mjs → chunk-BCBWIMPS.mjs}

@@ -1,4 +1,4 @@
-import { cn } from './chunk-KVFUDYD3.mjs';
+import { cn } from './chunk-HMN4IKTG.mjs';
 import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
 import { jsx } from 'react/jsx-runtime';
 

package/dist/{chunk-CGFJLQRG.mjs → chunk-BEJIZ56L.mjs}

@@ -1,5 +1,5 @@
 import { useSyncScroll, useScrollSlave, useSyncDrag } from './chunk-SAGQV2YZ.mjs';
-import { cn } from './chunk-KVFUDYD3.mjs';
+import { cn } from './chunk-HMN4IKTG.mjs';
 import { Slot } from '@radix-ui/react-slot';
 import { useState, useRef, useEffect } from 'react';
 import { jsx } from 'react/jsx-runtime';
@@ -239,5 +239,62 @@ var SyncDragSlaveX = ({
     }
   );
 };
+var SyncDragY = ({
+  ref: extRef,
+  children,
+  className,
+  asChild = false,
+  ...props
+}) => {
+  const ref = useSyncDrag({ ref: extRef, axis: "vertical" });
+  const [isDragging, setIsDragging] = useState(false);
+  const dragStartY = useRef(0);
+  const scrollStartTop = useRef(0);
+  useEffect(() => {
+    const element = ref.current;
+    if (!element) return;
+    const handleMouseDown = (e) => {
+      setIsDragging(true);
+      dragStartY.current = e.clientY;
+      scrollStartTop.current = element.scrollTop;
+      e.preventDefault();
+    };
+    const handleMouseMove = (e) => {
+      if (!isDragging || !element) return;
+      const deltaY = e.clientY - dragStartY.current;
+      element.scrollTop = scrollStartTop.current - deltaY * 2;
+    };
+    const handleMouseUp = () => {
+      setIsDragging(false);
+    };
+    element.addEventListener("mousedown", handleMouseDown);
+    if (isDragging) {
+      document.addEventListener("mousemove", handleMouseMove);
+      document.addEventListener("mouseup", handleMouseUp);
+      document.addEventListener("mouseleave", handleMouseUp);
+    }
+    return () => {
+      element.removeEventListener("mousedown", handleMouseDown);
+      document.removeEventListener("mousemove", handleMouseMove);
+      document.removeEventListener("mouseup", handleMouseUp);
+      document.removeEventListener("mouseleave", handleMouseUp);
+    };
+  }, [isDragging, ref]);
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx(
+    Comp,
+    {
+      ref,
+      className: cn(
+        "cursor-grab overflow-x-hidden overflow-y-auto",
+        isDragging && "cursor-grabbing",
+        className
+      ),
+      style: { userSelect: isDragging ? "none" : "auto", ...props.style },
+      ...props,
+      children
+    }
+  );
+};
 
-export { SyncDrag, SyncDragSlave, SyncDragSlaveX, SyncDragX, SyncScroll, SyncScrollSlave };
+export { SyncDrag, SyncDragSlave, SyncDragSlaveX, SyncDragX, SyncDragY, SyncScroll, SyncScrollSlave };

package/dist/{chunk-NMSI7U5J.mjs → chunk-BGYHKHMQ.mjs}

@@ -1,4 +1,4 @@
-import { cn } from './chunk-KVFUDYD3.mjs';
+import { cn } from './chunk-HMN4IKTG.mjs';
 import { Slot } from '@radix-ui/react-slot';
 import { jsx } from 'react/jsx-runtime';
 

package/dist/chunk-CIPI2V54.mjs

@@ -0,0 +1,66 @@
+import { useRef, useEffect, useCallback } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/ui/waterfall/WheelZoomContext.tsx
+function WheelZoomContext({
+  ref,
+  className,
+  viewStart,
+  viewDuration,
+  onViewStartChange,
+  onWindowChange,
+  minWindow = 0.01,
+  maxWindow = Infinity,
+  zoomFactor = 1.1,
+  enabled = true,
+  children
+}) {
+  const localRef = useRef(null);
+  const containerRef = ref || localRef;
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container || !enabled) return;
+    const preventScroll = (e) => {
+      e.preventDefault();
+    };
+    container.addEventListener("wheel", preventScroll, { passive: false });
+    return () => {
+      container.removeEventListener("wheel", preventScroll);
+    };
+  }, [enabled]);
+  const handleWheel = useCallback(
+    (e) => {
+      if (!enabled) return;
+      const container = containerRef.current;
+      if (!container) return;
+      if (e.shiftKey || e.altKey) {
+        const rect = container.getBoundingClientRect();
+        const cursorX = e.clientX - rect.left;
+        const cursorRatio = cursorX / container.offsetWidth;
+        const timeAtCursor = viewStart + cursorRatio * viewDuration;
+        const scaleFactor = e.deltaY < 0 ? 1 / zoomFactor : zoomFactor;
+        const newDuration = Math.max(minWindow, Math.min(maxWindow, viewDuration * scaleFactor));
+        if (newDuration === viewDuration) return;
+        const newViewStart = timeAtCursor - cursorRatio * newDuration;
+        onWindowChange(newDuration);
+        onViewStartChange(newViewStart);
+      } else {
+        const panAmount = (e.deltaX + e.deltaY) / container.offsetWidth * viewDuration;
+        onViewStartChange(viewStart + panAmount);
+      }
+    },
+    [
+      enabled,
+      viewStart,
+      viewDuration,
+      onViewStartChange,
+      onWindowChange,
+      minWindow,
+      maxWindow,
+      zoomFactor
+    ]
+  );
+  return /* @__PURE__ */ jsx("div", { ref: containerRef, className, onWheel: handleWheel, children });
+}
+
+export { WheelZoomContext };