@vuer-ai/vuer-uikit 0.0.19 → 0.0.21

package/dist/chunk-SKO72K64.js

@@ -0,0 +1,118 @@
+'use strict';
+
+var chunkXXWQ4RVP_js = require('./chunk-XXWQ4RVP.js');
+var reactComposeRefs = require('@radix-ui/react-compose-refs');
+var classVarianceAuthority = require('class-variance-authority');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+var inputRootVariants = classVarianceAuthority.cva(
+  [
+    "px-1.5",
+    "flex",
+    "gap-md",
+    "items-center",
+    "rounded-uk-sm",
+    "overflow-hidden",
+    "bg-bg-secondary"
+  ],
+  {
+    variants: {
+      state: {
+        default: ["hover:bg-bg-tertiary", "has-[input:focus]:bg-bg-quaternary"],
+        disabled: ["disabled:cursor-not-allowed", "bg-bg-tertiary", "text-text-tertiary"],
+        error: ["hover:bg-danger-primary/10", "bg-danger-primary/20"]
+      },
+      size: {
+        sm: ["h-5.5", "text-uk-sm", "[&_.input-slot>svg:not([class*='size-'])]:size-lg"],
+        base: ["h-7", "text-uk-md", "[&_.input-slot>svg:not([class*='size-'])]:size-[14px]"],
+        lg: ["h-8", "text-uk-lg", "[&_.input-slot>svg:not([class*='size-'])]:size-xl"]
+      }
+    },
+    defaultVariants: {
+      state: "default",
+      size: "base"
+    }
+  }
+);
+var InputRoot = react.forwardRef(function InputRoot2({ style, className, side, children, disabled, state, size, type, inputClassName, ...props }, ref) {
+  const inputRef = react.useRef(null);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style,
+      "data-input": true,
+      className: chunkXXWQ4RVP_js.cn(inputRootVariants({ size, state: disabled ? "disabled" : state }), className),
+      onClick: (event) => {
+        const target = event.target;
+        if (target.closest("input, button, a")) return;
+        const input = inputRef.current;
+        if (!input) return;
+        const isRightSlot = target.closest(`
+            .input-slot[data-side='right'],
+            .input-slot:not([data-side='right']) ~ .input-slot:not([data-side='left'])
+          `);
+        const cursorPosition = isRightSlot ? input.value.length : 0;
+        requestAnimationFrame(() => {
+          try {
+            input.setSelectionRange(cursorPosition, cursorPosition);
+          } catch {
+          }
+          input.focus();
+        });
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            spellCheck: "false",
+            ...props,
+            type,
+            "data-side": side,
+            disabled,
+            name: type ?? "text",
+            ref: reactComposeRefs.composeRefs(inputRef, ref),
+            className: chunkXXWQ4RVP_js.cn(
+              [
+                "w-full",
+                "h-full",
+                "outline-none",
+                "data-[side=right]:text-right",
+                "[input[type=number]]:font-number-input",
+                "[&::-webkit-inner-spin-button]:appearance-none",
+                "[&::-webkit-outer-spin-button]:appearance-none"
+              ],
+              inputClassName
+            )
+          }
+        ),
+        children
+      ]
+    }
+  );
+});
+var InputSlot = react.forwardRef(function({ className, children, side = "left", ...props }, ref) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-side": side,
+      ...props,
+      ref,
+      className: chunkXXWQ4RVP_js.cn(
+        [
+          "input-slot",
+          "cursor-text",
+          "shrink-0",
+          "order-[0]",
+          "text-text-tertiary",
+          "data-[side=left]:-order-1"
+        ],
+        className
+      ),
+      children
+    }
+  );
+});
+
+exports.InputRoot = InputRoot;
+exports.InputSlot = InputSlot;

package/dist/chunk-T3VSSE2L.mjs

@@ -0,0 +1,165 @@
+import { cn } from './chunk-KTNZSZ5Y.mjs';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import { forwardRef, useState, useMemo } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var Slider = forwardRef(function Slider2({
+  className,
+  defaultValue,
+  value,
+  onValueChange,
+  showStep = false,
+  step = 1,
+  min = 0,
+  max = 100,
+  ...props
+}, ref) {
+  const [currentValue, setCurrentValue] = useState(value ?? defaultValue ?? [0]);
+  const _values = useMemo(
+    () => Array.isArray(value) ? value : Array.isArray(defaultValue) ? defaultValue : [min, max],
+    [value, defaultValue, min, max]
+  );
+  return /* @__PURE__ */ jsxs(
+    SliderPrimitive.Root,
+    {
+      "data-slot": "slider",
+      value,
+      defaultValue,
+      onValueChange: (v) => {
+        onValueChange == null ? void 0 : onValueChange(v);
+        setCurrentValue(v);
+      },
+      ref,
+      min,
+      max,
+      step,
+      className: cn(
+        "relative",
+        "flex",
+        "w-full",
+        "touch-none",
+        "select-none",
+        "items-center",
+        "data-[orientation=vertical]:h-full",
+        "data-[orientation=vertical]:min-h-44",
+        "data-[orientation=vertical]:w-auto",
+        "data-[orientation=vertical]:flex-col",
+        className
+      ),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx(
+          SliderPrimitive.Track,
+          {
+            "data-slot": "slider-track",
+            className: cn(
+              "peer/slider-track",
+              "bg-line-primary",
+              "relative",
+              "grow",
+              "overflow-hidden",
+              "rounded-full",
+              "data-[disabled]:bg-bg-secondary",
+              "data-[orientation=vertical]:w-0.5",
+              "data-[orientation=vertical]:h-full",
+              "data-[orientation=horizontal]:h-0.5",
+              "data-[orientation=horizontal]:w-full"
+            ),
+            children: /* @__PURE__ */ jsx(
+              SliderPrimitive.Range,
+              {
+                "data-slot": "slider-range",
+                className: cn(
+                  "bg-brand-primary",
+                  "absolute",
+                  "data-[disabled]:bg-bg-secondary",
+                  "data-[orientation=vertical]:w-full",
+                  "data-[orientation=horizontal]:h-full"
+                )
+              }
+            )
+          }
+        ),
+        showStep && /* @__PURE__ */ jsx(SliderSteps, { currentValue, max, min, step }),
+        Array.from({ length: _values.length }, (_, index) => /* @__PURE__ */ jsx(
+          SliderPrimitive.Thumb,
+          {
+            "data-slot": "slider-thumb",
+            className: cn(
+              "ring-brand-primary/50",
+              "bg-brand-primary",
+              "block",
+              "h-4",
+              "w-[0.6rem]",
+              "shrink-0",
+              "rounded-[3px]",
+              "transition-[color,box-shadow]",
+              "hover:ring-4",
+              "hover:cursor-ew-resize",
+              "focus-visible:ring-4",
+              "focus-visible:outline-hidden",
+              "data-[disabled]:bg-bg-tertiary",
+              "data-[disabled]:pointer-events-none"
+            )
+          },
+          index
+        ))
+      ]
+    }
+  );
+});
+function SliderSteps({ step, min, max, currentValue }) {
+  const steps = useMemo(() => {
+    const value = max - min;
+    const stepCount = Math.ceil(value / step);
+    return Array.from({ length: stepCount + 1 }, (_, i) => {
+      return { position: Math.min(100 / value * (i * step), 100), v: i * step + min };
+    });
+  }, [max, min, step]);
+  const [minRange, maxRange] = useMemo(() => {
+    if (currentValue.length > 1) {
+      return [Math.min(...currentValue), Math.max(...currentValue)];
+    } else {
+      return [0, ...currentValue];
+    }
+  }, [currentValue]);
+  return steps.map((step2, i) => {
+    const thumbInBoundsOffset = getThumbInBoundsOffset(9.6, step2.position, 1);
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        "data-slot": "slider-step",
+        style: { left: `calc(${step2.position}% + ${thumbInBoundsOffset}px)` },
+        className: cn(
+          "absolute",
+          "top-1/2",
+          "translate-y-[-50%]",
+          "translate-x-[-50%]",
+          "bg-brand-primary",
+          "block",
+          "h-[5pt]",
+          "w-[1pt]",
+          "shrink-0",
+          "rounded-[1px]",
+          "peer-has-data-[disabled]/slider-track:bg-bg-tertiary",
+          { "bg-bg-tertiary": step2.v < minRange || step2.v > maxRange }
+        )
+      },
+      i
+    );
+  });
+}
+function getThumbInBoundsOffset(width, left, direction) {
+  const halfWidth = width / 2;
+  const halfPercent = 50;
+  const offset = linearScale([0, halfPercent], [0, halfWidth]);
+  return (halfWidth - offset(left) * direction) * direction;
+}
+function linearScale(input, output) {
+  return (value) => {
+    const ratio = (output[1] - output[0]) / (input[1] - input[0]);
+    return output[0] + ratio * (value - input[0]);
+  };
+}
+
+export { Slider };

package/dist/chunk-TMBKCIVQ.mjs

@@ -0,0 +1,148 @@
+import { cn } from './chunk-KTNZSZ5Y.mjs';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { cva } from 'class-variance-authority';
+import { XIcon } from 'lucide-react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+function Modal({ ...props }) {
+  return /* @__PURE__ */ jsx(DialogPrimitive.Root, { "data-slot": "modal", ...props });
+}
+function ModalTrigger({ ...props }) {
+  return /* @__PURE__ */ jsx(DialogPrimitive.Trigger, { "data-slot": "modal-trigger", ...props });
+}
+function ModalPortal({ ...props }) {
+  return /* @__PURE__ */ jsx(DialogPrimitive.Portal, { "data-slot": "modal-portal", ...props });
+}
+function ModalClose({ ...props }) {
+  return /* @__PURE__ */ jsx(DialogPrimitive.Close, { "data-slot": "modal-close", ...props });
+}
+var modalOverlayVariants = cva([
+  "fixed",
+  "inset-0",
+  "z-100",
+  "bg-bg-mask",
+  "transition-all",
+  "duration-200"
+]);
+function ModalOverlay({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    DialogPrimitive.Overlay,
+    {
+      "data-slot": "modal-overlay",
+      className: cn(modalOverlayVariants(), className),
+      ...props
+    }
+  );
+}
+var modalContentVariants = cva([
+  "pb-xl",
+  "px-xl",
+  "bg-bg-primary",
+  "rounded-uk-xl",
+  "shadow-[0_4px_16px_0_var(--color-shadow-secondary)]",
+  "min-w-[280px]",
+  "duration-200",
+  "transition-all",
+  "fixed",
+  "translate-x-[-50%]",
+  "translate-y-[-50%]",
+  "z-101",
+  "left-1/2",
+  "top-1/2",
+  "data-[state=open]:animate-in",
+  "data-[state=closed]:animate-out",
+  "data-[state=closed]:fade-out-0",
+  "data-[state=open]:fade-in-0",
+  "data-[state=closed]:zoom-out-95",
+  "data-[state=open]:zoom-in-95",
+  "liquid:liquid-bg"
+]);
+function ModalContent({
+  className,
+  children,
+  showCloseButton = true,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxs(ModalPortal, { children: [
+    /* @__PURE__ */ jsx(ModalOverlay, {}),
+    /* @__PURE__ */ jsxs(
+      DialogPrimitive.Content,
+      {
+        "data-slot": "modal-content",
+        className: cn(modalContentVariants(), className),
+        ...props,
+        children: [
+          children,
+          showCloseButton && /* @__PURE__ */ jsxs(
+            DialogPrimitive.Close,
+            {
+              "data-slot": "modal-close",
+              className: cn(
+                "absolute",
+                "right-[16px]",
+                "top-[16px]",
+                "w-[16px]",
+                "h-[16px]",
+                "rounded-uk-sm",
+                "cursor-pointer",
+                "hover:text-icon-highlight",
+                "text-icon-primary",
+                "flex",
+                "items-center",
+                "justify-center"
+              ),
+              children: [
+                /* @__PURE__ */ jsx(XIcon, {}),
+                /* @__PURE__ */ jsx("span", { className: "sr-only", children: "Close" })
+              ]
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+function ModalHeader({ className, ...props }) {
+  return /* @__PURE__ */ jsx("div", { "data-slot": "modal-header", className: cn("flex flex-col", className), ...props });
+}
+function ModalTitle({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    DialogPrimitive.Title,
+    {
+      "data-slot": "modal-title",
+      className: cn(
+        "text-text-highlight",
+        "text-uk-lg",
+        "leading-uk-lg",
+        "font-medium",
+        "py-lg",
+        "px-xl",
+        "text-center",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function ModalDescription({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    DialogPrimitive.Description,
+    {
+      "data-slot": "modal-description",
+      className: cn("text-text-primary", "text-uk-md", "leading-uk-md", "text-start", className),
+      ...props
+    }
+  );
+}
+function ModalFooter({ className, ...props }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-slot": "modal-footer",
+      className: cn("w-full", "flex", "justify-end", "gap-xs", className),
+      ...props
+    }
+  );
+}
+
+export { Modal, ModalClose, ModalContent, ModalDescription, ModalFooter, ModalHeader, ModalOverlay, ModalPortal, ModalTitle, ModalTrigger };

package/dist/chunk-U2ZLDPOE.js

@@ -0,0 +1,261 @@
+'use strict';
+
+var chunkWJ7T7FAH_js = require('./chunk-WJ7T7FAH.js');
+var chunkXXWQ4RVP_js = require('./chunk-XXWQ4RVP.js');
+var lucideReact = require('lucide-react');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function TreeView({
+  data,
+  getIcon,
+  onVisibleDataChange,
+  onItemHover,
+  className,
+  hoveredId
+}) {
+  const [expandedItems, setExpandedItems] = react.useState(() => {
+    const initial = /* @__PURE__ */ new Set();
+    data.forEach((item) => {
+      if (item.isCollapsible) initial.add(item.id);
+    });
+    return initial;
+  });
+  const [searchQuery, setSearchQuery] = react.useState("");
+  const [isCaseSensitive, setIsCaseSensitive] = react.useState(false);
+  const [isRegex, setIsRegex] = react.useState(false);
+  const [isRegexValid, setIsRegexValid] = react.useState(true);
+  const toggleItem = (id) => {
+    setExpandedItems((prev) => {
+      const newSet = new Set(prev);
+      if (newSet.has(id)) {
+        newSet.delete(id);
+      } else {
+        newSet.add(id);
+      }
+      return newSet;
+    });
+  };
+  const childrenMap = react.useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    data.forEach((item) => {
+      if (!map.has(item.parentId)) {
+        map.set(item.parentId, []);
+      }
+      map.get(item.parentId).push(item);
+    });
+    return map;
+  }, [data]);
+  const dataWithMeta = react.useMemo(() => {
+    const dataMap = new Map(data.map((item) => [item.id, item]));
+    const getAncestors = (item) => {
+      const ancestors = [];
+      let current = item.parentId;
+      while (current) {
+        const parent = dataMap.get(current);
+        if (parent) {
+          ancestors.unshift(parent);
+          current = parent.parentId;
+        } else {
+          break;
+        }
+      }
+      return ancestors;
+    };
+    return data.map((item) => {
+      const siblings = childrenMap.get(item.parentId) || [];
+      const isLast = siblings.length > 0 && siblings[siblings.length - 1].id === item.id;
+      const ancestors = getAncestors(item);
+      const indent = ancestors.length;
+      return { ...item, indent, isLast, ancestors };
+    });
+  }, [data, childrenMap]);
+  const visibleData = react.useMemo(() => {
+    const dataMap = new Map(data.map((item) => [item.id, item]));
+    if (!searchQuery) {
+      const isVisible = (item) => {
+        return item.ancestors.every((ancestor) => expandedItems.has(ancestor.id));
+      };
+      return dataWithMeta.filter(isVisible);
+    }
+    const matchingAndAncestorIds = /* @__PURE__ */ new Set();
+    let regex = null;
+    if (isRegex) {
+      try {
+        regex = new RegExp(searchQuery, isCaseSensitive ? "" : "i");
+        if (!isRegexValid) setIsRegexValid(true);
+      } catch {
+        if (isRegexValid) setIsRegexValid(false);
+        return [];
+      }
+    }
+    data.forEach((item) => {
+      let labelMatches = false;
+      if (regex) {
+        labelMatches = regex.test(item.label);
+      } else {
+        const source = isCaseSensitive ? item.label : item.label.toLowerCase();
+        const query = isCaseSensitive ? searchQuery : searchQuery.toLowerCase();
+        labelMatches = source.includes(query);
+      }
+      if (labelMatches) {
+        matchingAndAncestorIds.add(item.id);
+        let current = item.parentId;
+        while (current) {
+          const parent = dataMap.get(current);
+          if (parent) {
+            matchingAndAncestorIds.add(parent.id);
+            current = parent.parentId;
+          } else {
+            break;
+          }
+        }
+      }
+    });
+    return dataWithMeta.filter((item) => matchingAndAncestorIds.has(item.id));
+  }, [searchQuery, dataWithMeta, expandedItems, isCaseSensitive, isRegex, isRegexValid, data]);
+  react.useEffect(() => {
+    onVisibleDataChange == null ? void 0 : onVisibleDataChange(visibleData);
+  }, [visibleData, onVisibleDataChange]);
+  const renderLabel = (label) => {
+    if (!searchQuery || !isRegexValid) {
+      return label;
+    }
+    let regex;
+    try {
+      regex = new RegExp(`(${searchQuery})`, isCaseSensitive ? "g" : "gi");
+    } catch {
+      return label;
+    }
+    const parts = label.split(regex);
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: parts.map(
+      (part, i) => i % 2 === 1 ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "rounded-uk-xs bg-yellow-300 dark:bg-yellow-700", children: part }, i) : part
+    ) });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: chunkXXWQ4RVP_js.cn("border-line-secondary/20 flex flex-col", className), children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "border-line-secondary/20 flex h-[32px] shrink-0 items-center gap-1 border-b px-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Search, { className: "text-text-secondary size-4" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "text",
+          placeholder: "Search...",
+          className: chunkXXWQ4RVP_js.cn(
+            "text-uk-md w-full bg-transparent focus:outline-none",
+            !isRegexValid && "text-red-500"
+          ),
+          value: searchQuery,
+          onChange: (e) => setSearchQuery(e.target.value)
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs(chunkWJ7T7FAH_js.TooltipProvider, { delayDuration: 200, children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(chunkWJ7T7FAH_js.Tooltip, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(chunkWJ7T7FAH_js.TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              onClick: () => setIsCaseSensitive((prev) => !prev),
+              className: chunkXXWQ4RVP_js.cn("rounded-uk-sm p-1", isCaseSensitive && "bg-bg-tertiary"),
+              children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.CaseSensitive, { className: "size-4" })
+            }
+          ) }),
+          /* @__PURE__ */ jsxRuntime.jsx(chunkWJ7T7FAH_js.TooltipContent, { children: /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Case Sensitive" }) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(chunkWJ7T7FAH_js.Tooltip, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(chunkWJ7T7FAH_js.TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              onClick: () => setIsRegex((prev) => !prev),
+              className: chunkXXWQ4RVP_js.cn("rounded-uk-sm p-1", isRegex && "bg-bg-tertiary"),
+              children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Regex, { className: "size-4" })
+            }
+          ) }),
+          /* @__PURE__ */ jsxRuntime.jsx(chunkWJ7T7FAH_js.TooltipContent, { children: /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Use Regular Expression" }) })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "overflow-y-auto", children: visibleData.map((item) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: chunkXXWQ4RVP_js.cn(
+          "group relative flex h-[32px] cursor-pointer items-center",
+          hoveredId === item.id && "bg-bg-secondary/80"
+        ),
+        onMouseEnter: () => onItemHover == null ? void 0 : onItemHover(item.id),
+        onMouseLeave: () => onItemHover == null ? void 0 : onItemHover(null),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "absolute top-0 left-[-0.28rem] z-0 flex h-full items-center", children: [
+            item.ancestors.map((ancestor, index) => {
+              var _a;
+              const parentIsLast = (_a = dataWithMeta.find((d) => d.id === ancestor.id)) == null ? void 0 : _a.isLast;
+              return /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  className: chunkXXWQ4RVP_js.cn(
+                    "h-full w-[1.25rem]",
+                    parentIsLast ? "" : "border-l",
+                    "border-line-secondary/20"
+                  )
+                },
+                index
+              );
+            }),
+            item.indent > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative h-full w-[1.24rem]", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  className: chunkXXWQ4RVP_js.cn(
+                    "absolute top-0 left-0 h-1/2 w-1/2 border-b border-l",
+                    item.isLast ? "rounded-bl-md" : "",
+                    "border-line-secondary/20"
+                  )
+                }
+              ),
+              !item.isLast && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "border-line-secondary/20 absolute top-1/2 left-0 h-1/2 w-1/2 border-l" })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              className: "text-uk-md z-10 flex w-full items-center gap-2 px-2 whitespace-nowrap",
+              style: { paddingLeft: `${item.indent * 1.25 + 0.5}rem` },
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative flex size-4 items-center justify-center", children: [
+                  item.isCollapsible && /* @__PURE__ */ jsxRuntime.jsx(
+                    "button",
+                    {
+                      onClick: () => toggleItem(item.id),
+                      className: "absolute z-20 flex items-center justify-center opacity-0 transition-opacity group-hover:opacity-100",
+                      children: /* @__PURE__ */ jsxRuntime.jsx(
+                        lucideReact.ChevronDown,
+                        {
+                          className: chunkXXWQ4RVP_js.cn(
+                            "size-4 transition-transform",
+                            !expandedItems.has(item.id) && "-rotate-90"
+                          )
+                        }
+                      )
+                    }
+                  ),
+                  /* @__PURE__ */ jsxRuntime.jsx(
+                    "div",
+                    {
+                      className: chunkXXWQ4RVP_js.cn(
+                        "transition-opacity",
+                        item.isCollapsible && "group-hover:opacity-0"
+                      ),
+                      children: getIcon(item)
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", children: renderLabel(item.label) })
+              ]
+            }
+          )
+        ]
+      },
+      item.id
+    )) })
+  ] });
+}
+
+exports.TreeView = TreeView;