flowcloudai-ui 0.0.0 → 0.1.0

package/dist/index.js

@@ -1,24 +1,2255 @@
-// src/Button.tsx
+// src/ThemeProvider.tsx
+import { createContext, useContext, useEffect, useState } from "react";
 import { jsx } from "react/jsx-runtime";
-function Button({ children, style, ...props }) {
-  return /* @__PURE__ */ jsx(
+var ThemeContext = createContext(null);
+function useTheme() {
+  const ctx = useContext(ThemeContext);
+  if (!ctx) throw new Error("useTheme must be used within <ThemeProvider>");
+  return ctx;
+}
+function getSystemTheme() {
+  return typeof window !== "undefined" && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function ThemeProvider({ children, defaultTheme = "system", target }) {
+  const [theme, setTheme] = useState(defaultTheme);
+  const [systemTheme, setSystemTheme] = useState(getSystemTheme);
+  const resolvedTheme = theme === "system" ? systemTheme : theme;
+  useEffect(() => {
+    const el = target ?? document.documentElement;
+    el.classList.remove("theme-light", "theme-dark");
+    el.classList.add(`theme-${resolvedTheme}`);
+    el.setAttribute("data-theme", resolvedTheme);
+    if (resolvedTheme === "dark") {
+      document.body.style.backgroundColor = "#0F0F0F";
+      document.body.style.color = "#E8E8E6";
+    } else {
+      document.body.style.backgroundColor = "";
+      document.body.style.color = "";
+    }
+  }, [resolvedTheme, target]);
+  useEffect(() => {
+    if (theme !== "system") return;
+    const mq = window.matchMedia("(prefers-color-scheme: dark)");
+    const handler = () => setSystemTheme(mq.matches ? "dark" : "light");
+    mq.addEventListener("change", handler);
+    return () => mq.removeEventListener("change", handler);
+  }, [theme]);
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value: { theme, resolvedTheme, setTheme }, children });
+}
+
+// src/components/Button/Button.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function Button({
+  variant = "primary",
+  size = "md",
+  disabled = false,
+  loading = false,
+  block = false,
+  circle = false,
+  iconOnly = false,
+  iconLeft,
+  iconRight,
+  className,
+  children,
+  ...props
+}) {
+  const classNames = [
+    "fc-btn",
+    `fc-btn--${variant}`,
+    `fc-btn--${size}`,
+    block && "fc-btn--block",
+    circle && "fc-btn--circle",
+    iconOnly && "fc-btn--icon-only",
+    loading && "is-loading",
+    disabled && "is-disabled",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs(
     "button",
     {
+      className: classNames,
+      disabled: disabled || loading,
+      ...props,
+      children: [
+        iconLeft && !loading && /* @__PURE__ */ jsx2("span", { className: "fc-btn__icon fc-btn__icon--left", children: iconLeft }),
+        children,
+        iconRight && !loading && /* @__PURE__ */ jsx2("span", { className: "fc-btn__icon fc-btn__icon--right", children: iconRight })
+      ]
+    }
+  );
+}
+function ButtonGroup({ children, className, ...props }) {
+  return /* @__PURE__ */ jsx2("div", { className: `fc-btn-group ${className ?? ""}`, ...props, children });
+}
+function ButtonToolbar({
+  children,
+  align = "left",
+  className,
+  ...props
+}) {
+  const alignClass = {
+    left: "",
+    center: "fc-btn-toolbar--center",
+    right: "fc-btn-toolbar--right",
+    between: "fc-btn-toolbar--between"
+  }[align];
+  return /* @__PURE__ */ jsx2("div", { className: `fc-btn-toolbar ${alignClass} ${className ?? ""}`, ...props, children });
+}
+
+// src/components/Button/CheckButton.tsx
+import * as React from "react";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function CheckButton({
+  checked: controlledChecked,
+  defaultChecked = false,
+  onChange,
+  disabled = false,
+  size = "md",
+  labelLeft,
+  labelRight,
+  className = "",
+  style
+}) {
+  const isControlled = controlledChecked !== void 0;
+  const [internalChecked, setInternalChecked] = React.useState(defaultChecked);
+  const checked = isControlled ? controlledChecked : internalChecked;
+  const toggle = () => {
+    if (disabled) return;
+    const next = !checked;
+    if (!isControlled) setInternalChecked(next);
+    onChange?.(next);
+  };
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" || e.key === " ") {
+      e.preventDefault();
+      toggle();
+    }
+  };
+  const cls = [
+    "fc-check",
+    `fc-check--${size}`,
+    checked && "fc-check--checked",
+    disabled && "fc-check--disabled",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      className: cls,
+      style,
+      role: "switch",
+      "aria-checked": checked,
+      tabIndex: disabled ? -1 : 0,
+      onClick: toggle,
+      onKeyDown: handleKeyDown,
+      children: [
+        labelLeft && /* @__PURE__ */ jsx3("span", { className: "fc-check__label", children: labelLeft }),
+        /* @__PURE__ */ jsx3("span", { className: "fc-check__track", children: /* @__PURE__ */ jsx3("span", { className: "fc-check__thumb", children: /* @__PURE__ */ jsx3("span", { className: "fc-check__thumb-inner" }) }) }),
+        labelRight && /* @__PURE__ */ jsx3("span", { className: "fc-check__label", children: labelRight })
+      ]
+    }
+  );
+}
+
+// src/components/Box/RollingBox.tsx
+import * as React2 from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function RollingBox({
+  showThumb = "auto",
+  horizontal = false,
+  vertical = true,
+  thumbSize = "normal",
+  showTrack = false,
+  children,
+  className,
+  ...props
+}) {
+  const containerRef = React2.useRef(null);
+  const [isScrolling, setIsScrolling] = React2.useState(false);
+  const scrollTimeoutRef = React2.useRef(null);
+  const handleScroll = React2.useCallback(() => {
+    if (showThumb !== "auto") return;
+    setIsScrolling(true);
+    if (scrollTimeoutRef.current) {
+      clearTimeout(scrollTimeoutRef.current);
+    }
+    scrollTimeoutRef.current = setTimeout(() => {
+      setIsScrolling(false);
+    }, 1e3);
+  }, [showThumb]);
+  React2.useEffect(() => {
+    return () => {
+      if (scrollTimeoutRef.current) {
+        clearTimeout(scrollTimeoutRef.current);
+      }
+    };
+  }, []);
+  const resolvedDirection = horizontal ? "horizontal" : "vertical";
+  const classNames = [
+    "fc-roll",
+    `fc-roll--thumb-${showThumb}`,
+    `fc-roll--size-${thumbSize}`,
+    `fc-roll--${resolvedDirection}`,
+    showTrack && "fc-roll--track",
+    isScrolling && "fc-roll--scrolling",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      ref: containerRef,
+      className: classNames,
+      onScroll: handleScroll,
       ...props,
-      style: {
-        padding: "10px 16px",
-        border: "none",
-        borderRadius: 10,
-        background: "#863bff",
-        color: "#fff",
-        cursor: "pointer",
-        fontSize: 14,
-        ...style
-      },
-      children
+      children: /* @__PURE__ */ jsx4("div", { className: "fc-roll__content", children })
+    }
+  );
+}
+
+// src/components/Bar/SideBar.tsx
+import * as React3 from "react";
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+function SideBar({
+  items,
+  selectedKeys: controlledSelected,
+  defaultSelectedKeys = [],
+  openKeys: controlledOpen,
+  defaultOpenKeys = [],
+  onSelect,
+  onOpenChange,
+  collapsed: controlledCollapsed,
+  defaultCollapsed = false,
+  onCollapse,
+  className,
+  width = 240,
+  collapsedWidth = 64
+}) {
+  const [internalSelected, setInternalSelected] = React3.useState(defaultSelectedKeys);
+  const [internalOpen, setInternalOpen] = React3.useState(defaultOpenKeys);
+  const [internalCollapsed, setInternalCollapsed] = React3.useState(defaultCollapsed);
+  const currentSelected = controlledSelected ?? internalSelected;
+  const currentOpen = controlledOpen ?? internalOpen;
+  const currentCollapsed = controlledCollapsed ?? internalCollapsed;
+  const updateOpen = React3.useCallback((next) => {
+    if (controlledOpen === void 0) setInternalOpen(next);
+    onOpenChange?.(next);
+  }, [controlledOpen, onOpenChange]);
+  const toggleOpen = React3.useCallback((key) => {
+    const next = currentOpen.includes(key) ? currentOpen.filter((k) => k !== key) : [...currentOpen, key];
+    updateOpen(next);
+  }, [currentOpen, updateOpen]);
+  const handleSelect = React3.useCallback((key, item) => {
+    if (item.disabled) return;
+    const next = [key];
+    if (controlledSelected === void 0) setInternalSelected(next);
+    onSelect?.(next);
+  }, [controlledSelected, onSelect]);
+  const toggleCollapse = React3.useCallback(() => {
+    const next = !currentCollapsed;
+    if (controlledCollapsed === void 0) setInternalCollapsed(next);
+    onCollapse?.(next);
+  }, [currentCollapsed, controlledCollapsed, onCollapse]);
+  const handleItemClick = React3.useCallback((item) => {
+    if (item.children?.length) {
+      toggleOpen(item.key);
+    } else {
+      handleSelect(item.key, item);
+    }
+  }, [toggleOpen, handleSelect]);
+  const handleItemKeyDown = React3.useCallback((e, item) => {
+    if (e.key === "Enter" || e.key === " ") {
+      e.preventDefault();
+      handleItemClick(item);
+    }
+  }, [handleItemClick]);
+  const renderMenuItem = (item, level = 0) => {
+    const hasChildren = (item.children?.length ?? 0) > 0;
+    const isOpen = currentOpen.includes(item.key);
+    const isSelected = currentSelected.includes(item.key);
+    const itemClassName = [
+      "fc-sidebar__item",
+      `fc-sidebar__item--level-${level}`,
+      hasChildren && "fc-sidebar__item--parent",
+      isOpen && "fc-sidebar__item--open",
+      isSelected && "fc-sidebar__item--selected",
+      item.disabled && "fc-sidebar__item--disabled"
+    ].filter(Boolean).join(" ");
+    const Tag = item.href ? "a" : "div";
+    const interactiveProps = {
+      role: hasChildren ? "treeitem" : "menuitem",
+      tabIndex: item.disabled ? -1 : 0,
+      "aria-selected": isSelected || void 0,
+      "aria-expanded": hasChildren ? isOpen : void 0,
+      "aria-disabled": item.disabled || void 0,
+      onClick: () => handleItemClick(item),
+      onKeyDown: (e) => handleItemKeyDown(e, item),
+      ...item.href ? { href: item.href } : {}
+    };
+    return /* @__PURE__ */ jsxs3("div", { className: "fc-sidebar__item-wrapper", children: [
+      /* @__PURE__ */ jsxs3(Tag, { className: itemClassName, ...interactiveProps, children: [
+        item.icon && /* @__PURE__ */ jsx5("span", { className: "fc-sidebar__icon", "aria-hidden": "true", children: item.icon }),
+        /* @__PURE__ */ jsx5("span", { className: "fc-sidebar__label", children: item.label }),
+        hasChildren && /* @__PURE__ */ jsx5("span", { className: "fc-sidebar__arrow", "aria-hidden": "true", children: "\u25B6" })
+      ] }),
+      hasChildren && /* @__PURE__ */ jsx5(
+        "div",
+        {
+          className: [
+            "fc-sidebar__submenu",
+            isOpen && "fc-sidebar__submenu--open"
+          ].filter(Boolean).join(" "),
+          role: "group",
+          children: /* @__PURE__ */ jsx5("div", { className: "fc-sidebar__submenu-inner", children: item.children.map((child) => renderMenuItem(child, level + 1)) })
+        }
+      )
+    ] }, item.key);
+  };
+  const sidebarStyle = {
+    "--sidebar-width": `${currentCollapsed ? collapsedWidth : width}px`,
+    "--sidebar-collapsed-width": `${collapsedWidth}px`
+  };
+  return /* @__PURE__ */ jsxs3(
+    "aside",
+    {
+      className: [
+        "fc-sidebar",
+        currentCollapsed && "fc-sidebar--collapsed",
+        className
+      ].filter(Boolean).join(" "),
+      style: sidebarStyle,
+      role: "navigation",
+      "aria-label": "Sidebar",
+      children: [
+        /* @__PURE__ */ jsx5("div", { className: "fc-sidebar__header", children: /* @__PURE__ */ jsx5(
+          "button",
+          {
+            className: "fc-sidebar__collapse-btn",
+            onClick: toggleCollapse,
+            "aria-label": currentCollapsed ? "\u5C55\u5F00\u4FA7\u680F" : "\u6536\u8D77\u4FA7\u680F",
+            "aria-expanded": !currentCollapsed,
+            children: currentCollapsed ? "\u2192" : "\u2190"
+          }
+        ) }),
+        /* @__PURE__ */ jsx5("nav", { className: "fc-sidebar__menu", role: "tree", children: items.map((item) => renderMenuItem(item)) })
+      ]
+    }
+  );
+}
+
+// src/components/Input/Input.tsx
+import * as React4 from "react";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var Input = React4.forwardRef(({
+  size = "md",
+  status = "default",
+  prefix,
+  suffix,
+  allowClear = false,
+  passwordToggle = false,
+  addonBefore,
+  addonAfter,
+  helperText,
+  className = "",
+  type: initialType = "text",
+  value,
+  defaultValue,
+  onChange,
+  onClear,
+  disabled,
+  ...props
+}, ref) => {
+  const [type, setType] = React4.useState(initialType);
+  const [internalValue, setInternalValue] = React4.useState(defaultValue || "");
+  const isControlled = value !== void 0;
+  const currentValue = isControlled ? value : internalValue;
+  const handleChange = (e) => {
+    if (!isControlled) setInternalValue(e.target.value);
+    onChange?.(e);
+  };
+  const handleClear = () => {
+    if (!isControlled) setInternalValue("");
+    onClear?.();
+    const event = { target: { value: "" } };
+    onChange?.(event);
+  };
+  const togglePassword = () => {
+    setType((prev) => prev === "password" ? "text" : "password");
+  };
+  const showClear = allowClear && currentValue && !disabled;
+  const showPasswordToggle = passwordToggle && initialType === "password" && !disabled;
+  const classNames = [
+    "fc-input",
+    `fc-input--${size}`,
+    `fc-input--${status}`,
+    (prefix || addonBefore) && "fc-input--has-prefix",
+    (suffix || addonAfter || showClear || showPasswordToggle) && "fc-input--has-suffix",
+    addonBefore && "fc-input--addon-before",
+    addonAfter && "fc-input--addon-after",
+    disabled && "fc-input--disabled",
+    className
+  ].filter(Boolean).join(" ");
+  const input = /* @__PURE__ */ jsx6(
+    "input",
+    {
+      ref,
+      type,
+      value: currentValue,
+      onChange: handleChange,
+      disabled,
+      className: "fc-input__field",
+      ...props
+    }
+  );
+  return /* @__PURE__ */ jsxs4("div", { className: classNames, children: [
+    addonBefore && /* @__PURE__ */ jsx6("span", { className: "fc-input__addon fc-input__addon--before", children: addonBefore }),
+    prefix && /* @__PURE__ */ jsx6("span", { className: "fc-input__prefix", children: prefix }),
+    /* @__PURE__ */ jsxs4("div", { className: "fc-input__wrapper", children: [
+      input,
+      /* @__PURE__ */ jsxs4("span", { className: "fc-input__actions", children: [
+        showClear && /* @__PURE__ */ jsx6(
+          "button",
+          {
+            type: "button",
+            className: "fc-input__action fc-input__clear",
+            onClick: handleClear,
+            tabIndex: -1,
+            children: "\u2715"
+          }
+        ),
+        showPasswordToggle && /* @__PURE__ */ jsx6(
+          "button",
+          {
+            type: "button",
+            className: "fc-input__action fc-input__eye",
+            onClick: togglePassword,
+            tabIndex: -1,
+            children: type === "password" ? "\u{1F441}" : "\u{1F648}"
+          }
+        ),
+        suffix && /* @__PURE__ */ jsx6("span", { className: "fc-input__suffix", children: suffix })
+      ] })
+    ] }),
+    addonAfter && /* @__PURE__ */ jsx6("span", { className: "fc-input__addon fc-input__addon--after", children: addonAfter }),
+    helperText && /* @__PURE__ */ jsx6("span", { className: `fc-input__helper fc-input__helper--${status}`, children: helperText })
+  ] });
+});
+Input.displayName = "Input";
+
+// src/components/Slider/Slider.tsx
+import * as React5 from "react";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function Slider({
+  value: controlledValue,
+  defaultValue,
+  onChange,
+  min = 0,
+  max = 100,
+  step = 1,
+  range = false,
+  orientation = "horizontal",
+  disabled = false,
+  marks,
+  tooltip = false,
+  className = ""
+}) {
+  const trackRef = React5.useRef(null);
+  const draggingRef = React5.useRef(null);
+  const [dragging, setDragging] = React5.useState(null);
+  const initialValue = defaultValue ?? (range ? [min, max] : min);
+  const [internalValue, setInternalValue] = React5.useState(initialValue);
+  const isControlled = controlledValue !== void 0;
+  const currentValue = isControlled ? controlledValue : internalValue;
+  const getPercent = (val) => Math.max(0, Math.min(100, (val - min) / (max - min) * 100));
+  const getValueFromPercent = (percent) => {
+    const raw = min + percent / 100 * (max - min);
+    const stepped = Math.round(raw / step) * step;
+    return Math.max(min, Math.min(max, stepped));
+  };
+  const handleMove = React5.useCallback((clientX, clientY) => {
+    if (!trackRef.current || draggingRef.current === null || disabled) return;
+    const rect = trackRef.current.getBoundingClientRect();
+    const percent = orientation === "horizontal" ? (clientX - rect.left) / rect.width * 100 : (rect.bottom - clientY) / rect.height * 100;
+    const newValue = getValueFromPercent(Math.max(0, Math.min(100, percent)));
+    let nextValue;
+    if (range) {
+      const [start, end] = currentValue;
+      nextValue = draggingRef.current === 0 ? [Math.min(newValue, end), end] : [start, Math.max(newValue, start)];
+    } else {
+      nextValue = newValue;
+    }
+    if (!isControlled) setInternalValue(nextValue);
+    onChange?.(nextValue);
+  }, [disabled, orientation, range, currentValue, isControlled, onChange, min, max, step]);
+  const handleMouseDown = (index) => (e) => {
+    if (disabled) return;
+    e.preventDefault();
+    draggingRef.current = index;
+    setDragging(index);
+    const handleMouseMove = (e2) => handleMove(e2.clientX, e2.clientY);
+    const handleMouseUp = () => {
+      draggingRef.current = null;
+      setDragging(null);
+      document.removeEventListener("mousemove", handleMouseMove);
+      document.removeEventListener("mouseup", handleMouseUp);
+    };
+    document.addEventListener("mousemove", handleMouseMove);
+    document.addEventListener("mouseup", handleMouseUp);
+  };
+  const handleTrackClick = (e) => {
+    if (disabled || draggingRef.current !== null) return;
+    handleMove(e.clientX, e.clientY);
+  };
+  const [startVal, endVal] = range ? currentValue : [min, currentValue];
+  const startPercent = getPercent(startVal);
+  const endPercent = getPercent(endVal);
+  const isHorizontal = orientation === "horizontal";
+  const thumbStyle = (percent) => isHorizontal ? { left: `${percent}%` } : { bottom: `${percent}%` };
+  const cls = [
+    "fc-slider",
+    `fc-slider--${orientation}`,
+    range && "fc-slider--range",
+    disabled && "fc-slider--disabled",
+    dragging !== null && "fc-slider--dragging",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx7("div", { className: cls, children: /* @__PURE__ */ jsxs5(
+    "div",
+    {
+      ref: trackRef,
+      className: "fc-slider__track",
+      onClick: handleTrackClick,
+      children: [
+        /* @__PURE__ */ jsx7(
+          "div",
+          {
+            className: "fc-slider__fill",
+            style: isHorizontal ? { left: `${startPercent}%`, width: `${endPercent - startPercent}%` } : { bottom: `${startPercent}%`, height: `${endPercent - startPercent}%` }
+          }
+        ),
+        range && /* @__PURE__ */ jsx7(
+          "div",
+          {
+            className: `fc-slider__thumb ${dragging === 0 ? "fc-slider__thumb--active" : ""}`,
+            style: thumbStyle(startPercent),
+            onMouseDown: handleMouseDown(0),
+            children: tooltip && /* @__PURE__ */ jsx7("span", { className: "fc-slider__tooltip", children: startVal })
+          }
+        ),
+        /* @__PURE__ */ jsx7(
+          "div",
+          {
+            className: `fc-slider__thumb ${dragging === (range ? 1 : 0) ? "fc-slider__thumb--active" : ""}`,
+            style: thumbStyle(endPercent),
+            onMouseDown: handleMouseDown(range ? 1 : 0),
+            children: tooltip && /* @__PURE__ */ jsx7("span", { className: "fc-slider__tooltip", children: endVal })
+          }
+        ),
+        marks && Object.entries(marks).map(([val, label]) => /* @__PURE__ */ jsxs5(
+          "div",
+          {
+            className: "fc-slider__mark",
+            style: thumbStyle(getPercent(Number(val))),
+            children: [
+              /* @__PURE__ */ jsx7("span", { className: "fc-slider__mark-dot" }),
+              /* @__PURE__ */ jsx7("span", { className: "fc-slider__mark-label", children: label })
+            ]
+          },
+          val
+        ))
+      ]
+    }
+  ) });
+}
+
+// src/components/Select/Select.tsx
+import * as React6 from "react";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function Select({
+  options,
+  value: controlledValue,
+  defaultValue,
+  onChange,
+  placeholder = "\u8BF7\u9009\u62E9",
+  searchable = false,
+  multiple = false,
+  disabled = false,
+  className = "",
+  virtualScroll = false,
+  virtualItemHeight = 32,
+  maxHeight = 256
+}) {
+  const [isOpen, setIsOpen] = React6.useState(false);
+  const [searchValue, setSearchValue] = React6.useState("");
+  const [highlightedIndex, setHighlightedIndex] = React6.useState(0);
+  const containerRef = React6.useRef(null);
+  const listRef = React6.useRef(null);
+  const isControlled = controlledValue !== void 0;
+  const [internalValue, setInternalValue] = React6.useState(
+    defaultValue ?? (multiple ? [] : void 0)
+  );
+  const currentValue = isControlled ? controlledValue : internalValue;
+  const groupedOptions = React6.useMemo(() => {
+    const filtered = searchable && searchValue ? options.filter((o) => o.label.toLowerCase().includes(searchValue.toLowerCase())) : options;
+    const groups = {};
+    filtered.forEach((opt) => {
+      const group = opt.group || "";
+      if (!groups[group]) groups[group] = [];
+      groups[group].push(opt);
+    });
+    return groups;
+  }, [options, searchValue, searchable]);
+  const flatOptions = React6.useMemo(() => {
+    return Object.values(groupedOptions).flat();
+  }, [groupedOptions]);
+  const [scrollTop, setScrollTop] = React6.useState(0);
+  const visibleCount = Math.ceil(maxHeight / virtualItemHeight);
+  const startIndex = Math.floor(scrollTop / virtualItemHeight);
+  const endIndex = Math.min(startIndex + visibleCount + 1, flatOptions.length);
+  const visibleOptions = virtualScroll ? flatOptions.slice(startIndex, endIndex) : flatOptions;
+  const totalHeight = flatOptions.length * virtualItemHeight;
+  const offsetY = startIndex * virtualItemHeight;
+  const handleSelect = (option) => {
+    if (option.disabled) return;
+    let nextValue;
+    if (multiple) {
+      const arr = currentValue || [];
+      const exists = arr.includes(option.value);
+      nextValue = exists ? arr.filter((v) => v !== option.value) : [...arr, option.value];
+    } else {
+      nextValue = option.value;
+      setIsOpen(false);
+    }
+    if (!isControlled) setInternalValue(nextValue);
+    onChange?.(nextValue);
+    if (!multiple) setSearchValue("");
+  };
+  const isSelected = (value) => {
+    if (multiple) return currentValue?.includes(value);
+    return currentValue === value;
+  };
+  const displayLabel = () => {
+    if (multiple) {
+      const count = currentValue?.length || 0;
+      return count > 0 ? `\u5DF2\u9009\u62E9 ${count} \u9879` : placeholder;
+    }
+    const selected = options.find((o) => o.value === currentValue);
+    return selected?.label || placeholder;
+  };
+  React6.useEffect(() => {
+    const handleClick = (e) => {
+      if (!containerRef.current?.contains(e.target)) {
+        setIsOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClick);
+    return () => document.removeEventListener("mousedown", handleClick);
+  }, []);
+  const classNames = [
+    "fc-select",
+    isOpen && "fc-select--open",
+    multiple && "fc-select--multiple",
+    disabled && "fc-select--disabled",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs6("div", { ref: containerRef, className: classNames, children: [
+    /* @__PURE__ */ jsxs6(
+      "div",
+      {
+        className: "fc-select__trigger",
+        onClick: () => !disabled && setIsOpen(!isOpen),
+        children: [
+          /* @__PURE__ */ jsx8("span", { className: `fc-select__value ${!currentValue && "fc-select__value--placeholder"}`, children: displayLabel() }),
+          /* @__PURE__ */ jsx8("span", { className: "fc-select__arrow", children: "\u25BC" })
+        ]
+      }
+    ),
+    isOpen && /* @__PURE__ */ jsxs6("div", { className: "fc-select__dropdown", children: [
+      searchable && /* @__PURE__ */ jsx8("div", { className: "fc-select__search", children: /* @__PURE__ */ jsx8(
+        "input",
+        {
+          type: "text",
+          value: searchValue,
+          onChange: (e) => setSearchValue(e.target.value),
+          placeholder: "\u641C\u7D22...",
+          className: "fc-select__search-input",
+          autoFocus: true
+        }
+      ) }),
+      /* @__PURE__ */ jsxs6(
+        "div",
+        {
+          ref: listRef,
+          className: "fc-select__list",
+          style: { maxHeight },
+          onScroll: (e) => virtualScroll && setScrollTop(e.target.scrollTop),
+          children: [
+            virtualScroll && /* @__PURE__ */ jsx8("div", { style: { height: totalHeight, position: "relative" }, children: /* @__PURE__ */ jsx8("div", { style: { transform: `translateY(${offsetY}px)` }, children: renderOptions(visibleOptions, startIndex) }) }),
+            !virtualScroll && renderGroupedOptions()
+          ]
+        }
+      )
+    ] })
+  ] });
+  function renderOptions(opts, baseIndex = 0) {
+    return opts.map((option, idx) => {
+      const actualIndex = baseIndex + idx;
+      const selected = isSelected(option.value);
+      const highlighted = actualIndex === highlightedIndex;
+      return /* @__PURE__ */ jsxs6(
+        "div",
+        {
+          className: [
+            "fc-select__option",
+            selected && "fc-select__option--selected",
+            option.disabled && "fc-select__option--disabled",
+            highlighted && "fc-select__option--highlighted"
+          ].filter(Boolean).join(" "),
+          onClick: () => handleSelect(option),
+          onMouseEnter: () => setHighlightedIndex(actualIndex),
+          style: { height: virtualItemHeight },
+          children: [
+            multiple && /* @__PURE__ */ jsx8("span", { className: `fc-select__checkbox ${selected && "fc-select__checkbox--checked"}`, children: selected && "\u2713" }),
+            /* @__PURE__ */ jsx8("span", { className: "fc-select__option-label", children: highlightText(option.label, searchValue) }),
+            !multiple && selected && /* @__PURE__ */ jsx8("span", { className: "fc-select__check", children: "\u2713" })
+          ]
+        },
+        option.value
+      );
+    });
+  }
+  function renderGroupedOptions() {
+    return Object.entries(groupedOptions).map(([group, opts]) => /* @__PURE__ */ jsxs6("div", { className: "fc-select__group", children: [
+      group && /* @__PURE__ */ jsx8("div", { className: "fc-select__group-label", children: group }),
+      renderOptions(opts)
+    ] }, group));
+  }
+  function highlightText(text, highlight) {
+    if (!highlight) return text;
+    const parts = text.split(new RegExp(`(${highlight})`, "gi"));
+    return parts.map(
+      (part, i) => part.toLowerCase() === highlight.toLowerCase() ? /* @__PURE__ */ jsx8("mark", { className: "fc-select__highlight", children: part }, i) : part
+    );
+  }
+}
+
+// src/components/Tree/Tree.tsx
+import {
+  createContext as createContext2,
+  memo,
+  useCallback as useCallback4,
+  useContext as useContext2,
+  useEffect as useEffect4,
+  useMemo as useMemo2,
+  useRef as useRef4,
+  useState as useState9
+} from "react";
+import {
+  DndContext,
+  PointerSensor,
+  useDraggable,
+  useDroppable,
+  useSensor,
+  useSensors
+} from "@dnd-kit/core";
+
+// src/components/Tree/DeleteDialog.tsx
+import { useState as useState8 } from "react";
+import { Fragment, jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function DeleteDialog({ node, onClose, onDelete }) {
+  const [phase, setPhase] = useState8("choose");
+  const [loading, setLoading] = useState8(false);
+  if (!node) return null;
+  const reset = () => {
+    setPhase("choose");
+    setLoading(false);
+  };
+  const handleClose = () => {
+    reset();
+    onClose();
+  };
+  const handleLift = async () => {
+    setLoading(true);
+    try {
+      await onDelete(node.key, "lift");
+      reset();
+      onClose();
+    } catch {
+      setLoading(false);
+    }
+  };
+  const handleCascade = async () => {
+    setLoading(true);
+    try {
+      await onDelete(node.key, "cascade");
+      reset();
+      onClose();
+    } catch {
+      setLoading(false);
+    }
+  };
+  return /* @__PURE__ */ jsx9("div", { className: "fc-dialog-overlay", onMouseDown: handleClose, children: /* @__PURE__ */ jsxs7("div", { className: "fc-dialog", onMouseDown: (e) => e.stopPropagation(), children: [
+    phase === "choose" && /* @__PURE__ */ jsxs7(Fragment, { children: [
+      /* @__PURE__ */ jsxs7("div", { className: "fc-dialog__header", children: [
+        /* @__PURE__ */ jsx9("span", { className: "fc-dialog__icon", children: "\u{1F5C2}" }),
+        /* @__PURE__ */ jsxs7("h3", { className: "fc-dialog__title", children: [
+          "\u5220\u9664\u300C",
+          node.title,
+          "\u300D"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx9("p", { className: "fc-dialog__desc", children: "\u8BE5\u5206\u7C7B\u4E0B\u53EF\u80FD\u5305\u542B\u5B50\u5206\u7C7B\u548C\u8BCD\u6761\uFF0C\u8BF7\u9009\u62E9\u5220\u9664\u65B9\u5F0F\uFF1A" }),
+      /* @__PURE__ */ jsxs7("div", { className: "fc-dialog__options", children: [
+        /* @__PURE__ */ jsxs7(
+          "button",
+          {
+            className: "fc-dialog__option",
+            onClick: handleLift,
+            disabled: loading,
+            children: [
+              /* @__PURE__ */ jsx9("span", { className: "fc-dialog__option-icon", children: "\u{1F4E4}" }),
+              /* @__PURE__ */ jsxs7("span", { className: "fc-dialog__option-body", children: [
+                /* @__PURE__ */ jsx9("span", { className: "fc-dialog__option-title", children: "\u79FB\u4EA4\u7ED9\u4E0A\u7EA7\u5206\u7C7B" }),
+                /* @__PURE__ */ jsx9("span", { className: "fc-dialog__option-desc", children: "\u6240\u6709\u5B50\u5206\u7C7B\u548C\u8BCD\u6761\u5C06\u79FB\u81F3\u4E0A\u7EA7\u5206\u7C7B\uFF1B\u82E5\u5DF2\u662F\u6839\u5206\u7C7B\uFF0C\u5219\u53D8\u4E3A\u65E0\u5206\u7C7B" })
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs7(
+          "button",
+          {
+            className: "fc-dialog__option fc-dialog__option--danger",
+            onClick: () => setPhase("confirm-cascade"),
+            disabled: loading,
+            children: [
+              /* @__PURE__ */ jsx9("span", { className: "fc-dialog__option-icon", children: "\u{1F5D1}" }),
+              /* @__PURE__ */ jsxs7("span", { className: "fc-dialog__option-body", children: [
+                /* @__PURE__ */ jsx9("span", { className: "fc-dialog__option-title", children: "\u5F7B\u5E95\u5220\u9664" }),
+                /* @__PURE__ */ jsx9("span", { className: "fc-dialog__option-desc", children: "\u5220\u9664\u8BE5\u5206\u7C7B\u53CA\u6240\u6709\u5B50\u5206\u7C7B\uFF1B\u8BCD\u6761\u4E0D\u4F1A\u88AB\u5220\u9664\uFF0C\u5C06\u53D8\u4E3A\u65E0\u5206\u7C7B" })
+              ] })
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx9("div", { className: "fc-dialog__footer", children: /* @__PURE__ */ jsx9("button", { className: "fc-dialog__btn", onClick: handleClose, disabled: loading, children: "\u53D6\u6D88" }) })
+    ] }),
+    phase === "confirm-cascade" && /* @__PURE__ */ jsxs7(Fragment, { children: [
+      /* @__PURE__ */ jsxs7("div", { className: "fc-dialog__header", children: [
+        /* @__PURE__ */ jsx9("span", { className: "fc-dialog__icon", children: "\u26A0\uFE0F" }),
+        /* @__PURE__ */ jsx9("h3", { className: "fc-dialog__title fc-dialog__title--danger", children: "\u786E\u8BA4\u5F7B\u5E95\u5220\u9664\uFF1F" })
+      ] }),
+      /* @__PURE__ */ jsxs7("p", { className: "fc-dialog__desc", children: [
+        "\u6B64\u64CD\u4F5C",
+        /* @__PURE__ */ jsx9("strong", { children: "\u4E0D\u53EF\u9006" }),
+        "\u3002\u300C",
+        node.title,
+        "\u300D\u53CA\u5176\u6240\u6709\u5B50\u5206\u7C7B\u5C06\u88AB\u6C38\u4E45\u5220\u9664\uFF0C \u5176\u4E0B\u8BCD\u6761\u5C06\u53D8\u4E3A\u65E0\u5206\u7C7B\u3002"
+      ] }),
+      /* @__PURE__ */ jsxs7("div", { className: "fc-dialog__footer", children: [
+        /* @__PURE__ */ jsx9(
+          "button",
+          {
+            className: "fc-dialog__btn",
+            onClick: () => setPhase("choose"),
+            disabled: loading,
+            children: "\u8FD4\u56DE"
+          }
+        ),
+        /* @__PURE__ */ jsx9(
+          "button",
+          {
+            className: "fc-dialog__btn fc-dialog__btn--danger",
+            onClick: handleCascade,
+            disabled: loading,
+            children: loading ? "\u5220\u9664\u4E2D\u2026" : "\u786E\u8BA4\u5220\u9664"
+          }
+        )
+      ] })
+    ] })
+  ] }) });
+}
+
+// src/components/Tree/flatToTree.ts
+function flatToTree(list) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const item of list) {
+    nodeMap.set(item.id, {
+      key: item.id,
+      title: item.name,
+      children: [],
+      raw: item
+    });
+  }
+  const roots = [];
+  const orphans = [];
+  for (const item of list) {
+    const node = nodeMap.get(item.id);
+    if (item.parent_id === null) {
+      roots.push(node);
+    } else if (nodeMap.has(item.parent_id)) {
+      nodeMap.get(item.parent_id).children.push(node);
+    } else {
+      orphans.push(node);
+    }
+  }
+  const sortLevel = (nodes) => {
+    nodes.sort((a, b) => a.raw.sort_order - b.raw.sort_order);
+    for (const node of nodes) sortLevel(node.children);
+  };
+  sortLevel(roots);
+  return { roots, orphans };
+}
+function findNodeInfo(nodes, key, parent = null) {
+  for (let i = 0; i < nodes.length; i++) {
+    if (nodes[i].key === key)
+      return { node: nodes[i], parent, siblings: nodes, index: i };
+    const found = findNodeInfo(nodes[i].children, key, nodes[i]);
+    if (found) return found;
+  }
+  return null;
+}
+function isDescendantOf(roots, ancestorKey, targetKey) {
+  const info = findNodeInfo(roots, ancestorKey);
+  if (!info) return false;
+  const check = (children) => children.some((n) => n.key === targetKey || check(n.children));
+  return check(info.node.children);
+}
+
+// src/components/Tree/Tree.tsx
+import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+var TreeActionsCtx = createContext2(null);
+var TreeStateCtx = createContext2(null);
+var DndStateCtx = createContext2(null);
+var CollapsePanel = memo(function CollapsePanel2({ open, children }) {
+  const innerRef = useRef4(null);
+  const [height, setHeight] = useState9(0);
+  const [ready, setReady] = useState9(false);
+  useEffect4(() => {
+    const el = innerRef.current;
+    if (!el) return;
+    const ro = new ResizeObserver(() => setHeight(el.offsetHeight));
+    ro.observe(el);
+    setHeight(el.offsetHeight);
+    requestAnimationFrame(() => requestAnimationFrame(() => setReady(true)));
+    return () => ro.disconnect();
+  }, []);
+  return /* @__PURE__ */ jsx10("div", { style: {
+    height: open ? height : 0,
+    overflow: "hidden",
+    transition: ready ? "height 0.12s ease-out" : "none"
+  }, children: /* @__PURE__ */ jsx10("div", { ref: innerRef, children }) });
+});
+var DndSlot = memo(function DndSlot2({
+  nodeKey,
+  disabled,
+  children
+}) {
+  const dndState = useContext2(DndStateCtx);
+  const isDropTarget = dndState.dropTargetKey === nodeKey;
+  const dropPosition = isDropTarget ? dndState.dropPosition : null;
+  const isDragSource = dndState.dragKey === nodeKey;
+  const { attributes, listeners, setNodeRef: setDragRef, isDragging } = useDraggable({ id: nodeKey, disabled });
+  const { setNodeRef: setDropRef } = useDroppable({ id: nodeKey, disabled });
+  const setRef = useCallback4((el) => {
+    setDragRef(el);
+    setDropRef(el);
+  }, [setDragRef, setDropRef]);
+  const handleProps = useMemo2(
+    () => ({ ...attributes, ...listeners }),
+    [attributes, listeners]
+  );
+  return /* @__PURE__ */ jsx10(Fragment2, { children: children({ setRef, handleProps, isDragging, isDragSource, dropPosition }) });
+});
+var TreeNodeItem = memo(function TreeNodeItem2({ node, level, hidden = false }) {
+  const actions = useContext2(TreeActionsCtx);
+  const state = useContext2(TreeStateCtx);
+  const isExpanded = state.expandedKeys.has(node.key);
+  const isEditing = state.editingKey === node.key;
+  const hasChildren = node.children.length > 0;
+  const indent = level * 20 + 12;
+  const [localEdit, setLocalEdit] = useState9("");
+  useEffect4(() => {
+    if (isEditing) setLocalEdit(node.title);
+  }, [isEditing, node.title]);
+  const handleEditKeyDown = useCallback4((e) => {
+    e.stopPropagation();
+    if (e.key === "Enter") actions.commitEdit(node.key, localEdit).then();
+    if (e.key === "Escape") actions.cancelEdit();
+  }, [actions, node.key, localEdit]);
+  return /* @__PURE__ */ jsx10(DndSlot, { nodeKey: node.key, disabled: isEditing || hidden, children: ({ setRef, handleProps, isDragging, isDragSource, dropPosition }) => /* @__PURE__ */ jsxs8("div", { className: `fc-tree__node ${isDragging ? "is-dragging" : ""}`, children: [
+    /* @__PURE__ */ jsxs8(
+      "div",
+      {
+        ref: setRef,
+        className: [
+          "fc-tree__item",
+          isDragSource && "fc-tree__item--drag-source",
+          dropPosition === "into" && "fc-tree__item--drop-into",
+          dropPosition === "before" && "fc-tree__item--drop-before",
+          dropPosition === "after" && "fc-tree__item--drop-after"
+        ].filter(Boolean).join(" "),
+        style: {
+          paddingLeft: dropPosition === "into" ? indent + 8 : indent,
+          "--fc-indent": `${indent}px`
+        },
+        children: [
+          /* @__PURE__ */ jsx10(
+            "span",
+            {
+              className: "fc-tree__drag-handle",
+              title: "\u62D6\u62FD\u79FB\u52A8",
+              ...handleProps,
+              onMouseDown: (e) => e.stopPropagation(),
+              children: "\u283F"
+            }
+          ),
+          /* @__PURE__ */ jsx10(
+            "span",
+            {
+              className: [
+                "fc-tree__switcher",
+                !hasChildren && "fc-tree__switcher--hidden",
+                isExpanded && "fc-tree__switcher--open"
+              ].filter(Boolean).join(" "),
+              onClick: () => hasChildren && actions.toggleExpand(node.key),
+              children: hasChildren ? "\u25B6" : ""
+            }
+          ),
+          isEditing ? /* @__PURE__ */ jsx10(
+            "input",
+            {
+              autoFocus: true,
+              className: "fc-tree__edit-input",
+              value: localEdit,
+              onChange: (e) => setLocalEdit(e.target.value),
+              onBlur: () => actions.commitEdit(node.key, localEdit),
+              onKeyDown: handleEditKeyDown,
+              onClick: (e) => e.stopPropagation()
+            }
+          ) : /* @__PURE__ */ jsx10(
+            "span",
+            {
+              className: "fc-tree__title",
+              onClick: () => {
+                actions.select(node.key);
+                if (hasChildren) actions.toggleExpand(node.key);
+              },
+              onDoubleClick: () => actions.startEdit(node.key),
+              children: node.title
+            }
+          ),
+          !isEditing && /* @__PURE__ */ jsxs8("span", { className: "fc-tree__actions", children: [
+            /* @__PURE__ */ jsx10(
+              "button",
+              {
+                className: "fc-tree__action",
+                title: "\u65B0\u5EFA\u5B50\u5206\u7C7B",
+                onClick: (e) => {
+                  e.stopPropagation();
+                  actions.requestCreate(node.key).then();
+                },
+                children: "+"
+              }
+            ),
+            /* @__PURE__ */ jsx10(
+              "button",
+              {
+                className: "fc-tree__action",
+                title: "\u91CD\u547D\u540D\uFF08\u53CC\u51FB\u4E5F\u53EF\uFF09",
+                onClick: (e) => {
+                  e.stopPropagation();
+                  actions.startEdit(node.key);
+                },
+                children: "\u270F"
+              }
+            ),
+            /* @__PURE__ */ jsx10(
+              "button",
+              {
+                className: "fc-tree__action fc-tree__action--danger",
+                title: "\u5220\u9664",
+                onClick: (e) => {
+                  e.stopPropagation();
+                  actions.requestDelete(node);
+                },
+                children: "\u{1F5D1}"
+              }
+            )
+          ] })
+        ]
+      }
+    ),
+    hasChildren && /* @__PURE__ */ jsx10(CollapsePanel, { open: isExpanded, children: node.children.map((child) => /* @__PURE__ */ jsx10(TreeNodeItem2, { node: child, level: level + 1, hidden: hidden || !isExpanded }, child.key)) })
+  ] }) });
+});
+function Tree({
+  treeData,
+  onRename,
+  onCreate,
+  onDelete,
+  onMove,
+  onSelect,
+  selectedKey,
+  searchable = false,
+  scrollHeight = "400px",
+  className = ""
+}) {
+  const [expandedKeys, setExpandedKeys] = useState9(/* @__PURE__ */ new Set());
+  const [editingKey, setEditingKey] = useState9(null);
+  const [deleteTarget, setDeleteTarget] = useState9(null);
+  const [searchValue, setSearchValue] = useState9("");
+  const [dndState, setDndState] = useState9({
+    dropTargetKey: null,
+    dropPosition: null,
+    dragKey: null
+  });
+  const dropRef = useRef4({ key: null, pos: null });
+  const pointerYRef = useRef4(0);
+  useEffect4(() => {
+    const handler = (e) => {
+      pointerYRef.current = e.clientY;
+    };
+    window.addEventListener("pointermove", handler);
+    return () => window.removeEventListener("pointermove", handler);
+  }, []);
+  const sensors = useSensors(
+    useSensor(PointerSensor, { activationConstraint: { distance: 8 } })
+  );
+  const toggleExpand = useCallback4((key) => {
+    setExpandedKeys((prev) => {
+      const next = new Set(prev);
+      next.has(key) ? next.delete(key) : next.add(key);
+      return next;
+    });
+  }, []);
+  const select = useCallback4((key) => onSelect?.(key), [onSelect]);
+  const startEdit = useCallback4((key) => setEditingKey(key), []);
+  const cancelEdit = useCallback4(() => setEditingKey(null), []);
+  const commitEdit = useCallback4(async (key, newTitle) => {
+    setEditingKey(null);
+    const trimmed = newTitle.trim();
+    if (trimmed && onRename) await onRename(key, trimmed);
+  }, [onRename]);
+  const requestCreate = useCallback4(async (parentKey) => {
+    if (!onCreate) return;
+    const newKey = await onCreate(parentKey);
+    if (parentKey) setExpandedKeys((prev) => /* @__PURE__ */ new Set([...prev, parentKey]));
+    setEditingKey(newKey);
+  }, [onCreate]);
+  const requestDelete = useCallback4((node) => {
+    setDeleteTarget(node);
+  }, []);
+  const treeDataRef = useRef4(treeData);
+  const expandedRef = useRef4(expandedKeys);
+  treeDataRef.current = treeData;
+  expandedRef.current = expandedKeys;
+  const handleDragStart = useCallback4(({ active }) => {
+    dropRef.current = { key: null, pos: null };
+    setDndState({ dropTargetKey: null, dropPosition: null, dragKey: active.id });
+  }, []);
+  const handleDragMove = useCallback4(({ over, active }) => {
+    if (!over || over.id === active.id) {
+      if (dropRef.current.key !== null) {
+        dropRef.current = { key: null, pos: null };
+        setDndState((prev) => ({ ...prev, dropTargetKey: null, dropPosition: null }));
+      }
+      return;
+    }
+    const targetKey = over.id;
+    if (isDescendantOf(treeDataRef.current, active.id, targetKey)) {
+      if (dropRef.current.key !== null) {
+        dropRef.current = { key: null, pos: null };
+        setDndState((prev) => ({ ...prev, dropTargetKey: null, dropPosition: null }));
+      }
+      return;
+    }
+    const rect = over.rect;
+    const y = pointerYRef.current;
+    const ratio = Math.max(0, Math.min(1, (y - rect.top) / rect.height));
+    let position;
+    if (ratio < 0.2) position = "before";
+    else if (ratio > 0.8) position = "after";
+    else position = "into";
+    if (dropRef.current.key === targetKey && dropRef.current.pos === position) return;
+    dropRef.current = { key: targetKey, pos: position };
+    setDndState((prev) => ({ ...prev, dropTargetKey: targetKey, dropPosition: position }));
+  }, []);
+  const handleDragEnd = useCallback4(({ active }) => {
+    const { key: target, pos: position } = dropRef.current;
+    dropRef.current = { key: null, pos: null };
+    setDndState({ dropTargetKey: null, dropPosition: null, dragKey: null });
+    if (!target || !position || active.id === target) return;
+    onMove?.(active.id, target, position);
+  }, [onMove]);
+  const handleDragCancel = useCallback4(() => {
+    dropRef.current = { key: null, pos: null };
+    setDndState({ dropTargetKey: null, dropPosition: null, dragKey: null });
+  }, []);
+  const displayData = useMemo2(() => {
+    if (!searchValue) return treeData;
+    const kw = searchValue.toLowerCase();
+    const filter = (nodes) => nodes.reduce((acc, node) => {
+      const match = node.title.toLowerCase().includes(kw);
+      const filteredChildren = filter(node.children);
+      if (match || filteredChildren.length > 0)
+        acc.push({ ...node, children: filteredChildren });
+      return acc;
+    }, []);
+    return filter(treeData);
+  }, [treeData, searchValue]);
+  const actionsValue = useMemo2(() => ({
+    toggleExpand,
+    select,
+    startEdit,
+    commitEdit,
+    cancelEdit,
+    requestCreate,
+    requestDelete
+  }), [toggleExpand, select, startEdit, commitEdit, cancelEdit, requestCreate, requestDelete]);
+  const stateValue = useMemo2(() => ({
+    expandedKeys,
+    selectedKey: selectedKey ?? null,
+    editingKey
+  }), [expandedKeys, selectedKey, editingKey]);
+  return /* @__PURE__ */ jsx10(TreeActionsCtx.Provider, { value: actionsValue, children: /* @__PURE__ */ jsx10(TreeStateCtx.Provider, { value: stateValue, children: /* @__PURE__ */ jsx10(DndStateCtx.Provider, { value: dndState, children: /* @__PURE__ */ jsxs8(
+    DndContext,
+    {
+      sensors,
+      onDragStart: handleDragStart,
+      onDragMove: handleDragMove,
+      onDragEnd: handleDragEnd,
+      onDragCancel: handleDragCancel,
+      children: [
+        /* @__PURE__ */ jsxs8("div", { className: `fc-tree ${className}`, children: [
+          searchable && /* @__PURE__ */ jsxs8("div", { className: "fc-tree__search", children: [
+            /* @__PURE__ */ jsx10(
+              "input",
+              {
+                type: "text",
+                value: searchValue,
+                onChange: (e) => setSearchValue(e.target.value),
+                placeholder: "\u641C\u7D22\u5206\u7C7B\u2026",
+                className: "fc-tree__search-input"
+              }
+            ),
+            searchValue && /* @__PURE__ */ jsx10("button", { className: "fc-tree__search-clear", onClick: () => setSearchValue(""), children: "\u2715" })
+          ] }),
+          /* @__PURE__ */ jsx10(RollingBox, { showThumb: "show", style: { height: scrollHeight }, children: /* @__PURE__ */ jsxs8("div", { className: "fc-tree__list", children: [
+            displayData.length === 0 && /* @__PURE__ */ jsx10("div", { className: "fc-tree__empty", children: searchValue ? "\u65E0\u5339\u914D\u5206\u7C7B" : "\u6682\u65E0\u5206\u7C7B" }),
+            displayData.map((node) => /* @__PURE__ */ jsx10(TreeNodeItem, { node, level: 0 }, node.key))
+          ] }) }),
+          onCreate && /* @__PURE__ */ jsx10("div", { className: "fc-tree__add-root", children: /* @__PURE__ */ jsx10(
+            "button",
+            {
+              className: "fc-tree__add-root-btn",
+              onClick: () => requestCreate(null),
+              children: "+ \u65B0\u5EFA\u9876\u7EA7\u5206\u7C7B"
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ jsx10(
+          DeleteDialog,
+          {
+            node: deleteTarget,
+            onClose: () => setDeleteTarget(null),
+            onDelete: async (key, mode) => {
+              await onDelete?.(key, mode);
+              setDeleteTarget(null);
+            }
+          }
+        )
+      ]
+    }
+  ) }) }) });
+}
+
+// src/components/Tree/OrphanDialog.tsx
+import { useState as useState10 } from "react";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+function OrphanDialog({ orphans, onResolve, onClose }) {
+  const [resolutions, setResolutions] = useState10(
+    () => Object.fromEntries(orphans.map((o) => [o.key, "lift"]))
+  );
+  if (orphans.length === 0) return null;
+  const set = (key, val) => setResolutions((prev) => ({ ...prev, [key]: val }));
+  return /* @__PURE__ */ jsx11("div", { className: "fc-dialog-overlay", children: /* @__PURE__ */ jsxs9("div", { className: "fc-dialog fc-dialog--wide", children: [
+    /* @__PURE__ */ jsxs9("div", { className: "fc-dialog__header", children: [
+      /* @__PURE__ */ jsx11("span", { className: "fc-dialog__icon", children: "\u{1F50D}" }),
+      /* @__PURE__ */ jsxs9("h3", { className: "fc-dialog__title fc-dialog__title--warning", children: [
+        "\u68C0\u6D4B\u5230 ",
+        orphans.length,
+        " \u4E2A\u5B64\u7ACB\u5206\u7C7B"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx11("p", { className: "fc-dialog__desc", children: "\u4EE5\u4E0B\u5206\u7C7B\u7684\u7236\u5206\u7C7B\u5DF2\u4E0D\u5B58\u5728\uFF0C\u53EF\u80FD\u662F\u6570\u636E\u8FC1\u79FB\u6216\u5F02\u5E38\u5220\u9664\u5BFC\u81F4\u3002 \u8FD9\u4E9B\u5206\u7C7B\u76EE\u524D\u4E0D\u4F1A\u663E\u793A\u5728\u6811\u4E2D\uFF0C\u8BF7\u9009\u62E9\u5904\u7406\u65B9\u5F0F\uFF1A" }),
+    /* @__PURE__ */ jsx11("div", { className: "fc-orphan-list", children: orphans.map((node) => /* @__PURE__ */ jsxs9("div", { className: "fc-orphan-item", children: [
+      /* @__PURE__ */ jsx11("span", { className: "fc-orphan-name", title: node.key, children: node.title }),
+      /* @__PURE__ */ jsxs9("span", { className: "fc-orphan-id", children: [
+        "id: ",
+        node.key.slice(0, 8),
+        "\u2026"
+      ] }),
+      /* @__PURE__ */ jsxs9("div", { className: "fc-orphan-radios", children: [
+        /* @__PURE__ */ jsxs9("label", { className: `fc-orphan-radio ${resolutions[node.key] === "lift" ? "is-active" : ""}`, children: [
+          /* @__PURE__ */ jsx11(
+            "input",
+            {
+              type: "radio",
+              name: node.key,
+              checked: resolutions[node.key] === "lift",
+              onChange: () => set(node.key, "lift")
+            }
+          ),
+          "\u63D0\u5347\u4E3A\u6839\u5206\u7C7B"
+        ] }),
+        /* @__PURE__ */ jsxs9("label", { className: `fc-orphan-radio fc-orphan-radio--danger ${resolutions[node.key] === "remove" ? "is-active" : ""}`, children: [
+          /* @__PURE__ */ jsx11(
+            "input",
+            {
+              type: "radio",
+              name: node.key,
+              checked: resolutions[node.key] === "remove",
+              onChange: () => set(node.key, "remove")
+            }
+          ),
+          "\u5220\u9664"
+        ] })
+      ] })
+    ] }, node.key)) }),
+    /* @__PURE__ */ jsxs9("div", { className: "fc-dialog__footer", children: [
+      /* @__PURE__ */ jsx11("button", { className: "fc-dialog__btn", onClick: onClose, children: "\u6682\u65F6\u5FFD\u7565" }),
+      /* @__PURE__ */ jsx11(
+        "button",
+        {
+          className: "fc-dialog__btn fc-dialog__btn--primary",
+          onClick: () => onResolve(resolutions),
+          children: "\u786E\u8BA4\u5904\u7406"
+        }
+      )
+    ] })
+  ] }) });
+}
+
+// src/components/Avatar/Avatar.tsx
+import { useState as useState11, useMemo as useMemo3, useCallback as useCallback5, forwardRef as forwardRef2, useEffect as useEffect5 } from "react";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var SIZE_MAP = {
+  xs: 20,
+  sm: 28,
+  md: 40,
+  lg: 56,
+  xl: 72
+};
+var DEFAULT_ICON = "M12 12c2.21 0 4-1.79 4-4s-1.79-4-4-4-4 1.79-4 4 1.79 4 4 4zm0 2c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z";
+var useAvatarStyles = (size, shape, bordered, onClick, loadState, src, children, colorVariant, className, color, customStyle) => {
+  const classes = useMemo3(() => {
+    const classNames = [
+      "ui-avatar",
+      `ui-avatar-${size}`,
+      `ui-avatar-${shape}`,
+      bordered && "ui-avatar-bordered",
+      onClick && "ui-avatar-clickable",
+      loadState === "loading" && "ui-avatar-loading",
+      !src && !children && "ui-avatar-empty",
+      colorVariant && `ui-avatar--${colorVariant}`,
+      className
+    ];
+    return classNames.filter(Boolean).join(" ");
+  }, [size, shape, bordered, onClick, loadState, src, children, colorVariant, className]);
+  const style = useMemo3(() => ({
+    width: SIZE_MAP[size],
+    height: SIZE_MAP[size],
+    fontSize: `${SIZE_MAP[size] * 0.4}px`,
+    ...color && { backgroundColor: color },
+    ...customStyle
+  }), [size, color, customStyle]);
+  return { classes, style };
+};
+var useImageLoader = (src, fallbackSrc, onImageLoad, onImageError, onStateChange) => {
+  const [loadState, setLoadState] = useState11("idle");
+  const [currentSrc, setCurrentSrc] = useState11(src);
+  useEffect5(() => {
+    setCurrentSrc(src);
+    setLoadState(src ? "loading" : "idle");
+  }, [src]);
+  useEffect5(() => {
+    onStateChange?.(loadState);
+  }, [loadState, onStateChange]);
+  const handleLoad = useCallback5(() => {
+    setLoadState("loaded");
+    onImageLoad?.();
+  }, [onImageLoad]);
+  const handleError = useCallback5((e) => {
+    if (fallbackSrc && currentSrc !== fallbackSrc) {
+      setCurrentSrc(fallbackSrc);
+      setLoadState("loading");
+    } else {
+      setLoadState("error");
+      onImageError?.(e.nativeEvent);
+    }
+  }, [fallbackSrc, currentSrc, onImageError]);
+  return {
+    loadState,
+    currentSrc,
+    handleLoad,
+    handleError
+  };
+};
+var useKeyboardInteraction = (onClick) => {
+  const handleKeyDown = useCallback5((e) => {
+    if (onClick && (e.key === "Enter" || e.key === " ")) {
+      e.preventDefault();
+      onClick(e);
+    }
+  }, [onClick]);
+  return { handleKeyDown };
+};
+var renderContent = (currentSrc, fallbackSrc, loadState, alt, lazyLoad2, children, handleLoad, handleError) => {
+  const showImage = currentSrc && loadState !== "error";
+  const showFallback = !showImage && children;
+  const imageSrc = loadState === "error" && currentSrc !== fallbackSrc ? fallbackSrc : currentSrc;
+  if (showImage && imageSrc) {
+    return /* @__PURE__ */ jsx12(
+      "img",
+      {
+        src: imageSrc,
+        alt,
+        className: "ui-avatar-img",
+        loading: lazyLoad2 ? "lazy" : "eager",
+        onLoad: handleLoad,
+        onError: handleError,
+        decoding: "async"
+      }
+    );
+  }
+  if (showFallback) {
+    return /* @__PURE__ */ jsx12("span", { className: "ui-avatar-text", children });
+  }
+  return /* @__PURE__ */ jsx12("span", { className: "ui-avatar-placeholder", children: /* @__PURE__ */ jsx12("svg", { viewBox: "0 0 24 24", width: "40%", height: "40%", fill: "currentColor", opacity: 0.4, children: /* @__PURE__ */ jsx12("path", { d: DEFAULT_ICON }) }) });
+};
+var useAriaAttributes = (onClick, loadState, alt) => {
+  return {
+    role: onClick ? "button" : "img",
+    tabIndex: onClick ? 0 : void 0,
+    "aria-label": alt,
+    "aria-busy": loadState === "loading",
+    "data-load-state": loadState
+  };
+};
+var Avatar = forwardRef2(
+  ({
+    children,
+    src,
+    fallbackSrc,
+    color,
+    colorVariant,
+    size = "md",
+    shape = "circle",
+    alt = "\u7528\u6237\u5934\u50CF",
+    lazyLoad: lazyLoad2 = false,
+    onImageLoad,
+    onImageError,
+    onStateChange,
+    bordered = false,
+    className = "",
+    onClick,
+    style: customStyle,
+    ...restProps
+  }, ref) => {
+    const { loadState, currentSrc, handleLoad, handleError } = useImageLoader(
+      src,
+      fallbackSrc,
+      onImageLoad,
+      onImageError,
+      onStateChange
+    );
+    const { classes, style } = useAvatarStyles(
+      size,
+      shape,
+      bordered,
+      onClick,
+      loadState,
+      src,
+      children,
+      colorVariant,
+      className,
+      color,
+      customStyle
+    );
+    const { handleKeyDown } = useKeyboardInteraction(onClick);
+    const ariaAttributes = useAriaAttributes(onClick, loadState, alt);
+    const content = renderContent(
+      currentSrc,
+      fallbackSrc,
+      loadState,
+      alt,
+      lazyLoad2,
+      children,
+      handleLoad,
+      handleError
+    );
+    return /* @__PURE__ */ jsx12(
+      "div",
+      {
+        ref,
+        className: classes,
+        style,
+        onClick,
+        onKeyDown: handleKeyDown,
+        ...ariaAttributes,
+        ...restProps,
+        children: content
+      }
+    );
+  }
+);
+Avatar.displayName = "Avatar";
+
+// src/components/ListGroup/ListGroup.tsx
+import { forwardRef as forwardRef3, useMemo as useMemo4, useCallback as useCallback6 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var combineClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(" ");
+};
+var ListGroupItem = forwardRef3(
+  ({
+    active = false,
+    disabled = false,
+    onClick,
+    className,
+    children,
+    ...props
+  }, ref) => {
+    const handleClick = useCallback6((e) => {
+      if (disabled) return;
+      onClick?.(e);
+    }, [disabled, onClick]);
+    const classNames = useMemo4(() => {
+      return combineClassNames(
+        "fc-list-group-item",
+        active && "fc-list-group-item--active",
+        disabled && "fc-list-group-item--disabled",
+        className
+      );
+    }, [active, disabled, className]);
+    return /* @__PURE__ */ jsx13(
+      "li",
+      {
+        ref,
+        className: classNames,
+        onClick: handleClick,
+        "aria-disabled": disabled,
+        "aria-selected": active,
+        role: onClick ? "button" : void 0,
+        tabIndex: onClick && !disabled ? 0 : void 0,
+        ...props,
+        children
+      }
+    );
+  }
+);
+ListGroupItem.displayName = "ListGroupItem";
+var ListGroup = forwardRef3(
+  ({
+    bordered = true,
+    flush = false,
+    className,
+    children,
+    ...props
+  }, ref) => {
+    const classNames = useMemo4(() => {
+      return combineClassNames(
+        "fc-list-group",
+        bordered && "fc-list-group--bordered",
+        flush && "fc-list-group--flush",
+        className
+      );
+    }, [bordered, flush, className]);
+    return /* @__PURE__ */ jsx13(
+      "ul",
+      {
+        ref,
+        className: classNames,
+        role: "list",
+        ...props,
+        children
+      }
+    );
+  }
+);
+ListGroup.displayName = "ListGroup";
+
+// src/components/VirtualList/VirtualList.tsx
+import { useState as useState12, useRef as useRef5, useCallback as useCallback7, useMemo as useMemo5, useEffect as useEffect6 } from "react";
+import { jsx as jsx14 } from "react/jsx-runtime";
+function VirtualList({
+  data,
+  height,
+  itemHeight,
+  renderItem,
+  className = "",
+  overscan = 3,
+  showScrollbar = true,
+  onScrollEnd,
+  style
+}) {
+  const containerRef = useRef5(null);
+  const [scrollTop, setScrollTop] = useState12(0);
+  const totalHeight = data.length * itemHeight;
+  const handleScroll = useCallback7((e) => {
+    const newScrollTop = e.currentTarget.scrollTop;
+    setScrollTop(newScrollTop);
+    if (onScrollEnd) {
+      const scrollHeight = e.currentTarget.scrollHeight;
+      const clientHeight = e.currentTarget.clientHeight;
+      if (newScrollTop + clientHeight >= scrollHeight - 5) {
+        onScrollEnd();
+      }
+    }
+  }, [onScrollEnd]);
+  const visibleRange = useMemo5(() => {
+    const startIndex = Math.max(0, Math.floor(scrollTop / itemHeight) - overscan);
+    const endIndex = Math.min(
+      data.length,
+      Math.ceil((scrollTop + height) / itemHeight) + overscan
+    );
+    return { startIndex, endIndex };
+  }, [scrollTop, height, itemHeight, data.length, overscan]);
+  const visibleData = useMemo5(() => {
+    return data.slice(visibleRange.startIndex, visibleRange.endIndex);
+  }, [data, visibleRange]);
+  const offsetY = visibleRange.startIndex * itemHeight;
+  useEffect6(() => {
+    if (!showScrollbar && containerRef.current) {
+      containerRef.current.style.scrollbarWidth = "none";
+    }
+  }, [showScrollbar]);
+  const classNames = [
+    "fc-virtual-list",
+    !showScrollbar && "fc-virtual-list--hide-scrollbar",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsx14(
+    "div",
+    {
+      ref: containerRef,
+      className: classNames,
+      style: { height: `${height}px`, ...style },
+      onScroll: handleScroll,
+      children: /* @__PURE__ */ jsx14(
+        "div",
+        {
+          className: "fc-virtual-list__container",
+          style: { height: `${totalHeight}px` },
+          children: /* @__PURE__ */ jsx14(
+            "div",
+            {
+              className: "fc-virtual-list__content",
+              style: { transform: `translateY(${offsetY}px)` },
+              children: visibleData.map((item, idx) => {
+                const actualIndex = visibleRange.startIndex + idx;
+                return /* @__PURE__ */ jsx14(
+                  "div",
+                  {
+                    className: "fc-virtual-list__item",
+                    style: { height: `${itemHeight}px` },
+                    children: renderItem(item, actualIndex)
+                  },
+                  actualIndex
+                );
+              })
+            }
+          )
+        }
+      )
     }
   );
 }
+
+// src/components/Alert/AlertContext.tsx
+import { createContext as createContext3, useContext as useContext3, useState as useState13 } from "react";
+import { jsx as jsx15, jsxs as jsxs10 } from "react/jsx-runtime";
+var AlertContext = createContext3(null);
+var ICONS = {
+  success: /* @__PURE__ */ jsxs10(
+    "svg",
+    {
+      className: "fc-alert__icon",
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx15("circle", { cx: "12", cy: "12", r: "10" }),
+        /* @__PURE__ */ jsx15("polyline", { points: "17 9 11 17 6 12" })
+      ]
+    }
+  ),
+  error: /* @__PURE__ */ jsxs10(
+    "svg",
+    {
+      className: "fc-alert__icon",
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx15("circle", { cx: "12", cy: "12", r: "10" }),
+        /* @__PURE__ */ jsx15("line", { x1: "15", y1: "9", x2: "9", y2: "15" }),
+        /* @__PURE__ */ jsx15("line", { x1: "9", y1: "9", x2: "15", y2: "15" })
+      ]
+    }
+  ),
+  warning: /* @__PURE__ */ jsxs10(
+    "svg",
+    {
+      className: "fc-alert__icon",
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx15("path", { d: "M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" }),
+        /* @__PURE__ */ jsx15("line", { x1: "12", y1: "9", x2: "12", y2: "13" }),
+        /* @__PURE__ */ jsx15("line", { x1: "12", y1: "17", x2: "12.01", y2: "17" })
+      ]
+    }
+  ),
+  info: /* @__PURE__ */ jsxs10(
+    "svg",
+    {
+      className: "fc-alert__icon",
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      children: [
+        /* @__PURE__ */ jsx15("circle", { cx: "12", cy: "12", r: "10" }),
+        /* @__PURE__ */ jsx15("line", { x1: "12", y1: "8", x2: "12", y2: "12" }),
+        /* @__PURE__ */ jsx15("line", { x1: "12", y1: "16", x2: "12.01", y2: "16" })
+      ]
+    }
+  )
+};
+function AlertProvider({ children }) {
+  const [props, setProps] = useState13({
+    msg: "",
+    type: "info",
+    visible: false,
+    choice: () => {
+    }
+  });
+  const showAlert = (msg, type, confirm = false) => new Promise((resolve) => {
+    setProps({
+      msg,
+      type,
+      visible: true,
+      confirm,
+      choice: (res) => {
+        setProps((p) => ({ ...p, visible: false }));
+        resolve(res);
+      }
+    });
+  });
+  return /* @__PURE__ */ jsxs10(AlertContext.Provider, { value: { showAlert }, children: [
+    children,
+    props.visible && /* @__PURE__ */ jsx15("div", { className: "fc-alert-overlay", children: /* @__PURE__ */ jsxs10("div", { className: `fc-alert fc-alert--${props.type}`, children: [
+      /* @__PURE__ */ jsxs10("div", { className: "fc-alert__header", children: [
+        ICONS[props.type],
+        /* @__PURE__ */ jsx15("span", { className: "fc-alert__title", children: "\u63D0\u793A" })
+      ] }),
+      /* @__PURE__ */ jsx15(RollingBox, { className: "fc-alert__msg", children: props.msg }),
+      /* @__PURE__ */ jsxs10("div", { className: "fc-alert__footer", children: [
+        props.confirm && /* @__PURE__ */ jsx15(
+          Button,
+          {
+            variant: "secondary",
+            size: "sm",
+            onClick: () => props.choice("no"),
+            children: "\u53D6\u6D88"
+          }
+        ),
+        /* @__PURE__ */ jsx15(
+          Button,
+          {
+            variant: "primary",
+            size: "sm",
+            onClick: () => props.choice("yes"),
+            children: "\u786E\u5B9A"
+          }
+        )
+      ] })
+    ] }) })
+  ] });
+}
+var useAlert = () => useContext3(AlertContext);
+
+// src/components/LazyLoad/LazyLoad.tsx
+import { lazy, Suspense } from "react";
+import { jsx as jsx16, jsxs as jsxs11 } from "react/jsx-runtime";
+function lazyLoad(importFn, options = {}) {
+  const { fallback = /* @__PURE__ */ jsx16(LazySpinner, {}), timeout = 1e4 } = options;
+  const LazyComponent = lazy(() => {
+    let timeoutId;
+    const loadPromise = Promise.race([
+      importFn(),
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(`\u52A0\u8F7D\u8D85\u65F6`)), timeout);
+      })
+    ]).finally(() => clearTimeout(timeoutId));
+    return loadPromise;
+  });
+  return (props) => /* @__PURE__ */ jsx16(Suspense, { fallback, children: /* @__PURE__ */ jsx16(LazyComponent, { ...props }) });
+}
+function LazySpinner() {
+  return /* @__PURE__ */ jsxs11("div", { className: "fc-lazy-spinner", children: [
+    /* @__PURE__ */ jsx16("div", { className: "fc-lazy-spinner-dot" }),
+    /* @__PURE__ */ jsx16("div", { className: "fc-lazy-spinner-dot" }),
+    /* @__PURE__ */ jsx16("div", { className: "fc-lazy-spinner-dot" })
+  ] });
+}
+
+// src/components/Card/Card.tsx
+import { jsx as jsx17, jsxs as jsxs12 } from "react/jsx-runtime";
+var Card = ({
+  image,
+  imageSlot,
+  imageHeight = 200,
+  title,
+  description,
+  actions,
+  extraInfo,
+  variant = "default",
+  hoverable = false,
+  disabled = false,
+  className = "",
+  style,
+  onClick
+}) => {
+  const handleClick = () => {
+    if (!disabled && onClick) {
+      onClick();
+    }
+  };
+  const classes = [
+    "fc-card",
+    `fc-card--${variant}`,
+    hoverable && "fc-card--hoverable",
+    disabled && "fc-card--disabled",
+    onClick && "fc-card--clickable",
+    className
+  ].filter(Boolean).join(" ");
+  const renderImage = () => {
+    if (imageSlot) return imageSlot;
+    if (image) {
+      return /* @__PURE__ */ jsx17(
+        "img",
+        {
+          className: "fc-card__image",
+          src: image,
+          alt: typeof title === "string" ? title : "card image"
+        }
+      );
+    }
+    return null;
+  };
+  return /* @__PURE__ */ jsxs12("div", { className: classes, style, onClick: handleClick, children: [
+    renderImage() && /* @__PURE__ */ jsx17(
+      "div",
+      {
+        className: "fc-card__image-wrapper",
+        style: { height: imageHeight },
+        children: renderImage()
+      }
+    ),
+    /* @__PURE__ */ jsxs12("div", { className: "fc-card__content", children: [
+      title && /* @__PURE__ */ jsx17("div", { className: "fc-card__title", children: title }),
+      description && /* @__PURE__ */ jsx17("div", { className: "fc-card__description", children: description }),
+      extraInfo && /* @__PURE__ */ jsx17("div", { className: "fc-card__extra-info", children: extraInfo }),
+      actions && /* @__PURE__ */ jsx17("div", { className: "fc-card__actions", children: actions })
+    ] })
+  ] });
+};
+
+// src/components/Tabs/Tabs.tsx
+import { useState as useState14 } from "react";
+import { jsx as jsx18, jsxs as jsxs13 } from "react/jsx-runtime";
+var Tabs = ({
+  items,
+  activeKey: controlledActiveKey,
+  defaultActiveKey,
+  radius = "md",
+  closable = false,
+  addable = false,
+  onChange,
+  onClose,
+  onAdd,
+  className = "",
+  style
+}) => {
+  const [internalActiveKey, setInternalActiveKey] = useState14(
+    defaultActiveKey || items[0]?.key || ""
+  );
+  const activeKey = controlledActiveKey !== void 0 ? controlledActiveKey : internalActiveKey;
+  const handleTabClick = (key, disabled) => {
+    if (disabled) return;
+    if (controlledActiveKey === void 0) {
+      setInternalActiveKey(key);
+    }
+    onChange?.(key);
+  };
+  const handleClose = (e, key) => {
+    e.stopPropagation();
+    onClose?.(key);
+    if (key === activeKey) {
+      const currentIndex = items.findIndex((item) => item.key === key);
+      const nextItem = items[currentIndex + 1] || items[currentIndex - 1];
+      if (nextItem && !nextItem.disabled) {
+        handleTabClick(nextItem.key);
+      }
+    }
+  };
+  const classes = [
+    "fc-tabs",
+    `fc-tabs--radius-${radius}`,
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs13("div", { className: classes, style, children: [
+    /* @__PURE__ */ jsx18("div", { className: "fc-tabs__nav", children: /* @__PURE__ */ jsxs13("div", { className: "fc-tabs__nav-wrap", children: [
+      items.map((item) => {
+        const isActive = activeKey === item.key;
+        return /* @__PURE__ */ jsxs13(
+          "div",
+          {
+            className: `fc-tabs__tab ${isActive ? "fc-tabs__tab--active" : ""} ${item.disabled ? "fc-tabs__tab--disabled" : ""}`,
+            onClick: () => handleTabClick(item.key, item.disabled),
+            children: [
+              /* @__PURE__ */ jsx18("span", { className: "fc-tabs__tab-label", children: item.label }),
+              closable && /* @__PURE__ */ jsx18(
+                "span",
+                {
+                  className: "fc-tabs__tab-close",
+                  onClick: (e) => handleClose(e, item.key),
+                  children: "\xD7"
+                }
+              )
+            ]
+          },
+          item.key
+        );
+      }),
+      addable && /* @__PURE__ */ jsx18("div", { className: "fc-tabs__add-btn", onClick: onAdd, children: "+" })
+    ] }) }),
+    /* @__PURE__ */ jsx18("div", { className: "fc-tabs__content", children: items.find((item) => item.key === activeKey)?.content })
+  ] });
+};
+
+// src/components/Chat/Chat.tsx
+import { useState as useState15, useRef as useRef6, useEffect as useEffect7, useCallback as useCallback8 } from "react";
+import { Fragment as Fragment3, jsx as jsx19, jsxs as jsxs14 } from "react/jsx-runtime";
+var Chat = ({
+  messages = [],
+  onSendMessage,
+  placeholder = "\u8F93\u5165\u6D88\u606F...",
+  title = "AI \u52A9\u624B",
+  height = "600px",
+  showHeader = true,
+  showFooter = true,
+  loading = false,
+  disabled = false,
+  theme: propTheme,
+  userName = "\u6211",
+  assistantName = "AI\u52A9\u624B",
+  onTyping,
+  maxInputLength = 2e3,
+  autoFocus = true,
+  enableCopy = true
+}) => {
+  const [inputValue, setInputValue] = useState15("");
+  const [isTyping, setIsTyping] = useState15(false);
+  const [isSending, setIsSending] = useState15(false);
+  const [currentTheme, setCurrentTheme] = useState15("light");
+  const [copiedMessageId, setCopiedMessageId] = useState15(null);
+  const [copyError, setCopyError] = useState15(null);
+  const messagesEndRef = useRef6(null);
+  const inputRef = useRef6(null);
+  useEffect7(() => {
+    if (propTheme) {
+      setCurrentTheme(propTheme);
+    } else {
+      const checkTheme = () => {
+        const dataTheme = document.documentElement.getAttribute("data-theme");
+        if (dataTheme === "dark") {
+          setCurrentTheme("dark");
+        } else if (dataTheme === "light") {
+          setCurrentTheme("light");
+        } else {
+          const hasDarkClass = document.documentElement.classList.contains("dark") || document.body.classList.contains("dark") || document.documentElement.classList.contains("theme-dark") || document.body.classList.contains("theme-dark");
+          setCurrentTheme(hasDarkClass ? "dark" : "light");
+        }
+      };
+      checkTheme();
+      const observer = new MutationObserver(checkTheme);
+      observer.observe(document.documentElement, {
+        attributes: true,
+        attributeFilter: ["data-theme", "class"]
+      });
+      observer.observe(document.body, {
+        attributes: true,
+        attributeFilter: ["class"]
+      });
+      return () => observer.disconnect();
+    }
+  }, [propTheme]);
+  useEffect7(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages, loading]);
+  useEffect7(() => {
+    if (autoFocus && !disabled && inputRef.current) {
+      inputRef.current.focus();
+    }
+  }, [autoFocus, disabled]);
+  useEffect7(() => {
+    if (copyError) {
+      const timer = setTimeout(() => {
+        setCopyError(null);
+      }, 2e3);
+      return () => clearTimeout(timer);
+    }
+  }, [copyError]);
+  const handleCopyMessage = useCallback8(async (messageId, content) => {
+    if (!navigator.clipboard) {
+      setCopyError("\u5F53\u524D\u6D4F\u89C8\u5668\u4E0D\u652F\u6301\u590D\u5236\u529F\u80FD");
+      return;
+    }
+    try {
+      await navigator.clipboard.writeText(content);
+      setCopiedMessageId(messageId);
+      setTimeout(() => {
+        setCopiedMessageId(null);
+      }, 2e3);
+    } catch (err) {
+      console.error("\u590D\u5236\u5931\u8D25:", err);
+      if (err instanceof Error) {
+        if (err.name === "NotAllowedError") {
+          setCopyError("\u9700\u8981\u526A\u8D34\u677F\u6743\u9650\uFF0C\u8BF7\u5141\u8BB8\u540E\u91CD\u8BD5");
+        } else if (err.name === "SecurityError") {
+          setCopyError("\u51FA\u4E8E\u5B89\u5168\u539F\u56E0\uFF0C\u65E0\u6CD5\u590D\u5236\u5185\u5BB9");
+        } else {
+          setCopyError("\u590D\u5236\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5");
+        }
+      } else {
+        setCopyError("\u590D\u5236\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5");
+      }
+      setTimeout(() => {
+        setCopyError(null);
+      }, 3e3);
+    }
+  }, []);
+  const handleSend = useCallback8(() => {
+    const trimmedMessage = inputValue.trim();
+    if (!trimmedMessage || disabled || loading || isSending) return;
+    if (trimmedMessage.length > maxInputLength) {
+      console.warn(`\u6D88\u606F\u8D85\u8FC7\u6700\u5927\u957F\u5EA6\u9650\u5236: ${maxInputLength}`);
+      return;
+    }
+    setIsSending(true);
+    const sendPromise = onSendMessage?.(trimmedMessage);
+    if (sendPromise) {
+      void sendPromise.then(() => {
+        setInputValue("");
+        if (inputRef.current) {
+          inputRef.current.style.height = "auto";
+        }
+        if (isTyping) {
+          setIsTyping(false);
+          onTyping?.(false);
+        }
+      }).catch((error) => {
+        console.error("\u53D1\u9001\u6D88\u606F\u5931\u8D25:", error);
+      }).finally(() => {
+        setIsSending(false);
+      });
+    } else {
+      setInputValue("");
+      if (inputRef.current) {
+        inputRef.current.style.height = "auto";
+      }
+      if (isTyping) {
+        setIsTyping(false);
+        onTyping?.(false);
+      }
+      setIsSending(false);
+    }
+  }, [inputValue, disabled, loading, isSending, onSendMessage, maxInputLength, isTyping, onTyping]);
+  const handleKeyDown = useCallback8((e) => {
+    if (e.key === "Enter" && !e.shiftKey && !e.nativeEvent.isComposing) {
+      e.preventDefault();
+      handleSend();
+    }
+  }, [handleSend]);
+  const handleInputChange = useCallback8((e) => {
+    const value = e.target.value;
+    if (value.length <= maxInputLength) {
+      setInputValue(value);
+      e.target.style.height = "auto";
+      e.target.style.height = `${Math.min(e.target.scrollHeight, 100)}px`;
+      const hasContent = value.length > 0;
+      if (hasContent !== isTyping) {
+        setIsTyping(hasContent);
+        onTyping?.(hasContent);
+      }
+    }
+  }, [maxInputLength, isTyping, onTyping]);
+  const formatTime = useCallback8((date) => {
+    return new Date(date).toLocaleTimeString("zh-CN", {
+      hour: "2-digit",
+      minute: "2-digit"
+    });
+  }, []);
+  const renderMessage = (message) => {
+    const isUser = message.type === "user";
+    const isSystem = message.type === "system";
+    const isCopied = copiedMessageId === message.id;
+    if (isSystem) {
+      return /* @__PURE__ */ jsx19("div", { className: "chat-message-system", children: /* @__PURE__ */ jsx19("span", { className: "system-content", children: message.content }) }, message.id);
+    }
+    return /* @__PURE__ */ jsxs14("div", { className: `chat-message ${isUser ? "user" : "assistant"}`, children: [
+      !isUser && /* @__PURE__ */ jsx19("div", { className: "message-avatar", children: assistantName[0] }),
+      /* @__PURE__ */ jsxs14("div", { className: "message-content-wrapper", children: [
+        /* @__PURE__ */ jsxs14("div", { className: "message-header", children: [
+          /* @__PURE__ */ jsx19("span", { className: "message-sender", children: isUser ? userName : assistantName }),
+          /* @__PURE__ */ jsx19("span", { className: "message-time", children: formatTime(message.timestamp) })
+        ] }),
+        /* @__PURE__ */ jsxs14("div", { className: "message-bubble", children: [
+          /* @__PURE__ */ jsx19("div", { className: "message-text", children: message.content }),
+          message.status === "sending" && /* @__PURE__ */ jsx19("span", { className: "message-status sending", children: "\u53D1\u9001\u4E2D..." }),
+          message.status === "error" && /* @__PURE__ */ jsx19("span", { className: "message-status error", children: "\u53D1\u9001\u5931\u8D25" })
+        ] }),
+        enableCopy && /* @__PURE__ */ jsx19(
+          "button",
+          {
+            className: `copy-btn ${isCopied ? "copied" : ""}`,
+            onClick: () => handleCopyMessage(message.id, message.content),
+            title: isCopied ? "\u5DF2\u590D\u5236" : "\u590D\u5236\u5185\u5BB9",
+            "aria-label": isCopied ? "\u5DF2\u590D\u5236" : "\u590D\u5236\u5185\u5BB9",
+            children: isCopied ? /* @__PURE__ */ jsxs14(Fragment3, { children: [
+              /* @__PURE__ */ jsx19("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ jsx19("path", { d: "M20 6L9 17L4 12", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }) }),
+              /* @__PURE__ */ jsx19("span", { children: "\u5DF2\u590D\u5236" })
+            ] }) : /* @__PURE__ */ jsxs14(Fragment3, { children: [
+              /* @__PURE__ */ jsxs14("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+                /* @__PURE__ */ jsx19("rect", { x: "9", y: "9", width: "13", height: "13", rx: "2", stroke: "currentColor", strokeWidth: "2" }),
+                /* @__PURE__ */ jsx19("path", { d: "M5 15H4C2.9 15 2 14.1 2 13V4C2 2.9 2.9 2 4 2H13C14.1 2 15 2.9 15 4V5", stroke: "currentColor", strokeWidth: "2" })
+              ] }),
+              /* @__PURE__ */ jsx19("span", { children: "\u590D\u5236" })
+            ] })
+          }
+        )
+      ] })
+    ] }, message.id);
+  };
+  return /* @__PURE__ */ jsxs14("div", { className: `chat-container ${currentTheme}`, style: { height }, children: [
+    showHeader && /* @__PURE__ */ jsxs14("div", { className: "chat-header", children: [
+      /* @__PURE__ */ jsx19("div", { className: "chat-title", children: title }),
+      /* @__PURE__ */ jsxs14("div", { className: "chat-status", children: [
+        (loading || isSending) && /* @__PURE__ */ jsx19("span", { className: "status-dot" }),
+        /* @__PURE__ */ jsx19("span", { children: loading || isSending ? "AI \u6B63\u5728\u601D\u8003..." : "\u5728\u7EBF" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs14("div", { className: "chat-messages", children: [
+      messages.map(renderMessage),
+      (loading || isSending) && /* @__PURE__ */ jsxs14("div", { className: "chat-message assistant", children: [
+        /* @__PURE__ */ jsx19("div", { className: "message-avatar", children: assistantName[0] }),
+        /* @__PURE__ */ jsxs14("div", { className: "message-content-wrapper", children: [
+          /* @__PURE__ */ jsx19("div", { className: "message-header", children: /* @__PURE__ */ jsx19("span", { className: "message-sender", children: assistantName }) }),
+          /* @__PURE__ */ jsx19("div", { className: "message-bubble", children: /* @__PURE__ */ jsxs14("div", { className: "typing-indicator", children: [
+            /* @__PURE__ */ jsx19("span", {}),
+            /* @__PURE__ */ jsx19("span", {}),
+            /* @__PURE__ */ jsx19("span", {})
+          ] }) })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx19("div", { ref: messagesEndRef })
+    ] }),
+    copyError && /* @__PURE__ */ jsx19("div", { className: "copy-error-toast", children: copyError }),
+    showFooter && /* @__PURE__ */ jsxs14("div", { className: "chat-footer", children: [
+      /* @__PURE__ */ jsxs14("div", { className: "chat-input-wrapper", children: [
+        /* @__PURE__ */ jsx19(
+          "textarea",
+          {
+            ref: inputRef,
+            className: "chat-input",
+            value: inputValue,
+            onChange: handleInputChange,
+            onKeyDown: handleKeyDown,
+            placeholder,
+            disabled: disabled || loading || isSending,
+            rows: 1,
+            maxLength: maxInputLength,
+            spellCheck: false,
+            autoCorrect: "off",
+            autoCapitalize: "off",
+            autoComplete: "off"
+          }
+        ),
+        /* @__PURE__ */ jsx19(
+          "button",
+          {
+            className: `chat-send-btn ${!inputValue.trim() || disabled || loading || isSending ? "disabled" : ""}`,
+            onClick: handleSend,
+            disabled: !inputValue.trim() || disabled || loading || isSending,
+            children: "\u53D1\u9001"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs14("div", { className: "chat-tips", children: [
+        /* @__PURE__ */ jsx19("span", { children: "\u6309 Enter \u53D1\u9001\uFF0CShift + Enter \u6362\u884C" }),
+        maxInputLength && /* @__PURE__ */ jsxs14("span", { className: "char-count", children: [
+          inputValue.length,
+          "/",
+          maxInputLength
+        ] })
+      ] })
+    ] })
+  ] });
+};
 export {
-  Button
+  AlertProvider,
+  Avatar,
+  Button,
+  ButtonGroup,
+  ButtonToolbar,
+  Card,
+  Chat,
+  CheckButton,
+  DeleteDialog,
+  Input,
+  ListGroup,
+  ListGroupItem,
+  OrphanDialog,
+  RollingBox,
+  Select,
+  SideBar,
+  Slider,
+  Tabs,
+  ThemeProvider,
+  Tree,
+  VirtualList,
+  findNodeInfo,
+  flatToTree,
+  isDescendantOf,
+  lazyLoad,
+  useAlert,
+  useTheme
 };