@4399ywkf/design 2.0.0 → 2.1.1

package/dist/AiConversation/_lobe/base-ui/DropdownMenu/type.d.ts

@@ -0,0 +1,39 @@
+import type { MenuPopupProps, MenuPortalProps, MenuPositionerProps, MenuRootProps, MenuTriggerProps } from '@base-ui/react/menu';
+import type { ReactNode } from 'react';
+import type { BaseMenuItemType, IconAlign, MenuCheckboxItemType, MenuSwitchItemType } from '../../Menu';
+import type { Trigger } from '../../types';
+import type { Placement } from '../../utils/placement';
+import type { IconSpaceMode } from './renderItems';
+export type DropdownMenuPlacement = Placement;
+export type DropdownMenuCheckboxItem = MenuCheckboxItemType;
+export type DropdownMenuSwitchItem = MenuSwitchItemType;
+export type DropdownItem = BaseMenuItemType;
+export interface DropdownMenuProps<Payload = unknown> extends Omit<MenuRootProps<Payload>, 'children'> {
+    children: ReactNode;
+    /**
+     * 图标与 label+desc 的垂直对齐方式
+     * - 'center': 图标垂直居中（默认）
+     * - 'start': 图标与第一行文本顶部对齐，仅在 item 有 desc 时生效
+     * @default 'center'
+     */
+    iconAlign?: IconAlign;
+    /**
+     * 图标空间保留模式
+     * - 'global': 当任何一个选项有图标时，所有 item 都保留图标位
+     * - 'group': 只有当一个分组中存在图标时，该分组才保留图标位
+     * @default 'global'
+     */
+    iconSpaceMode?: IconSpaceMode;
+    items: DropdownItem[] | (() => DropdownItem[]);
+    nativeButton?: boolean;
+    placement?: DropdownMenuPlacement;
+    popupProps?: MenuPopupProps;
+    portalProps?: MenuPortalProps;
+    positionerProps?: MenuPositionerProps;
+    /**
+     * 触发方式
+     * @default 'click'
+     */
+    trigger?: Trigger;
+    triggerProps?: Omit<MenuTriggerProps<Payload>, 'children'>;
+}

package/dist/AiConversation/_lobe/base-ui/DropdownMenu/type.js

@@ -0,0 +1 @@
+export {};

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/FloatingSheet.d.ts

@@ -0,0 +1,2 @@
+import type { FloatingSheetProps } from './type';
+export declare function FloatingSheet({ open: openProp, onOpenChange, defaultOpen, snapPoints: snapPointsProp, activeSnapPoint: activeSnapPointProp, onSnapPointChange, minHeight: minHeightProp, maxHeight: maxHeightProp, restingHeight: restingHeightProp, mode, variant, width, title, headerActions, dismissible, closeThreshold, children, className, }: FloatingSheetProps): import("react/jsx-runtime").JSX.Element;

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/FloatingSheet.js

@@ -0,0 +1,291 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { cx } from 'antd-style';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { FloatingSheetHeader } from "./FloatingSheetHeader";
+import { clamp, dampenValue, resolveSize } from "./helpers";
+import { styles } from "./style";
+import { useSheetDrag } from "./useSheetDrag";
+import { useSnapPoints } from "./useSnapPoints";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var ANIMATION_MS = 300;
+export function FloatingSheet(_ref) {
+  var openProp = _ref.open,
+    onOpenChange = _ref.onOpenChange,
+    _ref$defaultOpen = _ref.defaultOpen,
+    defaultOpen = _ref$defaultOpen === void 0 ? false : _ref$defaultOpen,
+    snapPointsProp = _ref.snapPoints,
+    activeSnapPointProp = _ref.activeSnapPoint,
+    onSnapPointChange = _ref.onSnapPointChange,
+    _ref$minHeight = _ref.minHeight,
+    minHeightProp = _ref$minHeight === void 0 ? 200 : _ref$minHeight,
+    _ref$maxHeight = _ref.maxHeight,
+    maxHeightProp = _ref$maxHeight === void 0 ? 0.8 : _ref$maxHeight,
+    restingHeightProp = _ref.restingHeight,
+    _ref$mode = _ref.mode,
+    mode = _ref$mode === void 0 ? 'overlay' : _ref$mode,
+    _ref$variant = _ref.variant,
+    variant = _ref$variant === void 0 ? 'elevated' : _ref$variant,
+    _ref$width = _ref.width,
+    width = _ref$width === void 0 ? '100%' : _ref$width,
+    title = _ref.title,
+    headerActions = _ref.headerActions,
+    _ref$dismissible = _ref.dismissible,
+    dismissible = _ref$dismissible === void 0 ? true : _ref$dismissible,
+    _ref$closeThreshold = _ref.closeThreshold,
+    closeThreshold = _ref$closeThreshold === void 0 ? 0.25 : _ref$closeThreshold,
+    children = _ref.children,
+    className = _ref.className;
+  var s = styles;
+
+  // Controlled / uncontrolled open state
+  var isControlled = openProp !== undefined;
+  var _useState = useState(defaultOpen),
+    _useState2 = _slicedToArray(_useState, 2),
+    internalOpen = _useState2[0],
+    setInternalOpen = _useState2[1];
+  var isOpen = isControlled ? openProp : internalOpen;
+  var setOpen = useCallback(function (value) {
+    if (!isControlled) setInternalOpen(value);
+    onOpenChange === null || onOpenChange === void 0 || onOpenChange(value);
+  }, [isControlled, onOpenChange]);
+
+  // Container measurement via ResizeObserver
+  var containerRef = useRef(null);
+  var sheetRef = useRef(null);
+  var _useState3 = useState(0),
+    _useState4 = _slicedToArray(_useState3, 2),
+    containerHeight = _useState4[0],
+    setContainerHeight = _useState4[1];
+  useEffect(function () {
+    var _sheetRef$current;
+    var parent = (_sheetRef$current = sheetRef.current) === null || _sheetRef$current === void 0 ? void 0 : _sheetRef$current.parentElement;
+    if (!parent) return;
+    containerRef.current = parent;
+    var observer = new ResizeObserver(function (entries) {
+      var _iterator = _createForOfIteratorHelper(entries),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var entry = _step.value;
+          setContainerHeight(entry.contentRect.height);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    });
+    observer.observe(parent);
+    setContainerHeight(parent.getBoundingClientRect().height);
+    return function () {
+      return observer.disconnect();
+    };
+  }, []);
+
+  // Resolve min/max to px
+  var minHeightPx = useMemo(function () {
+    return resolveSize(minHeightProp, containerHeight);
+  }, [minHeightProp, containerHeight]);
+  var maxHeightPx = useMemo(function () {
+    return resolveSize(maxHeightProp, containerHeight);
+  }, [maxHeightProp, containerHeight]);
+  var restingHeightPx = useMemo(function () {
+    return restingHeightProp !== undefined ? clamp(resolveSize(restingHeightProp, containerHeight), minHeightPx, maxHeightPx) : minHeightPx;
+  }, [restingHeightProp, containerHeight, minHeightPx, maxHeightPx]);
+
+  // Snap points
+  var hasSnapPoints = !!snapPointsProp && snapPointsProp.length > 0;
+  var _useSnapPoints = useSnapPoints({
+      closeThreshold: closeThreshold,
+      containerHeight: containerHeight,
+      containerRef: containerRef,
+      maxHeightPx: maxHeightPx,
+      minHeightPx: minHeightPx,
+      snapPoints: snapPointsProp !== null && snapPointsProp !== void 0 ? snapPointsProp : []
+    }),
+    snapPointHeights = _useSnapPoints.snapPointHeights,
+    findActiveIndex = _useSnapPoints.findActiveIndex,
+    getSnapRelease = _useSnapPoints.getSnapRelease;
+
+  // Compute the "resting" height for the current open + snap state
+  var restingHeight = useMemo(function () {
+    if (!containerHeight) return 0;
+    if (hasSnapPoints && activeSnapPointProp !== undefined) {
+      var resolved = resolveSize(activeSnapPointProp, containerHeight);
+      return clamp(resolved, minHeightPx, maxHeightPx);
+    }
+    if (hasSnapPoints && snapPointHeights.length > 0) {
+      return snapPointHeights[0];
+    }
+    return restingHeightPx;
+  }, [containerHeight, hasSnapPoints, activeSnapPointProp, snapPointHeights, minHeightPx, maxHeightPx, restingHeightPx]);
+  var _useState5 = useState(isOpen ? restingHeight : 0),
+    _useState6 = _slicedToArray(_useState5, 2),
+    height = _useState6[0],
+    setHeight = _useState6[1];
+  var _useState7 = useState(false),
+    _useState8 = _slicedToArray(_useState7, 2),
+    isAnimating = _useState8[0],
+    setIsAnimating = _useState8[1];
+  // Keeps sheet visible during close animation (height → 0)
+  var _useState9 = useState(false),
+    _useState10 = _slicedToArray(_useState9, 2),
+    isClosing = _useState10[0],
+    setIsClosing = _useState10[1];
+  var heightBeforeDrag = useRef(0);
+  var prevOpenRef = useRef(isOpen);
+
+  // Handle open/close transitions
+  useEffect(function () {
+    var wasOpen = prevOpenRef.current;
+    prevOpenRef.current = isOpen;
+    if (isOpen && !wasOpen) {
+      // Opening: animate from 0 → resting height
+      setIsClosing(false);
+      setIsAnimating(true);
+      setHeight(restingHeight);
+      var timer = setTimeout(function () {
+        return setIsAnimating(false);
+      }, ANIMATION_MS);
+      return function () {
+        return clearTimeout(timer);
+      };
+    }
+    if (!isOpen && wasOpen) {
+      // Closing: animate from current height → 0, then hide
+      setIsClosing(true);
+      setIsAnimating(true);
+      setHeight(0);
+      var _timer = setTimeout(function () {
+        setIsAnimating(false);
+        setIsClosing(false);
+      }, ANIMATION_MS);
+      return function () {
+        return clearTimeout(_timer);
+      };
+    }
+  }, [isOpen]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  // Sync height when resting height changes (container resize, snap point change)
+  useEffect(function () {
+    if (isOpen && !isDragging) {
+      setHeight(restingHeight);
+    }
+  }, [restingHeight]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  // Drag handlers
+  var onDragChange = useCallback(function (draggedDistance) {
+    var newHeight = heightBeforeDrag.current + draggedDistance;
+    if (hasSnapPoints) {
+      var _snapPointHeights$at, _snapPointHeights$;
+      var highest = (_snapPointHeights$at = snapPointHeights.at(-1)) !== null && _snapPointHeights$at !== void 0 ? _snapPointHeights$at : maxHeightPx;
+      var lowest = (_snapPointHeights$ = snapPointHeights[0]) !== null && _snapPointHeights$ !== void 0 ? _snapPointHeights$ : minHeightPx;
+      if (newHeight > highest) {
+        var overshoot = newHeight - highest;
+        setHeight(highest + dampenValue(overshoot));
+      } else if (newHeight < lowest) {
+        var undershoot = lowest - newHeight;
+        setHeight(Math.max(0, lowest - dampenValue(undershoot)));
+      } else {
+        setHeight(newHeight);
+      }
+    } else {
+      setHeight(clamp(newHeight, 0, maxHeightPx));
+    }
+  }, [hasSnapPoints, snapPointHeights, maxHeightPx, minHeightPx]);
+  var onDragEnd = useCallback(function (draggedDistance, velocity) {
+    setIsAnimating(true);
+    var currentHeight = heightBeforeDrag.current + draggedDistance;
+    if (hasSnapPoints) {
+      var activeIndex = findActiveIndex(heightBeforeDrag.current);
+      var result = getSnapRelease({
+        activeIndex: activeIndex,
+        currentHeight: currentHeight,
+        dismissible: dismissible,
+        draggedDistance: draggedDistance,
+        velocity: velocity
+      });
+      if (result.type === 'dismiss') {
+        setIsClosing(true);
+        setHeight(0);
+        var timer = setTimeout(function () {
+          setOpen(false);
+          setIsAnimating(false);
+          setIsClosing(false);
+        }, ANIMATION_MS);
+        return function () {
+          return clearTimeout(timer);
+        };
+      }
+      setHeight(result.height);
+      var originalSnapValue = snapPointsProp === null || snapPointsProp === void 0 ? void 0 : snapPointsProp.find(function (sp) {
+        return resolveSize(sp, containerHeight) === result.height || clamp(resolveSize(sp, containerHeight), minHeightPx, maxHeightPx) === result.height;
+      });
+      if (originalSnapValue !== undefined) {
+        onSnapPointChange === null || onSnapPointChange === void 0 || onSnapPointChange(originalSnapValue);
+      }
+    } else {
+      if (dismissible && currentHeight < minHeightPx * closeThreshold) {
+        setIsClosing(true);
+        setHeight(0);
+        var _timer2 = setTimeout(function () {
+          setOpen(false);
+          setIsAnimating(false);
+          setIsClosing(false);
+        }, ANIMATION_MS);
+        return function () {
+          return clearTimeout(_timer2);
+        };
+      }
+      setHeight(clamp(currentHeight, minHeightPx, maxHeightPx));
+    }
+    setTimeout(function () {
+      return setIsAnimating(false);
+    }, ANIMATION_MS);
+  }, [hasSnapPoints, findActiveIndex, getSnapRelease, dismissible, snapPointsProp, containerHeight, minHeightPx, maxHeightPx, closeThreshold, setOpen, onSnapPointChange]);
+  var _useSheetDrag = useSheetDrag({
+      enabled: isOpen !== null && isOpen !== void 0 ? isOpen : false,
+      onDragChange: onDragChange,
+      onDragEnd: onDragEnd
+    }),
+    isDragging = _useSheetDrag.isDragging,
+    handleProps = _useSheetDrag.handleProps;
+
+  // Record height at drag start
+  useEffect(function () {
+    if (isDragging) {
+      heightBeforeDrag.current = height;
+    }
+  }, [isDragging]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  var isVisible = isOpen || isClosing || height > 0;
+  var shouldAnimate = !isDragging && isAnimating;
+  var inlineOverflowUp = mode === 'inline' && isVisible ? Math.max(0, height - restingHeightPx) : 0;
+  return /*#__PURE__*/_jsxs("div", {
+    "data-floating-sheet": "",
+    "data-state": isOpen ? 'open' : 'closed',
+    ref: sheetRef,
+    className: cx(s.root, variant === 'embedded' ? s.embedded : s.elevated, mode === 'overlay' ? s.overlay : s.inline, mode === 'overlay' ? s.overlayRadius : s.inlineRadius, shouldAnimate && s.transition, !isVisible && s.hidden, className),
+    style: {
+      height: isVisible ? height : 0,
+      marginTop: inlineOverflowUp ? -inlineOverflowUp : undefined,
+      width: width
+    },
+    children: [/*#__PURE__*/_jsx(FloatingSheetHeader, {
+      handleProps: handleProps,
+      headerActions: headerActions,
+      isDragging: isDragging,
+      title: title
+    }), /*#__PURE__*/_jsx("div", {
+      className: s.content,
+      children: children
+    })]
+  });
+}

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/FloatingSheetHeader.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+interface FloatingSheetHeaderProps {
+    handleProps: {
+        onMouseDown: (e: React.MouseEvent<HTMLDivElement>) => void;
+    };
+    headerActions?: ReactNode;
+    isDragging: boolean;
+    title?: ReactNode;
+}
+export declare function FloatingSheetHeader({ title, headerActions, isDragging, handleProps, }: FloatingSheetHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/FloatingSheetHeader.js

@@ -0,0 +1,34 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { cx } from 'antd-style';
+import { styles } from "./style";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export function FloatingSheetHeader(_ref) {
+  var title = _ref.title,
+    headerActions = _ref.headerActions,
+    isDragging = _ref.isDragging,
+    handleProps = _ref.handleProps;
+  var s = styles;
+  return /*#__PURE__*/_jsxs("div", _objectSpread(_objectSpread({
+    className: cx(s.header, isDragging && s.headerDragging)
+  }, handleProps), {}, {
+    children: [/*#__PURE__*/_jsx("div", {
+      className: s.handle
+    }), /*#__PURE__*/_jsxs("div", {
+      className: s.headerContent,
+      children: [title && /*#__PURE__*/_jsx("div", {
+        className: s.headerTitle,
+        children: title
+      }), headerActions && /*#__PURE__*/_jsx("div", {
+        className: s.headerActions,
+        "data-no-drag": "",
+        children: headerActions
+      })]
+    })]
+  }));
+}

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/helpers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Clamp a value between min and max.
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+/**
+ * Rubber-band damping for drag resistance beyond snap bounds.
+ * Returns 0 when v <= 0, near 1:1 for small v, then grows logarithmically.
+ */
+export declare function dampenValue(v: number): number;
+/**
+ * Resolve a size value to pixels.
+ * 0 < v <= 1 → fraction of containerHeight.
+ * v > 1 → pixel value.
+ * v === 0 → 0.
+ */
+export declare function resolveSize(value: number, containerHeight: number): number;

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/helpers.js

@@ -0,0 +1,27 @@
+/**
+ * Clamp a value between min and max.
+ */
+export function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+/**
+ * Rubber-band damping for drag resistance beyond snap bounds.
+ * Returns 0 when v <= 0, near 1:1 for small v, then grows logarithmically.
+ */
+export function dampenValue(v) {
+  if (v <= 0) return 0;
+  return 8 * Math.log1p(v / 8);
+}
+
+/**
+ * Resolve a size value to pixels.
+ * 0 < v <= 1 → fraction of containerHeight.
+ * v > 1 → pixel value.
+ * v === 0 → 0.
+ */
+export function resolveSize(value, containerHeight) {
+  if (value === 0) return 0;
+  if (value > 0 && value <= 1) return value * containerHeight;
+  return value;
+}

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/index.d.ts

@@ -0,0 +1,2 @@
+export { FloatingSheet } from './FloatingSheet';
+export type { FloatingSheetProps } from './type';

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/index.js

@@ -0,0 +1 @@
+export { FloatingSheet } from "./FloatingSheet";

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/style.d.ts

@@ -0,0 +1,18 @@
+export declare const styles: {
+    root: string;
+    overlayRadius: string;
+    inlineRadius: string;
+    elevated: string;
+    embedded: string;
+    overlay: string;
+    inline: string;
+    transition: string;
+    hidden: string;
+    header: string;
+    headerDragging: string;
+    handle: string;
+    headerContent: string;
+    headerTitle: string;
+    headerActions: string;
+    content: string;
+};

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/style.js

@@ -0,0 +1,27 @@
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14, _templateObject15, _templateObject16;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import { createStaticStyles } from 'antd-style';
+var transitionDuration = '0.3s';
+var transitionEasing = 'cubic-bezier(0.32, 0.72, 0, 1)';
+export var styles = createStaticStyles(function (_ref) {
+  var css = _ref.css,
+    cssVar = _ref.cssVar;
+  return {
+    root: css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    overflow: hidden;\n    display: flex;\n    flex-direction: column;\n    background: ", ";\n  "])), cssVar.colorBgContainer),
+    overlayRadius: css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n    border-radius: 12px 12px 0 0;\n  "]))),
+    inlineRadius: css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n    border-radius: 12px;\n  "]))),
+    elevated: css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n    box-shadow: ", ";\n  "])), cssVar.boxShadowSecondary),
+    embedded: css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n    border: 1px solid ", ";\n    box-shadow: none;\n  "])), cssVar.colorBorderSecondary),
+    overlay: css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n    position: absolute;\n    z-index: 10;\n    inset-block-end: 0;\n    inset-inline: 0;\n  "]))),
+    inline: css(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n    position: relative;\n    z-index: 1;\n    flex-shrink: 0;\n  "]))),
+    transition: css(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n    transition:\n      height ", " ", ",\n      margin-block-start ", " ", ";\n  "])), transitionDuration, transitionEasing, transitionDuration, transitionEasing),
+    hidden: css(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["\n    visibility: hidden;\n  "]))),
+    header: css(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["\n    cursor: grab;\n    user-select: none;\n\n    display: flex;\n    flex-direction: column;\n    flex-shrink: 0;\n    align-items: center;\n\n    padding-block: 8px 4px;\n    padding-inline: 16px;\n  "]))),
+    headerDragging: css(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["\n    cursor: grabbing;\n  "]))),
+    handle: css(_templateObject12 || (_templateObject12 = _taggedTemplateLiteral(["\n    width: 32px;\n    height: 4px;\n    margin-block-end: 8px;\n    border-radius: 2px;\n\n    background: ", ";\n  "])), cssVar.colorBorderSecondary),
+    headerContent: css(_templateObject13 || (_templateObject13 = _taggedTemplateLiteral(["\n    display: flex;\n    align-items: center;\n    justify-content: space-between;\n\n    width: 100%;\n    min-height: 24px;\n  "]))),
+    headerTitle: css(_templateObject14 || (_templateObject14 = _taggedTemplateLiteral(["\n    flex: 1;\n    min-width: 0;\n  "]))),
+    headerActions: css(_templateObject15 || (_templateObject15 = _taggedTemplateLiteral(["\n    display: flex;\n    flex-shrink: 0;\n    gap: 4px;\n    align-items: center;\n  "]))),
+    content: css(_templateObject16 || (_templateObject16 = _taggedTemplateLiteral(["\n    overflow: auto;\n    flex: 1;\n    min-height: 0;\n  "])))
+  };
+});

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/type.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from 'react';
+export interface FloatingSheetProps {
+    activeSnapPoint?: number;
+    children?: ReactNode;
+    className?: string;
+    closeThreshold?: number;
+    defaultOpen?: boolean;
+    dismissible?: boolean;
+    headerActions?: ReactNode;
+    maxHeight?: number;
+    minHeight?: number;
+    mode?: 'overlay' | 'inline';
+    onOpenChange?: (open: boolean) => void;
+    onSnapPointChange?: (snapPoint: number) => void;
+    open?: boolean;
+    restingHeight?: number;
+    snapPoints?: number[];
+    title?: ReactNode;
+    variant?: 'elevated' | 'embedded';
+    width?: number | string;
+}

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/type.js

@@ -0,0 +1 @@
+export {};

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/useSheetDrag.d.ts

@@ -0,0 +1,12 @@
+interface UseSheetDragOptions {
+    enabled: boolean;
+    onDragChange: (draggedDistance: number) => void;
+    onDragEnd: (draggedDistance: number, velocity: number) => void;
+}
+export declare function useSheetDrag({ onDragChange, onDragEnd, enabled }: UseSheetDragOptions): {
+    isDragging: boolean;
+    handleProps: {
+        onMouseDown: (event: React.MouseEvent<HTMLDivElement>) => void;
+    };
+};
+export {};

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/useSheetDrag.js

@@ -0,0 +1,67 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useCallback, useEffect, useRef, useState } from 'react';
+export function useSheetDrag(_ref) {
+  var onDragChange = _ref.onDragChange,
+    onDragEnd = _ref.onDragEnd,
+    enabled = _ref.enabled;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isDragging = _useState2[0],
+    setIsDragging = _useState2[1];
+  var startY = useRef(0);
+  var startTime = useRef(0);
+  var draggingRef = useRef(false);
+
+  // Store latest callbacks in refs to avoid stale closures in document listeners
+  var onDragChangeRef = useRef(onDragChange);
+  var onDragEndRef = useRef(onDragEnd);
+  onDragChangeRef.current = onDragChange;
+  onDragEndRef.current = onDragEnd;
+  useEffect(function () {
+    if (!draggingRef.current) return;
+    var onMouseMove = function onMouseMove(e) {
+      e.preventDefault();
+      var draggedDistance = startY.current - e.clientY;
+      onDragChangeRef.current(draggedDistance);
+    };
+    var onMouseUp = function onMouseUp(e) {
+      draggingRef.current = false;
+      setIsDragging(false);
+      var draggedDistance = startY.current - e.clientY;
+      var elapsed = Date.now() - startTime.current;
+      var velocity = elapsed > 0 ? Math.abs(draggedDistance) / elapsed : 0;
+      onDragEndRef.current(draggedDistance, velocity);
+    };
+    document.addEventListener('mousemove', onMouseMove);
+    document.addEventListener('mouseup', onMouseUp);
+    return function () {
+      document.removeEventListener('mousemove', onMouseMove);
+      document.removeEventListener('mouseup', onMouseUp);
+    };
+  }, [isDragging]);
+  var onMouseDown = useCallback(function (event) {
+    var _target$closest;
+    if (!enabled) return;
+    if (event.button !== 0) return; // left click only
+
+    var target = event.target;
+    if ((_target$closest = target.closest) !== null && _target$closest !== void 0 && _target$closest.call(target, '[data-no-drag]')) return;
+    event.preventDefault(); // prevent text selection during drag
+
+    startY.current = event.clientY;
+    startTime.current = Date.now();
+    draggingRef.current = true;
+    setIsDragging(true);
+  }, [enabled]);
+  return {
+    isDragging: isDragging,
+    handleProps: {
+      onMouseDown: onMouseDown
+    }
+  };
+}

package/dist/AiConversation/_lobe/base-ui/FloatingSheet/useSnapPoints.d.ts

@@ -0,0 +1,29 @@
+import { type RefObject } from 'react';
+interface UseSnapPointsOptions {
+    closeThreshold: number;
+    containerHeight: number;
+    containerRef: RefObject<HTMLElement | null>;
+    maxHeightPx: number;
+    minHeightPx: number;
+    snapPoints: number[];
+}
+interface SnapReleaseParams {
+    activeIndex: number;
+    currentHeight: number;
+    dismissible: boolean;
+    draggedDistance: number;
+    velocity: number;
+}
+type SnapReleaseResult = {
+    type: 'snap';
+    height: number;
+} | {
+    type: 'dismiss';
+};
+export declare function useSnapPoints({ closeThreshold, snapPoints, containerHeight, minHeightPx, maxHeightPx, }: UseSnapPointsOptions): {
+    snapPointHeights: number[];
+    findClosestSnapPoint: (height: number) => number;
+    findActiveIndex: (height: number) => number;
+    getSnapRelease: ({ currentHeight, activeIndex, draggedDistance, velocity, dismissible, }: SnapReleaseParams) => SnapReleaseResult;
+};
+export {};