flowcloudai-ui 0.0.0 → 0.1.1

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,37 +17,2821 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Button: () => Button
+  AlertProvider: () => AlertProvider,
+  Avatar: () => Avatar,
+  Button: () => Button,
+  ButtonGroup: () => ButtonGroup,
+  ButtonToolbar: () => ButtonToolbar,
+  Card: () => Card,
+  Chat: () => Chat,
+  CheckButton: () => CheckButton,
+  ContextMenuProvider: () => ContextMenuProvider,
+  DeleteDialog: () => DeleteDialog,
+  Input: () => Input,
+  ListGroup: () => ListGroup,
+  ListGroupItem: () => ListGroupItem,
+  MarkdownEditor: () => MarkdownEditor,
+  OrphanDialog: () => OrphanDialog,
+  RollingBox: () => RollingBox,
+  Select: () => Select,
+  SideBar: () => SideBar,
+  Slider: () => Slider,
+  SmartMessage: () => SmartMessage,
+  TabBar: () => TabBar,
+  TagItem: () => TagItem,
+  ThemeProvider: () => ThemeProvider,
+  Tree: () => Tree,
+  VirtualList: () => VirtualList,
+  findNodeInfo: () => findNodeInfo,
+  flatToTree: () => flatToTree,
+  isDescendantOf: () => isDescendantOf,
+  lazyLoad: () => lazyLoad,
+  useAlert: () => useAlert,
+  useContextMenu: () => useContextMenu,
+  useTheme: () => useTheme
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/Button.tsx
+// src/ThemeProvider.tsx
+var import_react = require("react");
 var import_jsx_runtime = require("react/jsx-runtime");
-function Button({ children, style, ...props }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+var ThemeContext = (0, import_react.createContext)(null);
+function useTheme() {
+  const ctx = (0, import_react.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] = (0, import_react.useState)(defaultTheme);
+  const [systemTheme, setSystemTheme] = (0, import_react.useState)(getSystemTheme);
+  const resolvedTheme = theme === "system" ? systemTheme : theme;
+  (0, import_react.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]);
+  (0, import_react.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__ */ (0, import_jsx_runtime.jsx)(ThemeContext.Provider, { value: { theme, resolvedTheme, setTheme }, children });
+}
+
+// src/components/Button/Button.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function Button({
+  variant = "primary",
+  size = "md",
+  disabled = false,
+  loading = false,
+  block = false,
+  circle = false,
+  iconOnly = false,
+  iconLeft,
+  iconRight,
+  background,
+  hoverBackground,
+  activeBackground,
+  color,
+  hoverColor,
+  activeColor,
+  borderColor,
+  hoverBorderColor,
+  className,
+  style,
+  children,
+  ...props
+}) {
+  const colorVars = {
+    "--btn-bg": background,
+    "--btn-bg-hover": hoverBackground,
+    "--btn-bg-active": activeBackground,
+    "--btn-color": color,
+    "--btn-color-hover": hoverColor,
+    "--btn-color-active": activeColor,
+    "--btn-border": borderColor,
+    "--btn-border-hover": hoverBorderColor
+  };
+  const overrideStyle = {};
+  for (const [key, value] of Object.entries(colorVars)) {
+    if (value !== void 0) {
+      overrideStyle[key] = value;
+    }
+  }
+  const mergedStyle = {
+    ...overrideStyle,
+    ...style
+  };
+  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__ */ (0, import_jsx_runtime2.jsxs)(
     "button",
     {
+      className: classNames,
+      disabled: disabled || loading,
+      style: mergedStyle,
+      ...props,
+      children: [
+        iconLeft && !loading && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "fc-btn__icon fc-btn__icon--left", children: iconLeft }),
+        children,
+        iconRight && !loading && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "fc-btn__icon fc-btn__icon--right", children: iconRight })
+      ]
+    }
+  );
+}
+function ButtonGroup({ children, className, ...props }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("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__ */ (0, import_jsx_runtime2.jsx)("div", { className: `fc-btn-toolbar ${alignClass} ${className ?? ""}`, ...props, children });
+}
+
+// src/components/Button/CheckButton.tsx
+var React = __toESM(require("react"), 1);
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function CheckButton({
+  checked: controlledChecked,
+  defaultChecked = false,
+  onChange,
+  disabled = false,
+  size = "md",
+  labelLeft,
+  labelRight,
+  trackBackground,
+  checkedTrackBackground,
+  thumbBackground,
+  thumbDotColor,
+  labelColor,
+  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 colorVars = {
+    "--check-track-bg": trackBackground,
+    "--check-track-bg-checked": checkedTrackBackground,
+    "--check-thumb-bg": thumbBackground,
+    "--check-thumb-dot-color": thumbDotColor,
+    "--check-label-color": labelColor
+  };
+  const overrideStyle = {};
+  for (const [key, value] of Object.entries(colorVars)) {
+    if (value !== void 0) {
+      overrideStyle[key] = value;
+    }
+  }
+  const mergedStyle = {
+    ...overrideStyle,
+    ...style
+  };
+  const cls = [
+    "fc-check",
+    `fc-check--${size}`,
+    checked && "fc-check--checked",
+    disabled && "fc-check--disabled",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    "div",
+    {
+      className: cls,
+      style: mergedStyle,
+      role: "switch",
+      "aria-checked": checked,
+      tabIndex: disabled ? -1 : 0,
+      onClick: toggle,
+      onKeyDown: handleKeyDown,
+      children: [
+        labelLeft && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "fc-check__label", children: labelLeft }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "fc-check__track", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "fc-check__thumb", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "fc-check__thumb-inner" }) }) }),
+        labelRight && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "fc-check__label", children: labelRight })
+      ]
+    }
+  );
+}
+
+// src/components/Box/RollingBox.tsx
+var React2 = __toESM(require("react"), 1);
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function RollingBox({
+  showThumb = "auto",
+  horizontal = false,
+  vertical = true,
+  thumbSize = "normal",
+  showTrack = false,
+  children,
+  className,
+  thumbColor,
+  thumbHoverColor,
+  thumbActiveColor,
+  trackColor,
+  style,
+  ...props
+}) {
+  const colorVars = {
+    "--roll-thumb": thumbColor,
+    "--roll-thumb-hover": thumbHoverColor,
+    "--roll-thumb-active": thumbActiveColor,
+    "--roll-track": trackColor
+  };
+  const overrideStyle = {};
+  for (const [key, value] of Object.entries(colorVars)) {
+    if (value !== void 0) {
+      overrideStyle[key] = value;
+    }
+  }
+  const mergedStyle = { ...overrideStyle, ...style };
+  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__ */ (0, import_jsx_runtime4.jsx)(
+    "div",
+    {
+      ref: containerRef,
+      className: classNames,
+      style: mergedStyle,
+      onScroll: handleScroll,
       ...props,
-      style: {
-        padding: "10px 16px",
-        border: "none",
-        borderRadius: 10,
-        background: "#863bff",
-        color: "#fff",
-        cursor: "pointer",
-        fontSize: 14,
-        ...style
+      children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "fc-roll__content", children })
+    }
+  );
+}
+
+// src/components/Bar/SideBar.tsx
+var import_react2 = require("react");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var SideBarItemView = (0, import_react2.memo)(({ item, isSelected, onClick }) => {
+  const classes = [
+    "fc-sidebar__item",
+    isSelected && "fc-sidebar__item--selected",
+    item.disabled && "fc-sidebar__item--disabled"
+  ].filter(Boolean).join(" ");
+  const Tag = item.href ? "a" : "div";
+  const linkProps = item.href ? { href: item.href } : {};
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+    Tag,
+    {
+      className: classes,
+      onClick: () => !item.disabled && onClick(item.key),
+      ...linkProps,
+      children: [
+        item.icon && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "fc-sidebar__icon", children: item.icon }),
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { className: "fc-sidebar__label", children: item.label })
+      ]
+    }
+  );
+});
+SideBarItemView.displayName = "SideBarItemView";
+var SideBar = (0, import_react2.memo)(({
+  items,
+  selectedKey,
+  collapsed,
+  width = 240,
+  collapsedWidth = 64,
+  onSelect,
+  onCollapse,
+  className = "",
+  style
+}) => {
+  const handleClick = (0, import_react2.useCallback)(
+    (key) => onSelect(key),
+    [onSelect]
+  );
+  const toggleCollapse = (0, import_react2.useCallback)(
+    () => onCollapse(!collapsed),
+    [collapsed, onCollapse]
+  );
+  const rootClasses = [
+    "fc-sidebar",
+    collapsed && "fc-sidebar--collapsed",
+    className
+  ].filter(Boolean).join(" ");
+  const rootStyle = {
+    "--sidebar-width": `${collapsed ? collapsedWidth : width}px`,
+    "--sidebar-collapsed-width": `${collapsedWidth}px`,
+    ...style
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("aside", { className: rootClasses, style: rootStyle, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: "fc-sidebar__header", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      "button",
+      {
+        className: "fc-sidebar__collapse-btn",
+        onClick: toggleCollapse,
+        children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          "svg",
+          {
+            className: "fc-sidebar__collapse-icon",
+            width: "16",
+            height: "16",
+            viewBox: "0 0 16 16",
+            fill: "none",
+            xmlns: "http://www.w3.org/2000/svg",
+            children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+              "path",
+              {
+                d: collapsed ? "M6 3L11 8L6 13" : "M10 3L5 8L10 13",
+                stroke: "currentColor",
+                strokeWidth: "1.5",
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }
+            )
+          }
+        )
+      }
+    ) }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("nav", { className: "fc-sidebar__menu", children: items.map((item) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      SideBarItemView,
+      {
+        item,
+        isSelected: selectedKey === item.key,
+        onClick: handleClick
       },
-      children
+      item.key
+    )) })
+  ] });
+});
+SideBar.displayName = "SideBar";
+
+// src/components/Input/Input.tsx
+var React4 = __toESM(require("react"), 1);
+var import_jsx_runtime6 = require("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__ */ (0, import_jsx_runtime6.jsx)(
+    "input",
+    {
+      ref,
+      type,
+      value: currentValue,
+      onChange: handleChange,
+      disabled,
+      className: "fc-input__field",
+      ...props
+    }
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { className: classNames, children: [
+    addonBefore && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "fc-input__addon fc-input__addon--before", children: addonBefore }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { className: "fc-input__wrapper", children: [
+      prefix && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "fc-input__prefix", children: prefix }),
+      input,
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("span", { className: "fc-input__actions", children: [
+        showClear && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          "button",
+          {
+            type: "button",
+            className: "fc-input__action fc-input__clear",
+            onClick: handleClear,
+            tabIndex: -1,
+            children: "\u2715"
+          }
+        ),
+        showPasswordToggle && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          "button",
+          {
+            type: "button",
+            className: "fc-input__action fc-input__eye",
+            onClick: togglePassword,
+            tabIndex: -1,
+            children: type === "password" ? "\u{1F441}" : "\u{1F648}"
+          }
+        ),
+        suffix && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "fc-input__suffix", children: suffix })
+      ] })
+    ] }),
+    addonAfter && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "fc-input__addon fc-input__addon--after", children: addonAfter }),
+    helperText && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: `fc-input__helper fc-input__helper--${status}`, children: helperText })
+  ] });
+});
+Input.displayName = "Input";
+
+// src/components/Slider/Slider.tsx
+var React5 = __toESM(require("react"), 1);
+var import_jsx_runtime7 = require("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 = "",
+  style,
+  trackBackground,
+  fillBackground,
+  thumbBackground,
+  thumbBorderColor,
+  markDotColor,
+  markLabelColor,
+  tooltipBackground,
+  tooltipColor
+}) {
+  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 colorVars = {
+    "--slider-track-bg": trackBackground,
+    "--slider-fill-bg": fillBackground,
+    "--slider-thumb-bg": thumbBackground,
+    "--slider-thumb-border": thumbBorderColor,
+    "--slider-mark-dot-bg": markDotColor,
+    "--slider-mark-label-color": markLabelColor,
+    "--slider-tooltip-bg": tooltipBackground,
+    "--slider-tooltip-color": tooltipColor
+  };
+  const overrideStyle = {};
+  for (const [key, value] of Object.entries(colorVars)) {
+    if (value !== void 0) {
+      overrideStyle[key] = value;
+    }
+  }
+  const mergedStyle = { ...overrideStyle, ...style };
+  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__ */ (0, import_jsx_runtime7.jsx)("div", { className: cls, style: mergedStyle, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+    "div",
+    {
+      ref: trackRef,
+      className: "fc-slider__track",
+      onClick: handleTrackClick,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          "div",
+          {
+            className: "fc-slider__fill",
+            style: isHorizontal ? { left: `${startPercent}%`, width: `${endPercent - startPercent}%` } : { bottom: `${startPercent}%`, height: `${endPercent - startPercent}%` }
+          }
+        ),
+        range && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          "div",
+          {
+            className: `fc-slider__thumb ${dragging === 0 ? "fc-slider__thumb--active" : ""}`,
+            style: thumbStyle(startPercent),
+            onMouseDown: handleMouseDown(0),
+            children: tooltip && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("span", { className: "fc-slider__tooltip", children: startVal })
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          "div",
+          {
+            className: `fc-slider__thumb ${dragging === (range ? 1 : 0) ? "fc-slider__thumb--active" : ""}`,
+            style: thumbStyle(endPercent),
+            onMouseDown: handleMouseDown(range ? 1 : 0),
+            children: tooltip && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("span", { className: "fc-slider__tooltip", children: endVal })
+          }
+        ),
+        marks && Object.entries(marks).map(([val, label]) => /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+          "div",
+          {
+            className: "fc-slider__mark",
+            style: thumbStyle(getPercent(Number(val))),
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("span", { className: "fc-slider__mark-dot" }),
+              /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("span", { className: "fc-slider__mark-label", children: label })
+            ]
+          },
+          val
+        ))
+      ]
+    }
+  ) });
+}
+
+// src/components/Select/Select.tsx
+var React6 = __toESM(require("react"), 1);
+var import_jsx_runtime8 = require("react/jsx-runtime");
+function Select({
+  options,
+  value: controlledValue,
+  defaultValue,
+  onChange,
+  placeholder = "\u8BF7\u9009\u62E9",
+  searchable = false,
+  multiple = false,
+  disabled = false,
+  className = "",
+  style,
+  virtualScroll = false,
+  virtualItemHeight = 32,
+  maxHeight = 256,
+  triggerBackground,
+  triggerBorderColor,
+  selectedColor,
+  selectedBackground,
+  hoverBackground
+}) {
+  const colorVars = {
+    "--select-trigger-bg": triggerBackground,
+    "--select-trigger-border": triggerBorderColor,
+    "--select-option-selected-color": selectedColor,
+    "--select-option-selected-bg": selectedBackground,
+    "--select-option-hover-bg": hoverBackground
+  };
+  const overrideStyle = {};
+  for (const [key, value] of Object.entries(colorVars)) {
+    if (value !== void 0) {
+      overrideStyle[key] = value;
+    }
+  }
+  const mergedStyle = { ...overrideStyle, ...style };
+  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__ */ (0, import_jsx_runtime8.jsxs)("div", { ref: containerRef, className: classNames, style: mergedStyle, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+      "div",
+      {
+        className: "fc-select__trigger",
+        onClick: () => !disabled && setIsOpen(!isOpen),
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: `fc-select__value ${(currentValue === void 0 || currentValue === null || multiple && !currentValue.length) && "fc-select__value--placeholder"}`, children: displayLabel() }),
+          /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "fc-select__arrow", children: "\u25BC" })
+        ]
+      }
+    ),
+    isOpen && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "fc-select__dropdown", children: [
+      searchable && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "fc-select__search", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+        "input",
+        {
+          type: "text",
+          value: searchValue,
+          onChange: (e) => setSearchValue(e.target.value),
+          placeholder: "\u641C\u7D22...",
+          className: "fc-select__search-input",
+          autoFocus: true
+        }
+      ) }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+        "div",
+        {
+          ref: listRef,
+          className: "fc-select__list",
+          style: { maxHeight },
+          onScroll: (e) => virtualScroll && setScrollTop(e.target.scrollTop),
+          children: [
+            virtualScroll && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { style: { height: totalHeight, position: "relative" }, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("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__ */ (0, import_jsx_runtime8.jsxs)(
+        "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__ */ (0, import_jsx_runtime8.jsx)("span", { className: `fc-select__checkbox ${selected && "fc-select__checkbox--checked"}`, children: selected && "\u2713" }),
+            /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "fc-select__option-label", children: highlightText(option.label, searchValue) }),
+            !multiple && selected && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "fc-select__check", children: "\u2713" })
+          ]
+        },
+        option.value
+      );
+    });
+  }
+  function renderGroupedOptions() {
+    return Object.entries(groupedOptions).map(([group, opts]) => /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "fc-select__group", children: [
+      group && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: "fc-select__group-label", children: group }),
+      renderOptions(opts)
+    ] }, group));
+  }
+  function highlightText(text, highlight) {
+    if (!highlight) return text;
+    const escaped = highlight.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const parts = text.split(new RegExp(`(${escaped})`, "gi"));
+    return parts.map(
+      (part, i) => part.toLowerCase() === highlight.toLowerCase() ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("mark", { className: "fc-select__highlight", children: part }, i) : part
+    );
+  }
+}
+
+// src/components/Tree/Tree.tsx
+var import_react4 = require("react");
+var import_core = require("@dnd-kit/core");
+
+// src/components/Tree/DeleteDialog.tsx
+var import_react3 = require("react");
+var import_jsx_runtime9 = require("react/jsx-runtime");
+function DeleteDialog({ node, onClose, onDelete }) {
+  const [phase, setPhase] = (0, import_react3.useState)("choose");
+  const [loading, setLoading] = (0, import_react3.useState)(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__ */ (0, import_jsx_runtime9.jsx)("div", { className: "fc-dialog-overlay", onMouseDown: handleClose, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("div", { className: "fc-dialog", onMouseDown: (e) => e.stopPropagation(), children: [
+    phase === "choose" && /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_jsx_runtime9.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("div", { className: "fc-dialog__header", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "fc-dialog__icon", children: "\u{1F5C2}" }),
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("h3", { className: "fc-dialog__title", children: [
+          "\u5220\u9664\u300C",
+          node.title,
+          "\u300D"
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("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__ */ (0, import_jsx_runtime9.jsxs)("div", { className: "fc-dialog__options", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(
+          "button",
+          {
+            className: "fc-dialog__option",
+            onClick: handleLift,
+            disabled: loading,
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "fc-dialog__option-icon", children: "\u{1F4E4}" }),
+              /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("span", { className: "fc-dialog__option-body", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "fc-dialog__option-title", children: "\u79FB\u4EA4\u7ED9\u4E0A\u7EA7\u5206\u7C7B" }),
+                /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("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__ */ (0, import_jsx_runtime9.jsxs)(
+          "button",
+          {
+            className: "fc-dialog__option fc-dialog__option--danger",
+            onClick: () => setPhase("confirm-cascade"),
+            disabled: loading,
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "fc-dialog__option-icon", children: "\u{1F5D1}" }),
+              /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("span", { className: "fc-dialog__option-body", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "fc-dialog__option-title", children: "\u5F7B\u5E95\u5220\u9664" }),
+                /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("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__ */ (0, import_jsx_runtime9.jsx)("div", { className: "fc-dialog__footer", children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("button", { className: "fc-dialog__btn", onClick: handleClose, disabled: loading, children: "\u53D6\u6D88" }) })
+    ] }),
+    phase === "confirm-cascade" && /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_jsx_runtime9.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("div", { className: "fc-dialog__header", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "fc-dialog__icon", children: "\u26A0\uFE0F" }),
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("h3", { className: "fc-dialog__title fc-dialog__title--danger", children: "\u786E\u8BA4\u5F7B\u5E95\u5220\u9664\uFF1F" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("p", { className: "fc-dialog__desc", children: [
+        "\u6B64\u64CD\u4F5C",
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("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__ */ (0, import_jsx_runtime9.jsxs)("div", { className: "fc-dialog__footer", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+          "button",
+          {
+            className: "fc-dialog__btn",
+            onClick: () => setPhase("choose"),
+            disabled: loading,
+            children: "\u8FD4\u56DE"
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+          "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
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var TreeActionsCtx = (0, import_react4.createContext)(null);
+var TreeStateCtx = (0, import_react4.createContext)(null);
+var DndStateCtx = (0, import_react4.createContext)(null);
+var CollapsePanel = (0, import_react4.memo)(function CollapsePanel2({ open, children }) {
+  const innerRef = (0, import_react4.useRef)(null);
+  const [height, setHeight] = (0, import_react4.useState)(0);
+  const [ready, setReady] = (0, import_react4.useState)(false);
+  (0, import_react4.useEffect)(() => {
+    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__ */ (0, import_jsx_runtime10.jsx)("div", { style: {
+    height: open ? height : 0,
+    overflow: "hidden",
+    transition: ready ? "height 0.12s ease-out" : "none"
+  }, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { ref: innerRef, children }) });
+});
+var DndSlot = (0, import_react4.memo)(function DndSlot2({
+  nodeKey,
+  disabled,
+  children
+}) {
+  const dndState = (0, import_react4.useContext)(DndStateCtx);
+  const isDropTarget = dndState.dropTargetKey === nodeKey;
+  const dropPosition = isDropTarget ? dndState.dropPosition : null;
+  const isDragSource = dndState.dragKey === nodeKey;
+  const { attributes, listeners, setNodeRef: setDragRef, isDragging } = (0, import_core.useDraggable)({ id: nodeKey, disabled });
+  const { setNodeRef: setDropRef } = (0, import_core.useDroppable)({ id: nodeKey, disabled });
+  const setRef = (0, import_react4.useCallback)((el) => {
+    setDragRef(el);
+    setDropRef(el);
+  }, [setDragRef, setDropRef]);
+  const handleProps = (0, import_react4.useMemo)(
+    () => ({ ...attributes, ...listeners }),
+    [attributes, listeners]
   );
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_jsx_runtime10.Fragment, { children: children({ setRef, handleProps, isDragging, isDragSource, dropPosition }) });
+});
+var TreeNodeItem = (0, import_react4.memo)(function TreeNodeItem2({ node, level, hidden = false }) {
+  const actions = (0, import_react4.useContext)(TreeActionsCtx);
+  const state = (0, import_react4.useContext)(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] = (0, import_react4.useState)("");
+  (0, import_react4.useEffect)(() => {
+    if (isEditing) setLocalEdit(node.title);
+  }, [isEditing, node.title]);
+  const handleEditKeyDown = (0, import_react4.useCallback)((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__ */ (0, import_jsx_runtime10.jsx)(DndSlot, { nodeKey: node.key, disabled: isEditing || hidden, children: ({ setRef, handleProps, isDragging, isDragSource, dropPosition }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { className: `fc-tree__node ${isDragging ? "is-dragging" : ""}`, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(
+      "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__ */ (0, import_jsx_runtime10.jsx)(
+            "span",
+            {
+              className: "fc-tree__drag-handle",
+              title: "\u62D6\u62FD\u79FB\u52A8",
+              ...handleProps,
+              onMouseDown: (e) => e.stopPropagation(),
+              children: "\u283F"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+            "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__ */ (0, import_jsx_runtime10.jsx)(
+            "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__ */ (0, import_jsx_runtime10.jsx)(
+            "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__ */ (0, import_jsx_runtime10.jsxs)("span", { className: "fc-tree__actions", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+              "button",
+              {
+                className: "fc-tree__action",
+                title: "\u65B0\u5EFA\u5B50\u5206\u7C7B",
+                onClick: (e) => {
+                  e.stopPropagation();
+                  actions.requestCreate(node.key).then();
+                },
+                children: "+"
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+              "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__ */ (0, import_jsx_runtime10.jsx)(
+              "button",
+              {
+                className: "fc-tree__action fc-tree__action--danger",
+                title: "\u5220\u9664",
+                onClick: (e) => {
+                  e.stopPropagation();
+                  actions.requestDelete(node);
+                },
+                children: "\u{1F5D1}"
+              }
+            )
+          ] })
+        ]
+      }
+    ),
+    hasChildren && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(CollapsePanel, { open: isExpanded, children: node.children.map((child) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(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] = (0, import_react4.useState)(/* @__PURE__ */ new Set());
+  const [editingKey, setEditingKey] = (0, import_react4.useState)(null);
+  const [deleteTarget, setDeleteTarget] = (0, import_react4.useState)(null);
+  const [searchValue, setSearchValue] = (0, import_react4.useState)("");
+  const [dndState, setDndState] = (0, import_react4.useState)({
+    dropTargetKey: null,
+    dropPosition: null,
+    dragKey: null
+  });
+  const dropRef = (0, import_react4.useRef)({ key: null, pos: null });
+  const pointerYRef = (0, import_react4.useRef)(0);
+  (0, import_react4.useEffect)(() => {
+    const handler = (e) => {
+      pointerYRef.current = e.clientY;
+    };
+    window.addEventListener("pointermove", handler);
+    return () => window.removeEventListener("pointermove", handler);
+  }, []);
+  const sensors = (0, import_core.useSensors)(
+    (0, import_core.useSensor)(import_core.PointerSensor, { activationConstraint: { distance: 8 } })
+  );
+  const toggleExpand = (0, import_react4.useCallback)((key) => {
+    setExpandedKeys((prev) => {
+      const next = new Set(prev);
+      next.has(key) ? next.delete(key) : next.add(key);
+      return next;
+    });
+  }, []);
+  const select = (0, import_react4.useCallback)((key) => onSelect?.(key), [onSelect]);
+  const startEdit = (0, import_react4.useCallback)((key) => setEditingKey(key), []);
+  const cancelEdit = (0, import_react4.useCallback)(() => setEditingKey(null), []);
+  const commitEdit = (0, import_react4.useCallback)(async (key, newTitle) => {
+    setEditingKey(null);
+    const trimmed = newTitle.trim();
+    if (trimmed && onRename) await onRename(key, trimmed);
+  }, [onRename]);
+  const requestCreate = (0, import_react4.useCallback)(async (parentKey) => {
+    if (!onCreate) return;
+    const newKey = await onCreate(parentKey);
+    if (parentKey) setExpandedKeys((prev) => /* @__PURE__ */ new Set([...prev, parentKey]));
+    setEditingKey(newKey);
+  }, [onCreate]);
+  const requestDelete = (0, import_react4.useCallback)((node) => {
+    setDeleteTarget(node);
+  }, []);
+  const treeDataRef = (0, import_react4.useRef)(treeData);
+  const expandedRef = (0, import_react4.useRef)(expandedKeys);
+  treeDataRef.current = treeData;
+  expandedRef.current = expandedKeys;
+  const handleDragStart = (0, import_react4.useCallback)(({ active }) => {
+    dropRef.current = { key: null, pos: null };
+    setDndState({ dropTargetKey: null, dropPosition: null, dragKey: active.id });
+  }, []);
+  const handleDragMove = (0, import_react4.useCallback)(({ 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 = (0, import_react4.useCallback)(({ 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 = (0, import_react4.useCallback)(() => {
+    dropRef.current = { key: null, pos: null };
+    setDndState({ dropTargetKey: null, dropPosition: null, dragKey: null });
+  }, []);
+  const displayData = (0, import_react4.useMemo)(() => {
+    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 = (0, import_react4.useMemo)(() => ({
+    toggleExpand,
+    select,
+    startEdit,
+    commitEdit,
+    cancelEdit,
+    requestCreate,
+    requestDelete
+  }), [toggleExpand, select, startEdit, commitEdit, cancelEdit, requestCreate, requestDelete]);
+  const stateValue = (0, import_react4.useMemo)(() => ({
+    expandedKeys,
+    selectedKey: selectedKey ?? null,
+    editingKey
+  }), [expandedKeys, selectedKey, editingKey]);
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(TreeActionsCtx.Provider, { value: actionsValue, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(TreeStateCtx.Provider, { value: stateValue, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(DndStateCtx.Provider, { value: dndState, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(
+    import_core.DndContext,
+    {
+      sensors,
+      onDragStart: handleDragStart,
+      onDragMove: handleDragMove,
+      onDragEnd: handleDragEnd,
+      onDragCancel: handleDragCancel,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { className: `fc-tree ${className}`, children: [
+          searchable && /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { className: "fc-tree__search", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+              "input",
+              {
+                type: "text",
+                value: searchValue,
+                onChange: (e) => setSearchValue(e.target.value),
+                placeholder: "\u641C\u7D22\u5206\u7C7B\u2026",
+                className: "fc-tree__search-input"
+              }
+            ),
+            searchValue && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("button", { className: "fc-tree__search-clear", onClick: () => setSearchValue(""), children: "\u2715" })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(RollingBox, { showThumb: "show", style: { height: scrollHeight }, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("div", { className: "fc-tree__list", children: [
+            displayData.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "fc-tree__empty", children: searchValue ? "\u65E0\u5339\u914D\u5206\u7C7B" : "\u6682\u65E0\u5206\u7C7B" }),
+            displayData.map((node) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(TreeNodeItem, { node, level: 0 }, node.key))
+          ] }) }),
+          onCreate && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "fc-tree__add-root", children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+            "button",
+            {
+              className: "fc-tree__add-root-btn",
+              onClick: () => requestCreate(null),
+              children: "+ \u65B0\u5EFA\u9876\u7EA7\u5206\u7C7B"
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+          DeleteDialog,
+          {
+            node: deleteTarget,
+            onClose: () => setDeleteTarget(null),
+            onDelete: async (key, mode) => {
+              await onDelete?.(key, mode);
+              setDeleteTarget(null);
+            }
+          }
+        )
+      ]
+    }
+  ) }) }) });
 }
+
+// src/components/Tree/OrphanDialog.tsx
+var import_react5 = require("react");
+var import_jsx_runtime11 = require("react/jsx-runtime");
+function OrphanDialog({ orphans, onResolve, onClose }) {
+  const [resolutions, setResolutions] = (0, import_react5.useState)(
+    () => 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__ */ (0, import_jsx_runtime11.jsx)("div", { className: "fc-dialog-overlay", children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: "fc-dialog fc-dialog--wide", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: "fc-dialog__header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", { className: "fc-dialog__icon", children: "\u{1F50D}" }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("h3", { className: "fc-dialog__title fc-dialog__title--warning", children: [
+        "\u68C0\u6D4B\u5230 ",
+        orphans.length,
+        " \u4E2A\u5B64\u7ACB\u5206\u7C7B"
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("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__ */ (0, import_jsx_runtime11.jsx)("div", { className: "fc-orphan-list", children: orphans.map((node) => /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: "fc-orphan-item", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", { className: "fc-orphan-name", title: node.key, children: node.title }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("span", { className: "fc-orphan-id", children: [
+        "id: ",
+        node.key.slice(0, 8),
+        "\u2026"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: "fc-orphan-radios", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("label", { className: `fc-orphan-radio ${resolutions[node.key] === "lift" ? "is-active" : ""}`, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+            "input",
+            {
+              type: "radio",
+              name: node.key,
+              checked: resolutions[node.key] === "lift",
+              onChange: () => set(node.key, "lift")
+            }
+          ),
+          "\u63D0\u5347\u4E3A\u6839\u5206\u7C7B"
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("label", { className: `fc-orphan-radio fc-orphan-radio--danger ${resolutions[node.key] === "remove" ? "is-active" : ""}`, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+            "input",
+            {
+              type: "radio",
+              name: node.key,
+              checked: resolutions[node.key] === "remove",
+              onChange: () => set(node.key, "remove")
+            }
+          ),
+          "\u5220\u9664"
+        ] })
+      ] })
+    ] }, node.key)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: "fc-dialog__footer", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { className: "fc-dialog__btn", onClick: onClose, children: "\u6682\u65F6\u5FFD\u7565" }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        "button",
+        {
+          className: "fc-dialog__btn fc-dialog__btn--primary",
+          onClick: () => onResolve(resolutions),
+          children: "\u786E\u8BA4\u5904\u7406"
+        }
+      )
+    ] })
+  ] }) });
+}
+
+// src/components/Avatar/Avatar.tsx
+var import_react6 = require("react");
+var import_jsx_runtime12 = require("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 = (0, import_react6.useMemo)(() => {
+    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 = (0, import_react6.useMemo)(() => ({
+    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] = (0, import_react6.useState)("idle");
+  const [currentSrc, setCurrentSrc] = (0, import_react6.useState)(src);
+  (0, import_react6.useEffect)(() => {
+    setCurrentSrc(src);
+    setLoadState(src ? "loading" : "idle");
+  }, [src]);
+  (0, import_react6.useEffect)(() => {
+    onStateChange?.(loadState);
+  }, [loadState, onStateChange]);
+  const handleLoad = (0, import_react6.useCallback)(() => {
+    setLoadState("loaded");
+    onImageLoad?.();
+  }, [onImageLoad]);
+  const handleError = (0, import_react6.useCallback)((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 = (0, import_react6.useCallback)((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__ */ (0, import_jsx_runtime12.jsx)(
+      "img",
+      {
+        src: imageSrc,
+        alt,
+        className: "ui-avatar-img",
+        loading: lazyLoad2 ? "lazy" : "eager",
+        onLoad: handleLoad,
+        onError: handleError,
+        decoding: "async"
+      }
+    );
+  }
+  if (showFallback) {
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("span", { className: "ui-avatar-text", children });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("span", { className: "ui-avatar-placeholder", children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("svg", { viewBox: "0 0 24 24", width: "40%", height: "40%", fill: "currentColor", opacity: 0.4, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("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 = (0, import_react6.forwardRef)(
+  ({
+    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__ */ (0, import_jsx_runtime12.jsx)(
+      "div",
+      {
+        ref,
+        className: classes,
+        style,
+        onClick,
+        onKeyDown: handleKeyDown,
+        ...ariaAttributes,
+        ...restProps,
+        children: content
+      }
+    );
+  }
+);
+Avatar.displayName = "Avatar";
+
+// src/components/ListGroup/ListGroup.tsx
+var import_react7 = require("react");
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var combineClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(" ");
+};
+var ListGroupItem = (0, import_react7.forwardRef)(
+  ({
+    active = false,
+    disabled = false,
+    onClick,
+    className,
+    children,
+    ...props
+  }, ref) => {
+    const handleClick = (0, import_react7.useCallback)((e) => {
+      if (disabled) return;
+      onClick?.(e);
+    }, [disabled, onClick]);
+    const classNames = (0, import_react7.useMemo)(() => {
+      return combineClassNames(
+        "fc-list-group-item",
+        active && "fc-list-group-item--active",
+        disabled && "fc-list-group-item--disabled",
+        className
+      );
+    }, [active, disabled, className]);
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+      "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 = (0, import_react7.forwardRef)(
+  ({
+    bordered = true,
+    flush = false,
+    className,
+    children,
+    ...props
+  }, ref) => {
+    const classNames = (0, import_react7.useMemo)(() => {
+      return combineClassNames(
+        "fc-list-group",
+        bordered && "fc-list-group--bordered",
+        flush && "fc-list-group--flush",
+        className
+      );
+    }, [bordered, flush, className]);
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+      "ul",
+      {
+        ref,
+        className: classNames,
+        role: "list",
+        ...props,
+        children
+      }
+    );
+  }
+);
+ListGroup.displayName = "ListGroup";
+
+// src/components/VirtualList/VirtualList.tsx
+var import_react8 = require("react");
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var VirtualItem = (0, import_react8.memo)(({ children, height }) => /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("div", { className: "fc-virtual-list__item", style: { height: `${height}px` }, children }));
+VirtualItem.displayName = "VirtualItem";
+function VirtualList({
+  data,
+  height,
+  itemHeight,
+  renderItem,
+  className = "",
+  overscan = 3,
+  showScrollbar = true,
+  onScrollEnd,
+  style
+}) {
+  const containerRef = (0, import_react8.useRef)(null);
+  const [scrollTop, setScrollTop] = (0, import_react8.useState)(0);
+  const totalHeight = data.length * itemHeight;
+  const handleScroll = (0, import_react8.useCallback)((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 = (0, import_react8.useMemo)(() => {
+    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 = (0, import_react8.useMemo)(() => {
+    return data.slice(visibleRange.startIndex, visibleRange.endIndex);
+  }, [data, visibleRange]);
+  const offsetY = visibleRange.startIndex * itemHeight;
+  const classNames = [
+    "fc-virtual-list",
+    !showScrollbar && "fc-virtual-list--hide-scrollbar",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+    "div",
+    {
+      ref: containerRef,
+      className: classNames,
+      style: { height: `${height}px`, ...style },
+      onScroll: handleScroll,
+      children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+        "div",
+        {
+          className: "fc-virtual-list__container",
+          style: { height: `${totalHeight}px` },
+          children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+            "div",
+            {
+              className: "fc-virtual-list__content",
+              style: { transform: `translateY(${offsetY}px)` },
+              children: visibleData.map((item, idx) => {
+                const actualIndex = visibleRange.startIndex + idx;
+                return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(VirtualItem, { height: itemHeight, children: renderItem(item, actualIndex) }, actualIndex);
+              })
+            }
+          )
+        }
+      )
+    }
+  );
+}
+
+// src/components/Alert/AlertContext.tsx
+var import_react9 = require("react");
+var import_jsx_runtime15 = require("react/jsx-runtime");
+var AlertContext = (0, import_react9.createContext)(null);
+var ICONS = {
+  success: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+    "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__ */ (0, import_jsx_runtime15.jsx)("circle", { cx: "12", cy: "12", r: "10" }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("polyline", { points: "17 9 11 17 6 12" })
+      ]
+    }
+  ),
+  error: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+    "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__ */ (0, import_jsx_runtime15.jsx)("circle", { cx: "12", cy: "12", r: "10" }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("line", { x1: "15", y1: "9", x2: "9", y2: "15" }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("line", { x1: "9", y1: "9", x2: "15", y2: "15" })
+      ]
+    }
+  ),
+  warning: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+    "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__ */ (0, import_jsx_runtime15.jsx)("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__ */ (0, import_jsx_runtime15.jsx)("line", { x1: "12", y1: "9", x2: "12", y2: "13" }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("line", { x1: "12", y1: "17", x2: "12.01", y2: "17" })
+      ]
+    }
+  ),
+  info: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+    "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__ */ (0, import_jsx_runtime15.jsx)("circle", { cx: "12", cy: "12", r: "10" }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("line", { x1: "12", y1: "8", x2: "12", y2: "12" }),
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("line", { x1: "12", y1: "16", x2: "12.01", y2: "16" })
+      ]
+    }
+  )
+};
+function AlertProvider({ children, background, borderColor }) {
+  const [alert, setAlert] = (0, import_react9.useState)({
+    msg: "",
+    type: "info",
+    mode: "alert",
+    visible: false,
+    choice: () => {
+    }
+  });
+  const showAlert = (msg, type, mode = "alert", duration) => new Promise((resolve) => {
+    setAlert({
+      msg,
+      type,
+      mode,
+      visible: true,
+      duration,
+      choice: (res) => {
+        setAlert((p) => ({ ...p, visible: false }));
+        resolve(res);
+      }
+    });
+  });
+  (0, import_react9.useEffect)(() => {
+    if (!alert.visible || !alert.duration) return;
+    const timer = setTimeout(() => alert.choice("auto"), alert.duration);
+    return () => clearTimeout(timer);
+  }, [alert.visible, alert.duration]);
+  const overrideStyle = {};
+  if (background !== void 0) overrideStyle["--alert-bg"] = background;
+  if (borderColor !== void 0) overrideStyle["--alert-border"] = borderColor;
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(AlertContext.Provider, { value: { showAlert }, children: [
+    children,
+    alert.visible && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", { className: "fc-alert-overlay", children: /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(
+      "div",
+      {
+        className: `fc-alert fc-alert--${alert.type} fc-alert--${alert.mode}`,
+        style: overrideStyle,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "fc-alert__header", children: [
+            ICONS[alert.type],
+            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("span", { className: "fc-alert__title", children: "\u63D0\u793A" })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(RollingBox, { className: "fc-alert__msg", children: alert.msg }),
+          alert.mode !== "toast" && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)("div", { className: "fc-alert__footer", children: [
+            alert.mode === "confirm" && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+              Button,
+              {
+                variant: "secondary",
+                size: "sm",
+                onClick: () => alert.choice("no"),
+                children: "\u53D6\u6D88"
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+              Button,
+              {
+                variant: "primary",
+                size: "sm",
+                onClick: () => alert.choice("yes"),
+                children: "\u786E\u5B9A"
+              }
+            )
+          ] })
+        ]
+      }
+    ) })
+  ] });
+}
+var useAlert = () => (0, import_react9.useContext)(AlertContext);
+
+// src/components/LazyLoad/LazyLoad.tsx
+var import_react10 = require("react");
+var import_jsx_runtime16 = require("react/jsx-runtime");
+function lazyLoad(importFn, options = {}) {
+  const { fallback = /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(LazySpinner, {}), timeout = 1e4 } = options;
+  const LazyComponent = (0, import_react10.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__ */ (0, import_jsx_runtime16.jsx)(import_react10.Suspense, { fallback, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(LazyComponent, { ...props }) });
+}
+function LazySpinner() {
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)("div", { className: "fc-lazy-spinner", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { className: "fc-lazy-spinner-dot" }),
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { className: "fc-lazy-spinner-dot" }),
+    /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("div", { className: "fc-lazy-spinner-dot" })
+  ] });
+}
+
+// src/components/Card/Card.tsx
+var import_jsx_runtime17 = require("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__ */ (0, import_jsx_runtime17.jsx)(
+        "img",
+        {
+          className: "fc-card__image",
+          src: image,
+          alt: typeof title === "string" ? title : "card image"
+        }
+      );
+    }
+    return null;
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { className: classes, style, onClick: handleClick, children: [
+    renderImage() && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+      "div",
+      {
+        className: "fc-card__image-wrapper",
+        style: { height: imageHeight },
+        children: renderImage()
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)("div", { className: "fc-card__content", children: [
+      title && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { className: "fc-card__title", children: title }),
+      description && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { className: "fc-card__description", children: description }),
+      extraInfo && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { className: "fc-card__extra-info", children: extraInfo }),
+      actions && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { className: "fc-card__actions", children: actions })
+    ] })
+  ] });
+};
+
+// src/components/Bar/TabBar.tsx
+var import_react11 = require("react");
+var import_jsx_runtime18 = require("react/jsx-runtime");
+var TabItemView = (0, import_react11.memo)(({
+  item,
+  isActive,
+  closable,
+  draggable,
+  tabClassName,
+  activeTabClassName,
+  tabStyle,
+  activeTabStyle,
+  renderCloseIcon,
+  onClick,
+  onClose,
+  onDragStart,
+  onDragOver,
+  onDrop,
+  onDragEnd
+}) => {
+  const showClose = item.closable !== void 0 ? item.closable : closable;
+  const classes = [
+    "fc-tab-bar__tab",
+    isActive && "fc-tab-bar__tab--active",
+    item.disabled && "fc-tab-bar__tab--disabled",
+    draggable && !item.disabled && "fc-tab-bar__tab--draggable",
+    tabClassName,
+    isActive && activeTabClassName
+  ].filter(Boolean).join(" ");
+  const mergedStyle = {
+    ...tabStyle,
+    ...isActive ? activeTabStyle : void 0
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(
+    "div",
+    {
+      className: classes,
+      style: mergedStyle,
+      onClick: () => !item.disabled && onClick(item.key),
+      draggable: draggable && !item.disabled,
+      onDragStart: (e) => onDragStart(e, item.key),
+      onDragOver,
+      onDrop: (e) => onDrop(e, item.key),
+      onDragEnd,
+      role: "tab",
+      "aria-selected": isActive,
+      "aria-disabled": item.disabled,
+      tabIndex: item.disabled ? -1 : 0,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("span", { className: "fc-tab-bar__tab-label", children: item.label }),
+        showClose && !item.disabled && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+          "span",
+          {
+            className: "fc-tab-bar__tab-close",
+            onClick: (e) => onClose(e, item.key),
+            role: "button",
+            "aria-label": `\u5173\u95ED ${typeof item.label === "string" ? item.label : ""}`,
+            children: renderCloseIcon ? renderCloseIcon(item.key) : "\xD7"
+          }
+        )
+      ]
+    }
+  );
+});
+TabItemView.displayName = "TabItemView";
+var TabBar = (0, import_react11.memo)(({
+  items,
+  activeKey,
+  variant = "attached",
+  radius = "md",
+  tabRadius,
+  closable = false,
+  addable = false,
+  draggable = false,
+  onChange,
+  onClose,
+  onAdd,
+  onReorder,
+  tabClassName,
+  activeTabClassName,
+  tabStyle,
+  activeTabStyle,
+  renderCloseIcon,
+  renderAddButton,
+  className = "",
+  style,
+  background,
+  tabColor,
+  tabHoverColor,
+  tabHoverBackground,
+  tabActiveColor,
+  tabActiveBackground,
+  activeIndicatorColor
+}) => {
+  const colorVars = {
+    "--tab-bar-bg": background,
+    "--tab-color": tabColor,
+    "--tab-hover-color": tabHoverColor,
+    "--tab-hover-bg": tabHoverBackground,
+    "--tab-active-color": tabActiveColor,
+    "--tab-active-bg": tabActiveBackground,
+    "--tab-active-indicator": activeIndicatorColor
+  };
+  const overrideStyle = {};
+  for (const [key, value] of Object.entries(colorVars)) {
+    if (value !== void 0) {
+      overrideStyle[key] = value;
+    }
+  }
+  const mergedStyle = { ...overrideStyle, ...style };
+  const dragKeyRef = (0, import_react11.useRef)(null);
+  const handleClick = (0, import_react11.useCallback)(
+    (key) => onChange(key),
+    [onChange]
+  );
+  const handleClose = (0, import_react11.useCallback)(
+    (e, key) => {
+      e.stopPropagation();
+      onClose?.(key);
+    },
+    [onClose]
+  );
+  const handleDragStart = (0, import_react11.useCallback)(
+    (e, key) => {
+      dragKeyRef.current = key;
+      e.dataTransfer.effectAllowed = "move";
+      const target = e.currentTarget;
+      requestAnimationFrame(() => target.classList.add("fc-tab-bar__tab--dragging"));
+    },
+    []
+  );
+  const handleDragOver = (0, import_react11.useCallback)((e) => {
+    e.preventDefault();
+    e.dataTransfer.dropEffect = "move";
+  }, []);
+  const handleDrop = (0, import_react11.useCallback)(
+    (e, targetKey) => {
+      e.preventDefault();
+      const dragKey = dragKeyRef.current;
+      if (!dragKey || dragKey === targetKey || !onReorder) return;
+      const fromIndex = items.findIndex((i) => i.key === dragKey);
+      const toIndex = items.findIndex((i) => i.key === targetKey);
+      if (fromIndex === -1 || toIndex === -1) return;
+      const reordered = [...items];
+      const [moved] = reordered.splice(fromIndex, 1);
+      reordered.splice(toIndex, 0, moved);
+      onReorder(reordered);
+    },
+    [items, onReorder]
+  );
+  const handleDragEnd = (0, import_react11.useCallback)((e) => {
+    dragKeyRef.current = null;
+    e.currentTarget.classList.remove("fc-tab-bar__tab--dragging");
+  }, []);
+  const rootClasses = [
+    "fc-tab-bar",
+    `fc-tab-bar--${variant}`,
+    `fc-tab-bar--radius-${radius}`,
+    tabRadius && `fc-tab-bar--tab-radius-${tabRadius}`,
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("div", { className: rootClasses, style: mergedStyle, role: "tablist", children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("div", { className: "fc-tab-bar__nav", children: /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)("div", { className: "fc-tab-bar__nav-wrap", children: [
+    items.map((item) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+      TabItemView,
+      {
+        item,
+        isActive: activeKey === item.key,
+        closable,
+        draggable,
+        tabClassName,
+        activeTabClassName,
+        tabStyle,
+        activeTabStyle,
+        renderCloseIcon,
+        onClick: handleClick,
+        onClose: handleClose,
+        onDragStart: handleDragStart,
+        onDragOver: handleDragOver,
+        onDrop: handleDrop,
+        onDragEnd: handleDragEnd
+      },
+      item.key
+    )),
+    addable && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
+      "div",
+      {
+        className: "fc-tab-bar__add-btn",
+        onClick: onAdd,
+        role: "button",
+        "aria-label": "\u6DFB\u52A0\u6807\u7B7E",
+        children: renderAddButton ? renderAddButton() : "+"
+      }
+    )
+  ] }) }) });
+});
+TabBar.displayName = "TabBar";
+
+// src/components/Tag/TagItem.tsx
+var import_react12 = require("react");
+var import_jsx_runtime19 = require("react/jsx-runtime");
+function TagItem({
+  schema,
+  value,
+  onChange,
+  mode = "show",
+  background,
+  color,
+  borderColor
+}) {
+  const [editing, setEditing] = (0, import_react12.useState)(false);
+  const [draft, setDraft] = (0, import_react12.useState)(() => value !== void 0 ? String(value) : "");
+  const inputRef = (0, import_react12.useRef)(null);
+  (0, import_react12.useEffect)(() => {
+    if (!editing) setDraft(value !== void 0 ? String(value) : "");
+  }, [value, editing]);
+  const colorVars = {
+    "--tag-bg": background,
+    "--tag-color": color,
+    "--tag-border": borderColor
+  };
+  const overrideStyle = {};
+  for (const [k, v] of Object.entries(colorVars)) {
+    if (v !== void 0) overrideStyle[k] = v;
+  }
+  if (schema.type === "boolean") {
+    const boolVal = value === true || value === "true";
+    return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(
+      "span",
+      {
+        className: "fc-tag-item fc-tag-item--boolean",
+        style: overrideStyle,
+        onClick: () => onChange?.(!boolVal),
+        title: "\u70B9\u51FB\u5207\u6362",
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "fc-tag-item__name", children: schema.name }),
+          /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "fc-tag-item__sep", children: "\xB7" }),
+          /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: boolVal ? "fc-tag-item__bool-true" : "fc-tag-item__bool-false", children: boolVal ? "\u2713" : "\u2717" })
+        ]
+      }
+    );
+  }
+  const commit = () => {
+    if (schema.type === "number") {
+      const n = parseFloat(draft);
+      if (!isNaN(n)) {
+        const clamped = schema.range_min != null && n < schema.range_min ? schema.range_min : schema.range_max != null && n > schema.range_max ? schema.range_max : n;
+        onChange?.(clamped);
+      }
+    } else {
+      onChange?.(draft);
+    }
+    if (mode === "show") setEditing(false);
+  };
+  const cancel = () => {
+    setDraft(value !== void 0 ? String(value) : "");
+    if (mode === "show") setEditing(false);
+  };
+  const isEditing = mode === "edit" || editing;
+  if (isEditing) {
+    return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)("span", { className: "fc-tag-item fc-tag-item--editing", style: overrideStyle, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "fc-tag-item__name", children: schema.name }),
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "fc-tag-item__sep", children: "\xB7" }),
+      /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+        "input",
+        {
+          ref: inputRef,
+          className: "fc-tag-item__input",
+          type: schema.type === "number" ? "number" : "text",
+          value: draft,
+          min: schema.range_min ?? void 0,
+          max: schema.range_max ?? void 0,
+          autoFocus: true,
+          onChange: (e) => setDraft(e.target.value),
+          onBlur: commit,
+          onKeyDown: (e) => {
+            if (e.key === "Enter") {
+              e.preventDefault();
+              commit();
+            }
+            if (e.key === "Escape") {
+              e.preventDefault();
+              cancel();
+            }
+          }
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(
+    "span",
+    {
+      className: "fc-tag-item fc-tag-item--show",
+      style: overrideStyle,
+      onDoubleClick: () => {
+        setDraft(value !== void 0 ? String(value) : "");
+        setEditing(true);
+        setTimeout(() => inputRef.current?.select(), 0);
+      },
+      title: "\u53CC\u51FB\u7F16\u8F91",
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "fc-tag-item__name", children: schema.name }),
+        value !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(import_jsx_runtime19.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "fc-tag-item__sep", children: "\xB7" }),
+          /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("span", { className: "fc-tag-item__value", children: String(value) })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/MarkdownEditor/MarkdownEditor.tsx
+var import_react_md_editor = __toESM(require("@uiw/react-md-editor"), 1);
+var import_jsx_runtime20 = require("react/jsx-runtime");
+var TOOLBAR_COMMANDS = [
+  import_react_md_editor.commands.bold,
+  import_react_md_editor.commands.italic,
+  import_react_md_editor.commands.strikethrough,
+  import_react_md_editor.commands.divider,
+  import_react_md_editor.commands.title1,
+  import_react_md_editor.commands.title2,
+  import_react_md_editor.commands.title3,
+  import_react_md_editor.commands.divider,
+  import_react_md_editor.commands.quote,
+  import_react_md_editor.commands.code,
+  import_react_md_editor.commands.codeBlock,
+  import_react_md_editor.commands.divider,
+  import_react_md_editor.commands.link,
+  import_react_md_editor.commands.unorderedListCommand,
+  import_react_md_editor.commands.orderedListCommand,
+  import_react_md_editor.commands.hr
+];
+function MarkdownEditor({
+  value,
+  onChange,
+  onAiComplete,
+  minHeight = 200,
+  placeholder = "\u5728\u6B64\u8F93\u5165\u5185\u5BB9...",
+  background,
+  toolbarBackground,
+  borderColor
+}) {
+  const { resolvedTheme } = useTheme();
+  const colorVars = {
+    "--md-bg": background,
+    "--md-toolbar-bg": toolbarBackground,
+    "--md-border": borderColor
+  };
+  const overrideStyle = {};
+  for (const [k, v] of Object.entries(colorVars)) {
+    if (v !== void 0) overrideStyle[k] = v;
+  }
+  const aiCommand = {
+    name: "ai-complete",
+    keyCommand: "ai-complete",
+    buttonProps: { "aria-label": "AI \u8865\u5168", className: "fc-md-ai-btn" },
+    icon: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)("span", { children: "AI \u8865\u5168" }),
+    execute: () => onAiComplete?.()
+  };
+  const extraCommands = onAiComplete ? [import_react_md_editor.commands.divider, aiCommand, import_react_md_editor.commands.fullscreen] : [import_react_md_editor.commands.fullscreen];
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+    "div",
+    {
+      className: "fc-md-wrap",
+      style: overrideStyle,
+      "data-color-mode": resolvedTheme,
+      children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+        import_react_md_editor.default,
+        {
+          value,
+          onChange: (v) => onChange(v ?? ""),
+          commands: TOOLBAR_COMMANDS,
+          extraCommands,
+          height: minHeight,
+          preview: "edit",
+          visibleDragbar: false,
+          textareaProps: { placeholder }
+        }
+      )
+    }
+  );
+}
+
+// src/components/ContextMenu/ContextMenuContext.tsx
+var import_react13 = require("react");
+var import_jsx_runtime21 = require("react/jsx-runtime");
+var ContextMenuContext = (0, import_react13.createContext)(null);
+function ContextMenuProvider({
+  children,
+  background,
+  borderColor,
+  hoverBackground
+}) {
+  const [menu, setMenu] = (0, import_react13.useState)({
+    visible: false,
+    x: 0,
+    y: 0,
+    items: []
+  });
+  const menuRef = (0, import_react13.useRef)(null);
+  const showContextMenu = (e, items) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setMenu({ visible: true, x: e.clientX, y: e.clientY, items });
+  };
+  const hide = () => setMenu((s) => ({ ...s, visible: false }));
+  (0, import_react13.useEffect)(() => {
+    if (!menu.visible) return;
+    const onPointerDown = (e) => {
+      if (menuRef.current && !menuRef.current.contains(e.target)) hide();
+    };
+    const onKeyDown = (e) => {
+      if (e.key === "Escape") hide();
+    };
+    window.addEventListener("pointerdown", onPointerDown);
+    window.addEventListener("keydown", onKeyDown);
+    return () => {
+      window.removeEventListener("pointerdown", onPointerDown);
+      window.removeEventListener("keydown", onKeyDown);
+    };
+  }, [menu.visible]);
+  const getPosition = () => {
+    const W = window.innerWidth;
+    const H = window.innerHeight;
+    const menuW = 180;
+    const menuH = menu.items.length * 32 + 12;
+    return {
+      left: menu.x + menuW > W ? menu.x - menuW : menu.x,
+      top: menu.y + menuH > H ? menu.y - menuH : menu.y
+    };
+  };
+  const colorVars = {
+    "--ctx-bg": background,
+    "--ctx-border": borderColor,
+    "--ctx-item-hover-bg": hoverBackground
+  };
+  const overrideStyle = { ...getPosition() };
+  for (const [k, v] of Object.entries(colorVars)) {
+    if (v !== void 0) overrideStyle[k] = v;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(ContextMenuContext.Provider, { value: { showContextMenu }, children: [
+    children,
+    menu.visible && /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
+      "ul",
+      {
+        ref: menuRef,
+        className: "fc-context-menu",
+        style: overrideStyle,
+        children: menu.items.map((item, i) => {
+          if ("type" in item && item.type === "divider") {
+            return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("li", { className: "fc-context-menu__divider" }, i);
+          }
+          const action = item;
+          return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(
+            "li",
+            {
+              className: [
+                "fc-context-menu__item",
+                action.danger ? "fc-context-menu__item--danger" : "",
+                action.disabled ? "fc-context-menu__item--disabled" : ""
+              ].filter(Boolean).join(" "),
+              onPointerDown: (e) => e.stopPropagation(),
+              onClick: () => {
+                if (action.disabled) return;
+                action.onClick();
+                hide();
+              },
+              children: [
+                action.icon && /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("span", { className: "fc-context-menu__icon", children: action.icon }),
+                /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("span", { className: "fc-context-menu__label", children: action.label })
+              ]
+            },
+            i
+          );
+        })
+      }
+    )
+  ] });
+}
+var useContextMenu = () => (0, import_react13.useContext)(ContextMenuContext);
+
+// src/components/Chat/Chat.tsx
+var import_react15 = require("react");
+
+// src/components/SmartMessage/SmartMessage.tsx
+var import_react14 = require("react");
+var import_jsx_runtime22 = require("react/jsx-runtime");
+var SmartMessage = (0, import_react14.memo)(({
+  id,
+  content,
+  role,
+  timestamp,
+  status,
+  toolName,
+  toolResult,
+  onCopy,
+  className = "",
+  style = {}
+}) => {
+  const [copied, setCopied] = (0, import_react14.useState)(false);
+  const formattedTime = timestamp ? new Date(timestamp).toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit" }) : "";
+  const handleCopy = async () => {
+    try {
+      let copyContent = content;
+      if (role === "tool" && toolResult) {
+        copyContent = `\u5DE5\u5177: ${toolName || "\u5DE5\u5177\u8C03\u7528"}
+\u7ED3\u679C: ${JSON.stringify(toolResult, null, 2)}`;
+      }
+      await navigator.clipboard.writeText(copyContent);
+      setCopied(true);
+      onCopy?.(content, role);
+      setTimeout(() => setCopied(false), 2e3);
+    } catch (err) {
+      console.error("\u590D\u5236\u5931\u8D25:", err);
+    }
+  };
+  const shouldShowCopyButton = () => {
+    return role === "user" || role === "assistant";
+  };
+  const getContainerClassName = () => {
+    const baseClass = "smart-message";
+    const roleClass = `smart-message-${role}`;
+    const statusClass = status ? `smart-message-${status}` : "";
+    return `${baseClass} ${roleClass} ${statusClass} ${className}`.trim();
+  };
+  const getContentClassName = () => {
+    const baseClass = "smart-message-content";
+    const roleContentClass = `smart-message-content-${role}`;
+    return `${baseClass} ${roleContentClass}`;
+  };
+  const renderSystemMessage = () => /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("div", { className: "system-message-wrapper", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "system-message-icon", children: /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("circle", { cx: "12", cy: "12", r: "10", stroke: "currentColor", strokeWidth: "2" }),
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("path", { d: "M12 8V12M12 16H12.01", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" })
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "system-message-text", children: content }),
+    formattedTime && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "system-message-time", children: formattedTime })
+  ] });
+  const renderToolMessage = () => /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("div", { className: "tool-message-wrapper", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("div", { className: "tool-message-header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "tool-message-icon", children: /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("path", { d: "M14.7 6.3L19 2L22 5L17.7 9.3L14.7 6.3Z", stroke: "currentColor", strokeWidth: "2" }),
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("path", { d: "M9.3 17.7L5 22L2 19L6.3 14.7L9.3 17.7Z", stroke: "currentColor", strokeWidth: "2" }),
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("path", { d: "M12 12L14.7 9.3M12 12L9.3 14.7M12 12L8 8M12 12L16 16", stroke: "currentColor", strokeWidth: "2" })
+      ] }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("span", { className: "tool-message-name", children: toolName || "\u5DE5\u5177\u8C03\u7528" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("div", { className: "tool-message-content", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("div", { className: "tool-message-params", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("strong", { children: "\u53C2\u6570:" }),
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("pre", { children: content })
+      ] }),
+      toolResult && /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("div", { className: "tool-message-result", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("strong", { children: "\u7ED3\u679C:" }),
+        /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("pre", { children: typeof toolResult === "object" ? JSON.stringify(toolResult, null, 2) : toolResult })
+      ] })
+    ] }),
+    formattedTime && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "tool-message-time", children: formattedTime })
+  ] });
+  const renderUserAssistantMessage = () => /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_jsx_runtime22.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("div", { className: "message-header", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("span", { className: "message-sender", children: role === "user" ? "\u6211" : "AI\u52A9\u624B" }),
+      formattedTime && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("span", { className: "message-time", children: formattedTime })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("div", { className: getContentClassName(), children: [
+      /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: "message-text", children: content }),
+      shouldShowCopyButton() && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+        "button",
+        {
+          className: `copy-btn ${copied ? "copied" : ""}`,
+          onClick: handleCopy,
+          title: copied ? "\u5DF2\u590D\u5236" : "\u590D\u5236\u5185\u5BB9",
+          children: copied ? /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_jsx_runtime22.Fragment, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("path", { d: "M20 6L9 17L4 12", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }) }),
+            /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("span", { children: "\u5DF2\u590D\u5236" })
+          ] }) : /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)(import_jsx_runtime22.Fragment, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime22.jsxs)("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("rect", { x: "9", y: "9", width: "13", height: "13", rx: "2", stroke: "currentColor", strokeWidth: "2" }),
+              /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("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__ */ (0, import_jsx_runtime22.jsx)("span", { children: "\u590D\u5236" })
+          ] })
+        }
+      ),
+      status === "sending" && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("span", { className: "message-status sending", children: "\u53D1\u9001\u4E2D..." }),
+      status === "error" && /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("span", { className: "message-status error", children: "\u53D1\u9001\u5931\u8D25" })
+    ] })
+  ] });
+  const renderMessage = () => {
+    switch (role) {
+      case "system":
+        return renderSystemMessage();
+      case "tool":
+        return renderToolMessage();
+      case "user":
+      case "assistant":
+      default:
+        return renderUserAssistantMessage();
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)("div", { className: getContainerClassName(), style, "data-message-id": id, children: renderMessage() });
+});
+SmartMessage.displayName = "SmartMessage";
+var SmartMessage_default = SmartMessage;
+
+// src/components/Chat/Chat.tsx
+var import_jsx_runtime23 = require("react/jsx-runtime");
+var Chat = ({
+  messages = [],
+  title = "AI \u52A9\u624B",
+  loading = false,
+  conversations = [],
+  currentConversationId,
+  emptyText = "\u6682\u65E0\u5386\u53F2\u5BF9\u8BDD",
+  newConversationText = "\u65B0\u5EFA\u5BF9\u8BDD",
+  historyTitle = "\u5386\u53F2\u5BF9\u8BDD",
+  showHistoryButton = true,
+  showMinimizeButton = true,
+  showHeader = true,
+  showFooter = false,
+  autoScroll = true,
+  onSwitchConversation,
+  onNewConversation,
+  onDeleteConversation,
+  onMinimize,
+  onRestore,
+  onMessageCopy,
+  className = "",
+  style = {},
+  headerClassName = "",
+  headerStyle = {},
+  messagesClassName = "",
+  messagesStyle = {},
+  bubbleClassName = "",
+  height = "600px",
+  width
+}) => {
+  const [showHistory, setShowHistory] = (0, import_react15.useState)(false);
+  const [isMinimized, setIsMinimized] = (0, import_react15.useState)(false);
+  const messagesContainerRef = (0, import_react15.useRef)(null);
+  const messagesEndRef = (0, import_react15.useRef)(null);
+  const historyPanelRef = (0, import_react15.useRef)(null);
+  const currentConversation = (0, import_react15.useMemo)(
+    () => conversations.find((c) => c.id === currentConversationId),
+    [conversations, currentConversationId]
+  );
+  const currentTitle = currentConversation?.title || title;
+  (0, import_react15.useEffect)(() => {
+    if (autoScroll && messagesContainerRef.current && !showHistory && !isMinimized) {
+      messagesContainerRef.current.scrollTop = messagesContainerRef.current.scrollHeight;
+    }
+  }, [messages, loading, showHistory, isMinimized, autoScroll]);
+  (0, import_react15.useEffect)(() => {
+    const handleClickOutside = (event) => {
+      if (showHistory && historyPanelRef.current && !historyPanelRef.current.contains(event.target)) {
+        setShowHistory(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, [showHistory]);
+  const handleDeleteConversation = (0, import_react15.useCallback)((conversationId) => {
+    onDeleteConversation?.(conversationId);
+  }, [onDeleteConversation]);
+  const handleMinimize = (0, import_react15.useCallback)(() => {
+    setIsMinimized(true);
+    onMinimize?.();
+  }, [onMinimize]);
+  const handleRestore = (0, import_react15.useCallback)(() => {
+    setIsMinimized(false);
+    onRestore?.();
+  }, [onRestore]);
+  const handleCopy = (0, import_react15.useCallback)((content) => {
+    const message = messages.find((m) => m.content === content);
+    if (message) {
+      onMessageCopy?.(message);
+    }
+  }, [messages, onMessageCopy]);
+  const containerStyle = (0, import_react15.useMemo)(() => ({
+    height,
+    width,
+    ...style
+  }), [height, width, style]);
+  if (isMinimized) {
+    return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: `chat-container-minimized ${className}`, style: containerStyle, children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("button", { className: "restore-btn-only", onClick: handleRestore, title: "\u5C55\u5F00", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("path", { d: "M12 5V19M5 12H19", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }) }) }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: `chat-container ${className}`, style: containerStyle, children: [
+    showHeader && /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: `chat-header ${headerClassName}`, style: headerStyle, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: "chat-title", children: currentTitle }),
+      /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: "chat-header-actions", children: [
+        showHistoryButton && /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("button", { className: "history-btn", onClick: () => setShowHistory(!showHistory), title: "\u5386\u53F2\u5BF9\u8BDD", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("path", { d: "M12 8V12L15 15", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }),
+          /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("circle", { cx: "12", cy: "12", r: "9", stroke: "currentColor", strokeWidth: "2" })
+        ] }) }),
+        showMinimizeButton && /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("button", { className: "minimize-btn", onClick: handleMinimize, title: "\u6700\u5C0F\u5316", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("path", { d: "M5 12H19", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }) }) })
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: `chat-messages ${messagesClassName}`, ref: messagesContainerRef, style: messagesStyle, children: [
+      messages.map((message) => /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+        SmartMessage_default,
+        {
+          id: message.id,
+          content: message.content,
+          role: message.type,
+          timestamp: message.timestamp,
+          status: message.status,
+          toolName: message.toolName,
+          toolResult: message.toolResult,
+          onCopy: handleCopy,
+          className: bubbleClassName
+        },
+        message.id
+      )),
+      loading && /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: "typing-wrapper", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: "typing-indicator", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("span", {}),
+        /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("span", {}),
+        /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("span", {})
+      ] }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { ref: messagesEndRef })
+    ] }),
+    showFooter && /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: "chat-footer" }),
+    showHistory && /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: "history-panel", ref: historyPanelRef, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: "history-header", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("h3", { children: historyTitle }),
+        /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("button", { className: "close-history-btn", onClick: () => setShowHistory(false), children: "\u2715" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: "history-list", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("button", { className: "new-conversation-btn-large", onClick: () => {
+          onNewConversation?.();
+          setShowHistory(false);
+        }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("path", { d: "M12 5V19M5 12H19", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("span", { children: newConversationText })
+        ] }),
+        conversations.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: "empty-history", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("p", { children: emptyText }) }) : conversations.map((conv) => /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(
+          "div",
+          {
+            className: `history-item ${currentConversationId === conv.id ? "active" : ""}`,
+            onClick: () => {
+              onSwitchConversation?.(conv.id);
+              setShowHistory(false);
+            },
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: "history-item-content", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: "history-item-title", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("span", { children: conv.title }) }),
+                /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: "history-item-preview", children: conv.lastMessage }),
+                /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("div", { className: "history-item-meta", children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("span", { children: new Date(conv.timestamp).toLocaleDateString() }),
+                  /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("span", { children: [
+                    conv.messages.length,
+                    "\u6761\u6D88\u606F"
+                  ] })
+                ] })
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("div", { className: "history-item-actions", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+                "button",
+                {
+                  className: "delete-conversation-btn",
+                  onClick: (e) => {
+                    e.stopPropagation();
+                    handleDeleteConversation(conv.id);
+                  },
+                  title: "\u5220\u9664\u5BF9\u8BDD",
+                  children: /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("path", { d: "M3 6H21", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }),
+                    /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("path", { d: "M19 6V20C19 21.1 18.1 22 17 22H7C5.9 22 5 21.1 5 20V6", stroke: "currentColor", strokeWidth: "2" }),
+                    /* @__PURE__ */ (0, import_jsx_runtime23.jsx)("path", { d: "M8 6V4C8 2.9 8.9 2 10 2H14C15.1 2 16 2.9 16 4V6", stroke: "currentColor", strokeWidth: "2" })
+                  ] })
+                }
+              ) })
+            ]
+          },
+          conv.id
+        ))
+      ] })
+    ] })
+  ] });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Button
+  AlertProvider,
+  Avatar,
+  Button,
+  ButtonGroup,
+  ButtonToolbar,
+  Card,
+  Chat,
+  CheckButton,
+  ContextMenuProvider,
+  DeleteDialog,
+  Input,
+  ListGroup,
+  ListGroupItem,
+  MarkdownEditor,
+  OrphanDialog,
+  RollingBox,
+  Select,
+  SideBar,
+  Slider,
+  SmartMessage,
+  TabBar,
+  TagItem,
+  ThemeProvider,
+  Tree,
+  VirtualList,
+  findNodeInfo,
+  flatToTree,
+  isDescendantOf,
+  lazyLoad,
+  useAlert,
+  useContextMenu,
+  useTheme
 });