@vuer-ai/vuer-uikit 0.0.45 → 0.0.47

package/dist/{chunk-MFXAWZIK.mjs → chunk-3WAI7WDK.mjs}

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

package/dist/chunk-4HJQPZQ2.js

@@ -0,0 +1,139 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/ui/drag-selectable/DragSelectProvider.tsx
+var DragSelectContext = react.createContext(void 0);
+var DragSelectProvider = ({ children }) => {
+  const [selectedItems, setSelectedItems] = react.useState(/* @__PURE__ */ new Set());
+  const [isDragging, setIsDragging] = react.useState(false);
+  const dragStartId = react.useRef(null);
+  const dragMode = react.useRef("replace");
+  const dragStartSelection = react.useRef(/* @__PURE__ */ new Set());
+  const registeredItems = react.useRef(/* @__PURE__ */ new Map());
+  const registerItem = react.useCallback((id, index) => {
+    registeredItems.current.set(id, index);
+  }, []);
+  const unregisterItem = react.useCallback((id) => {
+    registeredItems.current.delete(id);
+  }, []);
+  const startDrag = react.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 = react.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 = react.useCallback(() => {
+    setIsDragging(false);
+    dragStartId.current = null;
+  }, []);
+  const clearSelection = react.useCallback(() => {
+    setSelectedItems(/* @__PURE__ */ new Set());
+  }, []);
+  const isSelected = react.useCallback(
+    (id) => {
+      return selectedItems.has(id);
+    },
+    [selectedItems]
+  );
+  react.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__ */ jsxRuntime.jsx(
+    DragSelectContext.Provider,
+    {
+      value: {
+        selectedItems,
+        isDragging,
+        registerItem,
+        unregisterItem,
+        startDrag,
+        updateSelection,
+        endDrag,
+        clearSelection,
+        isSelected
+      },
+      children
+    }
+  );
+};
+var useDragSelectContext = () => {
+  const context = react.useContext(DragSelectContext);
+  if (context === void 0) {
+    throw new Error("useDragSelectContext must be used within a DragSelectProvider");
+  }
+  return context;
+};
+
+exports.DragSelectProvider = DragSelectProvider;
+exports.useDragSelectContext = useDragSelectContext;

package/dist/{chunk-THPNMIDZ.mjs → chunk-5VYIGLGB.mjs}

@@ -1,7 +1,7 @@
 import { Badge } from './chunk-IZCHLZ4H.mjs';
 import { jsx } from 'react/jsx-runtime';
 
-var PACKAGE_VERSION = "0.0.45" ;
+var PACKAGE_VERSION = "0.0.47" ;
 var PACKAGE_NAME = "@vuer-ai/vuer-uikit" ;
 function VersionBadge({
   className,

package/dist/{chunk-NC6NIC5C.js → chunk-BGXUSJT2.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkXWC6N2UQ_js = require('./chunk-XWC6N2UQ.js');
+var chunkVEUXQSY3_js = require('./chunk-VEUXQSY3.js');
 var chunkER6XHUS7_js = require('./chunk-ER6XHUS7.js');
 var chunk7KYAICHB_js = require('./chunk-7KYAICHB.js');
 var lucideReact = require('lucide-react');
@@ -510,7 +510,7 @@ function Timeline({
   }, [viewStart, viewDuration, updateCursor]);
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-bg-primary text-text-primary border-line-secondary/20 rounded-uk-md mx-auto w-full max-w-7xl overflow-hidden border font-sans shadow-[0_4px_16px_0_var(--color-shadow-secondary)]", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid grid-cols-[minmax(300px,30%)_1fr]", children: [
     /* @__PURE__ */ jsxRuntime.jsx(
-      chunkXWC6N2UQ_js.TreeView,
+      chunkVEUXQSY3_js.TreeView,
       {
         data,
         getIcon,

package/dist/{chunk-RFVRJ4XV.js → chunk-IMIHCOOE.js}

@@ -3,7 +3,7 @@
 var chunkILJK43VJ_js = require('./chunk-ILJK43VJ.js');
 var jsxRuntime = require('react/jsx-runtime');
 
-var PACKAGE_VERSION = "0.0.45" ;
+var PACKAGE_VERSION = "0.0.47" ;
 var PACKAGE_NAME = "@vuer-ai/vuer-uikit" ;
 function VersionBadge({
   className,

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-KHROZRRE.mjs

@@ -0,0 +1 @@
+

package/dist/chunk-QQMHPZFI.js

@@ -0,0 +1,92 @@
+'use strict';
+
+var react = require('react');
+
+// src/hooks/useDragSelect.ts
+function useDragSelect(options = {}) {
+  const [selectedItems, setSelectedItems] = react.useState(/* @__PURE__ */ new Set());
+  const [isDragging, setIsDragging] = react.useState(false);
+  const [dragMode, setDragMode] = react.useState("toggle");
+  react.useEffect(() => {
+    var _a;
+    (_a = options.onSelectionChange) == null ? void 0 : _a.call(options, selectedItems);
+  }, [selectedItems, options.onSelectionChange]);
+  const handleMouseDown = react.useCallback((id, e) => {
+    e.preventDefault();
+    setIsDragging(true);
+    const mode = e.ctrlKey || e.metaKey ? "replace" : "toggle";
+    setDragMode(mode);
+    if (mode === "replace") {
+      setSelectedItems(/* @__PURE__ */ new Set([id]));
+    } else {
+      setSelectedItems((prev) => {
+        const newSet = new Set(prev);
+        if (newSet.has(id)) {
+          newSet.delete(id);
+        } else {
+          newSet.add(id);
+        }
+        return newSet;
+      });
+    }
+  }, []);
+  const handleMouseEnter = react.useCallback(
+    (id) => {
+      if (!isDragging) return;
+      if (dragMode === "replace") {
+        setSelectedItems((prev) => /* @__PURE__ */ new Set([...prev, id]));
+      } else {
+        setSelectedItems((prev) => {
+          const newSet = new Set(prev);
+          if (newSet.has(id)) {
+            newSet.delete(id);
+          } else {
+            newSet.add(id);
+          }
+          return newSet;
+        });
+      }
+    },
+    [isDragging, dragMode]
+  );
+  react.useCallback(() => {
+    setIsDragging(false);
+  }, []);
+  const clearSelection = react.useCallback(() => {
+    setSelectedItems(/* @__PURE__ */ new Set());
+  }, []);
+  const isSelected = react.useCallback(
+    (id) => selectedItems.has(id),
+    [selectedItems]
+  );
+  const getItemProps = react.useCallback(
+    (id) => ({
+      "data-selected": selectedItems.has(id),
+      onMouseDown: (e) => handleMouseDown(id, e),
+      onMouseEnter: () => handleMouseEnter(id)
+    }),
+    [selectedItems, handleMouseDown, handleMouseEnter]
+  );
+  react.useEffect(() => {
+    const handleGlobalMouseUp = () => setIsDragging(false);
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        clearSelection();
+      }
+    };
+    document.addEventListener("mouseup", handleGlobalMouseUp);
+    document.addEventListener("keydown", handleEscape);
+    return () => {
+      document.removeEventListener("mouseup", handleGlobalMouseUp);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [clearSelection]);
+  return {
+    selectedItems,
+    isSelected,
+    clearSelection,
+    getItemProps
+  };
+}
+
+exports.useDragSelect = useDragSelect;

package/dist/chunk-TVKPO5VK.mjs

@@ -0,0 +1,32 @@
+import { useDragSelectContext } from './chunk-JBQP2CBI.mjs';
+import { useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+function createSelectable(Component) {
+  return function SelectableComponent(props) {
+    const { registerItem, unregisterItem, startDrag, updateSelection, isSelected } = useDragSelectContext();
+    const { id, index } = props;
+    useEffect(() => {
+      registerItem(id, index);
+      return () => unregisterItem(id);
+    }, [id, index, registerItem, unregisterItem]);
+    const handleMouseDown = (e) => {
+      const mode = e.ctrlKey || e.metaKey ? "replace" : "toggle";
+      startDrag(id, mode);
+    };
+    const handleMouseEnter = () => {
+      updateSelection(id);
+    };
+    return /* @__PURE__ */ jsx(
+      Component,
+      {
+        ...props,
+        isSelected: isSelected(id),
+        onMouseDown: handleMouseDown,
+        onMouseEnter: handleMouseEnter
+      }
+    );
+  };
+}
+
+export { createSelectable };

package/dist/chunk-UZFOWGVD.mjs

@@ -0,0 +1,90 @@
+import { useState, useEffect, useCallback } from 'react';
+
+// src/hooks/useDragSelect.ts
+function useDragSelect(options = {}) {
+  const [selectedItems, setSelectedItems] = useState(/* @__PURE__ */ new Set());
+  const [isDragging, setIsDragging] = useState(false);
+  const [dragMode, setDragMode] = useState("toggle");
+  useEffect(() => {
+    var _a;
+    (_a = options.onSelectionChange) == null ? void 0 : _a.call(options, selectedItems);
+  }, [selectedItems, options.onSelectionChange]);
+  const handleMouseDown = useCallback((id, e) => {
+    e.preventDefault();
+    setIsDragging(true);
+    const mode = e.ctrlKey || e.metaKey ? "replace" : "toggle";
+    setDragMode(mode);
+    if (mode === "replace") {
+      setSelectedItems(/* @__PURE__ */ new Set([id]));
+    } else {
+      setSelectedItems((prev) => {
+        const newSet = new Set(prev);
+        if (newSet.has(id)) {
+          newSet.delete(id);
+        } else {
+          newSet.add(id);
+        }
+        return newSet;
+      });
+    }
+  }, []);
+  const handleMouseEnter = useCallback(
+    (id) => {
+      if (!isDragging) return;
+      if (dragMode === "replace") {
+        setSelectedItems((prev) => /* @__PURE__ */ new Set([...prev, id]));
+      } else {
+        setSelectedItems((prev) => {
+          const newSet = new Set(prev);
+          if (newSet.has(id)) {
+            newSet.delete(id);
+          } else {
+            newSet.add(id);
+          }
+          return newSet;
+        });
+      }
+    },
+    [isDragging, dragMode]
+  );
+  useCallback(() => {
+    setIsDragging(false);
+  }, []);
+  const clearSelection = useCallback(() => {
+    setSelectedItems(/* @__PURE__ */ new Set());
+  }, []);
+  const isSelected = useCallback(
+    (id) => selectedItems.has(id),
+    [selectedItems]
+  );
+  const getItemProps = useCallback(
+    (id) => ({
+      "data-selected": selectedItems.has(id),
+      onMouseDown: (e) => handleMouseDown(id, e),
+      onMouseEnter: () => handleMouseEnter(id)
+    }),
+    [selectedItems, handleMouseDown, handleMouseEnter]
+  );
+  useEffect(() => {
+    const handleGlobalMouseUp = () => setIsDragging(false);
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        clearSelection();
+      }
+    };
+    document.addEventListener("mouseup", handleGlobalMouseUp);
+    document.addEventListener("keydown", handleEscape);
+    return () => {
+      document.removeEventListener("mouseup", handleGlobalMouseUp);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [clearSelection]);
+  return {
+    selectedItems,
+    isSelected,
+    clearSelection,
+    getItemProps
+  };
+}
+
+export { useDragSelect };

package/dist/{chunk-XWC6N2UQ.js → chunk-VEUXQSY3.js}

@@ -224,7 +224,7 @@ function TreeView({
                     "button",
                     {
                       onClick: () => toggleItem(item.id),
-                      className: "absolute z-20 flex items-center justify-center opacity-0 transition-opacity group-hover:opacity-100",
+                      className: "absolute z-20 flex cursor-pointer items-center justify-center opacity-0 transition-opacity group-hover:opacity-100",
                       children: /* @__PURE__ */ jsxRuntime.jsx(
                         lucideReact.ChevronDown,
                         {
@@ -240,7 +240,7 @@ function TreeView({
                     "div",
                     {
                       className: chunk7KYAICHB_js.cn(
-                        "transition-opacity",
+                        "cursor-pointer transition-opacity",
                         item.isCollapsible && "group-hover:opacity-0"
                       ),
                       children: getIcon(item)

package/dist/chunk-WRF3C24J.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var chunk4HJQPZQ2_js = require('./chunk-4HJQPZQ2.js');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function createSelectable(Component) {
+  return function SelectableComponent(props) {
+    const { registerItem, unregisterItem, startDrag, updateSelection, isSelected } = chunk4HJQPZQ2_js.useDragSelectContext();
+    const { id, index } = props;
+    react.useEffect(() => {
+      registerItem(id, index);
+      return () => unregisterItem(id);
+    }, [id, index, registerItem, unregisterItem]);
+    const handleMouseDown = (e) => {
+      const mode = e.ctrlKey || e.metaKey ? "replace" : "toggle";
+      startDrag(id, mode);
+    };
+    const handleMouseEnter = () => {
+      updateSelection(id);
+    };
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Component,
+      {
+        ...props,
+        isSelected: isSelected(id),
+        onMouseDown: handleMouseDown,
+        onMouseEnter: handleMouseEnter
+      }
+    );
+  };
+}
+
+exports.createSelectable = createSelectable;

package/dist/{chunk-LD654LL2.mjs → chunk-YGSTPCLB.mjs}

@@ -222,7 +222,7 @@ function TreeView({
                     "button",
                     {
                       onClick: () => toggleItem(item.id),
-                      className: "absolute z-20 flex items-center justify-center opacity-0 transition-opacity group-hover:opacity-100",
+                      className: "absolute z-20 flex cursor-pointer items-center justify-center opacity-0 transition-opacity group-hover:opacity-100",
                       children: /* @__PURE__ */ jsx(
                         ChevronDown,
                         {
@@ -238,7 +238,7 @@ function TreeView({
                     "div",
                     {
                       className: cn(
-                        "transition-opacity",
+                        "cursor-pointer transition-opacity",
                         item.isCollapsible && "group-hover:opacity-0"
                       ),
                       children: getIcon(item)

package/dist/chunk-YQKZSWI6.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/highlight-cursor/cursor-context.d.mts

@@ -0,0 +1,7 @@
+import * as react from 'react';
+import { CursorContextType } from './types.mjs';
+
+declare const CursorContext: react.Context<CursorContextType>;
+declare const useCursor: () => CursorContextType;
+
+export { CursorContext, useCursor };

package/dist/highlight-cursor/cursor-context.d.ts

@@ -0,0 +1,7 @@
+import * as react from 'react';
+import { CursorContextType } from './types.js';
+
+declare const CursorContext: react.Context<CursorContextType>;
+declare const useCursor: () => CursorContextType;
+
+export { CursorContext, useCursor };

package/dist/highlight-cursor/cursor-provider.d.mts

@@ -0,0 +1,7 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { CursorProviderProps } from './types.mjs';
+import 'react';
+
+declare const CursorProvider: ({ children, maxOffsetX, maxOffsetY, cursorSize, transitionDuration, cursorClassName, className, as: Component, ...props }: CursorProviderProps) => react_jsx_runtime.JSX.Element;
+
+export { CursorProvider };

package/dist/highlight-cursor/cursor-provider.d.ts

@@ -0,0 +1,7 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { CursorProviderProps } from './types.js';
+import 'react';
+
+declare const CursorProvider: ({ children, maxOffsetX, maxOffsetY, cursorSize, transitionDuration, cursorClassName, className, as: Component, ...props }: CursorProviderProps) => react_jsx_runtime.JSX.Element;
+
+export { CursorProvider };

package/dist/highlight-cursor/enhanced-components.d.mts

@@ -0,0 +1,20 @@
+import { EnhancedComponentProps } from './types.mjs';
+import * as react from 'react';
+import { Textarea } from '../ui/textarea.mjs';
+import { TabsProps } from '../ui/tabs.mjs';
+import { ButtonProps } from '../ui/button.mjs';
+import { InputRootProps } from '../ui/input.mjs';
+import { SelectTrigger } from '../ui/select.mjs';
+import 'react/jsx-runtime';
+import 'class-variance-authority/types';
+import 'class-variance-authority';
+import '@radix-ui/react-tabs';
+import '@radix-ui/react-select';
+
+declare const CursorButton: react.ForwardRefExoticComponent<Omit<EnhancedComponentProps<Omit<ButtonProps, "ref"> & react.RefAttributes<HTMLButtonElement>>, "ref"> & react.RefAttributes<HTMLElement>>;
+declare const CursorTabs: react.ForwardRefExoticComponent<Omit<EnhancedComponentProps<TabsProps>, "ref"> & react.RefAttributes<HTMLElement>>;
+declare const CursorInputRoot: react.ForwardRefExoticComponent<Omit<EnhancedComponentProps<Omit<InputRootProps, "ref"> & react.RefAttributes<HTMLInputElement>>, "ref"> & react.RefAttributes<HTMLElement>>;
+declare const CursorSelectTrigger: typeof SelectTrigger;
+declare const CursorTextarea: typeof Textarea;
+
+export { CursorButton, CursorInputRoot, CursorSelectTrigger, CursorTabs, CursorTextarea };