@4399ywkf/design 2.1.0 → 2.1.1

package/dist/AiConversation/_lobe/Mermaid/SyntaxMermaid/style.js

@@ -0,0 +1,45 @@
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import { createStaticStyles, cx, keyframes } from 'antd-style';
+import { cva } from 'class-variance-authority';
+var fadeIn = keyframes(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  0% {\n    opacity: 0;\n  }\n  100% {\n    opacity: 1;\n  }\n"])));
+export var styles = createStaticStyles(function (_ref) {
+  var css = _ref.css,
+    cssVar = _ref.cssVar;
+  return {
+    animated: css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n      img {\n        opacity: 1;\n        animation: ", " 0.5s ease-in-out;\n      }\n    "])), fadeIn),
+    mermaid: cx('ant-mermaid-mermaid', css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n        img {\n          display: block;\n          width: 100%;\n          height: auto;\n        }\n      "])))),
+    noBackground: css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n      img {\n        background: transparent !important;\n      }\n    "]))),
+    noPadding: css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n      padding: 0;\n    "]))),
+    padding: css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n      padding: 16px;\n    "]))),
+    root: css(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n      direction: ltr;\n      margin: 0;\n      padding: 0;\n      text-align: start;\n    "]))),
+    unmermaid: css(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n      color: ", ";\n    "])), cssVar.colorTextDescription)
+  };
+});
+export var variants = cva(styles.root, {
+  defaultVariants: {
+    animated: false,
+    mermaid: true,
+    showBackground: false,
+    variant: 'borderless'
+  },
+  variants: {
+    mermaid: {
+      false: styles.unmermaid,
+      true: styles.mermaid
+    },
+    showBackground: {
+      false: styles.noBackground,
+      true: null
+    },
+    animated: {
+      true: styles.animated,
+      false: null
+    },
+    variant: {
+      filled: styles.padding,
+      outlined: styles.padding,
+      borderless: styles.noPadding
+    }
+  }
+});

package/dist/AiConversation/_lobe/Mermaid/const.d.ts

@@ -0,0 +1,7 @@
+interface MermaidThemeItem {
+    background?: string;
+    displayName: string;
+    id: string;
+}
+export declare const mermaidThemes: MermaidThemeItem[];
+export {};

package/dist/AiConversation/_lobe/Mermaid/const.js

@@ -0,0 +1,24 @@
+export var mermaidThemes = [{
+  displayName: 'Lobe Theme',
+  id: 'lobe-theme'
+}, {
+  background: '#fbf9ff',
+  displayName: 'Mermaid Default',
+  id: 'default'
+}, {
+  background: '#fffcf8',
+  displayName: 'Mermaid Base',
+  id: 'base'
+}, {
+  background: '#000',
+  displayName: 'Mermaid Dark',
+  id: 'dark'
+}, {
+  background: '#f9ffeb',
+  displayName: 'Mermaid Forest',
+  id: 'forest'
+}, {
+  background: '#fff',
+  displayName: 'Mermaid Neutral',
+  id: 'neutral'
+}];

package/dist/AiConversation/_lobe/Mermaid/index.d.ts

@@ -0,0 +1,4 @@
+export { mermaidThemes } from './const';
+export { default } from './Mermaid';
+export { default as SyntaxMermaid } from './SyntaxMermaid';
+export type * from './type';

package/dist/AiConversation/_lobe/Mermaid/index.js

@@ -0,0 +1,3 @@
+export { mermaidThemes } from "./const";
+export { default } from "./Mermaid";
+export { default as SyntaxMermaid } from "./SyntaxMermaid";

package/dist/AiConversation/_lobe/Mermaid/postProcessMermaidSvg.d.ts

@@ -0,0 +1,12 @@
+interface MermaidVisualTokens {
+    borderRadius: number;
+    labelBackground: string;
+    labelBorder: string;
+    labelPillRadius: number;
+    labelText: string;
+    noteBackground: string;
+    noteBorder: string;
+    noteText: string;
+}
+export declare function postProcessMermaidSvg(svg: string, tokens: MermaidVisualTokens): string;
+export {};

package/dist/AiConversation/_lobe/Mermaid/postProcessMermaidSvg.js

@@ -0,0 +1,289 @@
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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; }
+function clampRoundedRectRadius(width, height, radius) {
+  return Math.max(0, Math.min(radius, width / 2, height / 2));
+}
+function createRoundedRectPathD(x, y, width, height, radius) {
+  var roundedRadius = clampRoundedRectRadius(width, height, radius);
+  return ["M ".concat(x + roundedRadius, " ").concat(y), "H ".concat(x + width - roundedRadius), "A ".concat(roundedRadius, " ").concat(roundedRadius, " 0 0 1 ").concat(x + width, " ").concat(y + roundedRadius), "V ".concat(y + height - roundedRadius), "A ".concat(roundedRadius, " ").concat(roundedRadius, " 0 0 1 ").concat(x + width - roundedRadius, " ").concat(y + height), "H ".concat(x + roundedRadius), "A ".concat(roundedRadius, " ").concat(roundedRadius, " 0 0 1 ").concat(x, " ").concat(y + height - roundedRadius), "V ".concat(y + roundedRadius), "A ".concat(roundedRadius, " ").concat(roundedRadius, " 0 0 1 ").concat(x + roundedRadius, " ").concat(y), 'Z'].join(' ');
+}
+function createRoundedPolygonPathD(points, radius) {
+  var vertices = points.trim().split(/\s+/).map(function (p) {
+    var _p$split$map = p.split(',').map(Number),
+      _p$split$map2 = _slicedToArray(_p$split$map, 2),
+      x = _p$split$map2[0],
+      y = _p$split$map2[1];
+    return {
+      x: x,
+      y: y
+    };
+  });
+  if (vertices.length < 3) return null;
+  var n = vertices.length;
+  var segments = [];
+  for (var i = 0; i < n; i++) {
+    var prev = vertices[(i - 1 + n) % n];
+    var curr = vertices[i];
+    var next = vertices[(i + 1) % n];
+    var dx1 = prev.x - curr.x;
+    var dy1 = prev.y - curr.y;
+    var dx2 = next.x - curr.x;
+    var dy2 = next.y - curr.y;
+    var len1 = Math.hypot(dx1, dy1);
+    var len2 = Math.hypot(dx2, dy2);
+    if (len1 === 0 || len2 === 0) return null;
+    var r = Math.min(radius, len1 / 2, len2 / 2);
+    var startX = curr.x + dx1 / len1 * r;
+    var startY = curr.y + dy1 / len1 * r;
+    var endX = curr.x + dx2 / len2 * r;
+    var endY = curr.y + dy2 / len2 * r;
+    if (i === 0) {
+      segments.push("M ".concat(startX, " ").concat(startY));
+    } else {
+      segments.push("L ".concat(startX, " ").concat(startY));
+    }
+    segments.push("Q ".concat(curr.x, " ").concat(curr.y, " ").concat(endX, " ").concat(endY));
+  }
+  segments.push('Z');
+  return segments.join(' ');
+}
+function extractRectangleBoundsFromPath(pathData) {
+  var _pathData$match;
+  var numbers = (_pathData$match = pathData.match(/-?\d*\.?\d+/g)) === null || _pathData$match === void 0 ? void 0 : _pathData$match.map(Number);
+  if (!numbers || numbers.length < 8 || numbers.length % 2 !== 0) return null;
+  var points = [];
+  for (var index = 0; index < numbers.length; index += 2) {
+    var x = numbers[index];
+    var y = numbers[index + 1];
+    if (x === undefined || y === undefined) return null;
+    points.push({
+      x: x,
+      y: y
+    });
+  }
+  var uniqueX = _toConsumableArray(new Set(points.map(function (point) {
+    return Math.round(point.x * 100) / 100;
+  })));
+  var uniqueY = _toConsumableArray(new Set(points.map(function (point) {
+    return Math.round(point.y * 100) / 100;
+  })));
+  if (uniqueX.length > 2 || uniqueY.length > 2) return null;
+  var minX = Math.min.apply(Math, _toConsumableArray(points.map(function (point) {
+    return point.x;
+  })));
+  var maxX = Math.max.apply(Math, _toConsumableArray(points.map(function (point) {
+    return point.x;
+  })));
+  var minY = Math.min.apply(Math, _toConsumableArray(points.map(function (point) {
+    return point.y;
+  })));
+  var maxY = Math.max.apply(Math, _toConsumableArray(points.map(function (point) {
+    return point.y;
+  })));
+  return {
+    height: maxY - minY,
+    width: maxX - minX,
+    x: minX,
+    y: minY
+  };
+}
+function mergeInlineStyle(existingStyle, nextDeclarations) {
+  var styleMap = new Map();
+  var _iterator = _createForOfIteratorHelper(existingStyle.split(';').map(function (item) {
+      return item.trim();
+    }).filter(Boolean)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var part = _step.value;
+      var separatorIndex = part.indexOf(':');
+      if (separatorIndex === -1) continue;
+      var _property = part.slice(0, separatorIndex).trim().toLowerCase();
+      var _value = part.slice(separatorIndex + 1).trim();
+      if (!_property || !_value) continue;
+      styleMap.set(_property, _value);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  for (var _i = 0, _Object$entries = Object.entries(nextDeclarations); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      property = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    styleMap.set(property, String(value));
+  }
+  return Array.from(styleMap.entries()).map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      property = _ref2[0],
+      value = _ref2[1];
+    return "".concat(property, ": ").concat(value);
+  }).join('; ');
+}
+function setRectPresentation(rect, _ref3) {
+  var borderRadius = _ref3.borderRadius,
+    fill = _ref3.fill,
+    stroke = _ref3.stroke;
+  rect.setAttribute('rx', String(borderRadius));
+  rect.setAttribute('ry', String(borderRadius));
+  if (fill) rect.setAttribute('fill', fill);
+  if (stroke) rect.setAttribute('stroke', stroke);
+}
+function roundRectanglePaths(paths, radius) {
+  paths.forEach(function (path) {
+    var pathData = path.getAttribute('d');
+    if (!pathData) return;
+    var bounds = extractRectangleBoundsFromPath(pathData);
+    if (!bounds || bounds.width <= 0 || bounds.height <= 0) return;
+    path.setAttribute('d', createRoundedRectPathD(bounds.x, bounds.y, bounds.width, bounds.height, radius));
+  });
+}
+export function postProcessMermaidSvg(svg, tokens) {
+  if (!svg) return svg;
+  if (typeof DOMParser === 'undefined') return svg;
+  try {
+    var parser = new DOMParser();
+    var doc = parser.parseFromString(svg, 'image/svg+xml');
+    var parseError = doc.querySelector('parsererror');
+    if (parseError) return svg;
+    var root = doc.documentElement;
+    if (!root || root.localName !== 'svg') return svg;
+    var styleEl = root.querySelector('style');
+    if (styleEl) {
+      styleEl.textContent = (styleEl.textContent || '') + '\n.edgeLabel, .edgeLabel p { background-color: transparent !important; }' + '\n.edgeLabel rect { opacity: 1 !important; }' + '\n.labelBkg { background-color: transparent !important; box-shadow: none !important; }';
+    }
+    var edgeLabelGroups = root.querySelectorAll('.edgeLabel g.label');
+    edgeLabelGroups.forEach(function (labelGroup) {
+      var fo = labelGroup.querySelector('foreignObject');
+      if (!fo) return;
+      var foWidth = Number.parseFloat(fo.getAttribute('width') || '0');
+      var foHeight = Number.parseFloat(fo.getAttribute('height') || '0');
+      if (foWidth <= 0 || foHeight <= 0) return;
+      var existingRect = labelGroup.querySelector('rect');
+      if (existingRect) {
+        setRectPresentation(existingRect, {
+          borderRadius: tokens.labelPillRadius,
+          fill: tokens.labelBackground,
+          stroke: tokens.labelBorder
+        });
+      } else {
+        var actualRx = Math.min(tokens.labelPillRadius, foHeight / 2);
+        var paddingX = Math.ceil(actualRx * 0.5);
+        var rect = doc.createElementNS('http://www.w3.org/2000/svg', 'rect');
+        rect.setAttribute('x', String(-paddingX));
+        rect.setAttribute('y', '0');
+        rect.setAttribute('width', String(foWidth + paddingX * 2));
+        rect.setAttribute('height', String(foHeight));
+        rect.setAttribute('rx', String(actualRx));
+        rect.setAttribute('ry', String(actualRx));
+        rect.setAttribute('fill', tokens.labelBackground);
+        rect.setAttribute('stroke', tokens.labelBorder);
+        rect.setAttribute('class', 'edge-label-pill');
+        labelGroup.insertBefore(rect, labelGroup.firstChild);
+      }
+    });
+    var labelBackgrounds = root.querySelectorAll('foreignObject .labelBkg');
+    labelBackgrounds.forEach(function (el) {
+      var _el$getAttribute;
+      var existing = (_el$getAttribute = el.getAttribute('style')) !== null && _el$getAttribute !== void 0 ? _el$getAttribute : '';
+      el.setAttribute('style', mergeInlineStyle(existing, {
+        'background-color': 'transparent',
+        'box-shadow': 'none'
+      }));
+    });
+    var htmlEdgeLabels = root.querySelectorAll('foreignObject .edgeLabel');
+    htmlEdgeLabels.forEach(function (el) {
+      var _el$getAttribute2;
+      var existing = (_el$getAttribute2 = el.getAttribute('style')) !== null && _el$getAttribute2 !== void 0 ? _el$getAttribute2 : '';
+      el.setAttribute('style', mergeInlineStyle(existing, {
+        'background-color': 'transparent',
+        'color': tokens.labelText
+      }));
+    });
+    var edgeLabelRects = root.querySelectorAll('.edgeLabel rect:not(.edge-label-pill), rect.labelBox');
+    edgeLabelRects.forEach(function (rect) {
+      setRectPresentation(rect, {
+        borderRadius: tokens.labelPillRadius,
+        fill: tokens.labelBackground,
+        stroke: tokens.labelBorder
+      });
+    });
+    var noteRects = root.querySelectorAll('rect.note, .note rect');
+    noteRects.forEach(function (rect) {
+      setRectPresentation(rect, {
+        borderRadius: tokens.borderRadius,
+        fill: tokens.noteBackground,
+        stroke: tokens.noteBorder
+      });
+    });
+    var noteTexts = root.querySelectorAll('.noteText, .note text');
+    noteTexts.forEach(function (text) {
+      text.setAttribute('fill', tokens.noteText);
+    });
+    roundRectanglePaths(root.querySelectorAll('.basic.label-container path, g.basic.label-container path, .node.note path'), tokens.borderRadius);
+    root.querySelectorAll('g.basic.label-container, g.node.note').forEach(function (container) {
+      var pathArray = Array.from(container.querySelectorAll('path'));
+      if (pathArray.length < 2) return;
+      var isFillOnly = function isFillOnly(p) {
+        return p.getAttribute('fill') !== 'none' && p.getAttribute('fill') !== null && (p.getAttribute('stroke') === 'none' || p.getAttribute('stroke') === null || p.getAttribute('stroke-width') === '0');
+      };
+      var isBorderOnly = function isBorderOnly(p) {
+        return (!p.getAttribute('fill') || p.getAttribute('fill') === 'none') && p.getAttribute('stroke') !== 'none' && p.getAttribute('stroke') !== null && p.getAttribute('stroke-width') !== '0';
+      };
+      var fillPath = pathArray.find(isFillOnly);
+      var borderPaths = pathArray.filter(isBorderOnly);
+      if (!fillPath || borderPaths.length === 0) return;
+      var donor = borderPaths[0];
+      var stroke = donor.getAttribute('stroke');
+      var strokeWidth = donor.getAttribute('stroke-width');
+      if (stroke) fillPath.setAttribute('stroke', stroke);
+      if (strokeWidth) fillPath.setAttribute('stroke-width', strokeWidth);
+      var _iterator2 = _createForOfIteratorHelper(borderPaths),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var bp = _step2.value;
+          bp.remove();
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    });
+    var roundedRectSelectors = ['.node > rect', '.node rect', '.node > .basic', '.classGroup > rect', '.classGroup rect', '.cluster > rect', '.actor', '.activation0', '.activation1', '.activation2', '.stateGroup rect', '.statediagram-state rect'];
+    root.querySelectorAll(roundedRectSelectors.join(', ')).forEach(function (rect) {
+      setRectPresentation(rect, {
+        borderRadius: tokens.borderRadius
+      });
+    });
+    root.querySelectorAll('.node polygon').forEach(function (polygon) {
+      var pts = polygon.getAttribute('points');
+      if (!pts) return;
+      var d = createRoundedPolygonPathD(pts, tokens.borderRadius);
+      if (!d) return;
+      var path = doc.createElementNS('http://www.w3.org/2000/svg', 'path');
+      path.setAttribute('d', d);
+      for (var _i2 = 0, _Array$from = Array.from(polygon.attributes); _i2 < _Array$from.length; _i2++) {
+        var attr = _Array$from[_i2];
+        if (attr.name !== 'points') {
+          path.setAttribute(attr.name, attr.value);
+        }
+      }
+      polygon.replaceWith(path);
+    });
+    return new XMLSerializer().serializeToString(doc);
+  } catch (_unused) {
+    return svg;
+  }
+}

package/dist/AiConversation/_lobe/Mermaid/type.d.ts

@@ -0,0 +1,48 @@
+import type { MermaidConfig } from 'mermaid';
+import type { CSSProperties, ReactNode, Ref } from 'react';
+import type { ActionIconProps } from '../ActionIcon';
+import type { DivProps } from '../types';
+export interface SyntaxMermaidProps {
+    animated?: boolean;
+    children: string;
+    className?: string;
+    fallbackClassName?: string;
+    ref?: Ref<HTMLDivElement>;
+    style?: CSSProperties;
+    theme?: MermaidProps['theme'];
+    variant?: MermaidProps['variant'];
+}
+export interface MermaidProps extends DivProps {
+    actionIconSize?: ActionIconProps['size'];
+    actionsRender?: (props: {
+        actionIconSize: ActionIconProps['size'];
+        content: string;
+        getContent: () => string;
+        originalNode: ReactNode;
+    }) => ReactNode;
+    animated?: boolean;
+    bodyRender?: (props: {
+        content: string;
+        originalNode: ReactNode;
+    }) => ReactNode;
+    children: string;
+    classNames?: {
+        body?: string;
+        content?: string;
+        header?: string;
+    };
+    copyable?: boolean;
+    defaultExpand?: boolean;
+    fileName?: string;
+    fullFeatured?: boolean;
+    language?: string;
+    shadow?: boolean;
+    showLanguage?: boolean;
+    styles?: {
+        body?: CSSProperties;
+        content?: CSSProperties;
+        header?: CSSProperties;
+    };
+    theme?: 'lobe-theme' | MermaidConfig['theme'];
+    variant?: 'filled' | 'outlined' | 'borderless';
+}

package/dist/AiConversation/_lobe/Mermaid/type.js

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

package/dist/AiConversation/_lobe/Modal/Modal.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { type ModalProps } from './type';
+declare const Modal: import("react").NamedExoticComponent<ModalProps>;
+export default Modal;

package/dist/AiConversation/_lobe/Modal/Modal.js

@@ -0,0 +1,167 @@
+'use client';
+
+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); }
+var _excluded = ["panelRef", "allowFullscreen", "children", "title", "className", "classNames", "width", "onCancel", "open", "destroyOnHidden", "paddings", "height", "enableResponsive", "footer", "styles", "okText", "onOk", "cancelText", "okButtonProps", "cancelButtonProps", "confirmLoading"];
+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); }
+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; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import { Button, ConfigProvider, Drawer, Modal as AntModal } from 'antd';
+import { cssVar, cx, useResponsive } from 'antd-style';
+import { Maximize2, Minimize2, X } from 'lucide-react';
+import { memo, useState } from 'react';
+import ActionIcon from "../ActionIcon";
+import Icon from "../Icon";
+import { styles } from "./style";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var Modal = /*#__PURE__*/memo(function (_ref) {
+  var _paddings$desktop, _paddings$desktop2;
+  var panelRef = _ref.panelRef,
+    allowFullscreen = _ref.allowFullscreen,
+    children = _ref.children,
+    _ref$title = _ref.title,
+    title = _ref$title === void 0 ? ' ' : _ref$title,
+    className = _ref.className,
+    classNames = _ref.classNames,
+    _ref$width = _ref.width,
+    width = _ref$width === void 0 ? 700 : _ref$width,
+    onCancel = _ref.onCancel,
+    open = _ref.open,
+    destroyOnHidden = _ref.destroyOnHidden,
+    paddings = _ref.paddings,
+    _ref$height = _ref.height,
+    height = _ref$height === void 0 ? '75dvh' : _ref$height,
+    _ref$enableResponsive = _ref.enableResponsive,
+    enableResponsive = _ref$enableResponsive === void 0 ? true : _ref$enableResponsive,
+    footer = _ref.footer,
+    customStyles = _ref.styles,
+    okText = _ref.okText,
+    onOk = _ref.onOk,
+    cancelText = _ref.cancelText,
+    okButtonProps = _ref.okButtonProps,
+    cancelButtonProps = _ref.cancelButtonProps,
+    confirmLoading = _ref.confirmLoading,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    fullscreen = _useState2[0],
+    setFullscreen = _useState2[1];
+  var _useResponsive = useResponsive(),
+    mobile = _useResponsive.mobile;
+  var hideFooter = footer === false || footer === null;
+  if (enableResponsive && mobile) return /*#__PURE__*/_jsx(ConfigProvider, {
+    theme: {
+      token: {
+        colorBgElevated: cssVar.colorBgContainer
+      }
+    },
+    children: /*#__PURE__*/_jsx(Drawer, _objectSpread(_objectSpread({
+      className: cx(styles.drawerContent, className),
+      closeIcon: /*#__PURE__*/_jsx(ActionIcon, {
+        icon: X
+      }),
+      destroyOnHidden: destroyOnHidden,
+      height: fullscreen ? 'calc(100% - env(safe-area-inset-top))' : height,
+      open: open,
+      panelRef: panelRef,
+      placement: 'bottom',
+      title: title,
+      classNames: typeof classNames === 'function' ? classNames : _objectSpread(_objectSpread({}, classNames), {}, {
+        wrapper: cx(styles.wrap, classNames === null || classNames === void 0 ? void 0 : classNames.wrapper)
+      }),
+      extra: allowFullscreen && /*#__PURE__*/_jsx(ActionIcon, {
+        icon: fullscreen ? Minimize2 : Maximize2,
+        onClick: function onClick() {
+          return setFullscreen(!fullscreen);
+        }
+      }),
+      footer: hideFooter ? null : footer || /*#__PURE__*/_jsxs(_Fragment, {
+        children: [/*#__PURE__*/_jsx(Button, _objectSpread(_objectSpread({
+          color: 'default',
+          variant: 'filled',
+          onClick: onCancel
+        }, cancelButtonProps), {}, {
+          children: cancelText || 'Cancel'
+        })), /*#__PURE__*/_jsx(Button, _objectSpread(_objectSpread({
+          loading: confirmLoading,
+          type: "primary",
+          onClick: onOk
+        }, okButtonProps), {}, {
+          style: _objectSpread({
+            marginInlineStart: 8
+          }, okButtonProps === null || okButtonProps === void 0 ? void 0 : okButtonProps.style),
+          children: okText || 'OK'
+        }))]
+      }),
+      styles: typeof customStyles === 'function' ? customStyles : _objectSpread(_objectSpread({}, customStyles), {}, {
+        body: _objectSpread({
+          paddingBlock: "16px ".concat(footer ? 0 : '16px'),
+          paddingInline: (_paddings$desktop = paddings === null || paddings === void 0 ? void 0 : paddings.desktop) !== null && _paddings$desktop !== void 0 ? _paddings$desktop : 16
+        }, customStyles === null || customStyles === void 0 ? void 0 : customStyles.body)
+      }),
+      onClose: onCancel
+    }, rest), {}, {
+      children: children
+    }))
+  });
+  return /*#__PURE__*/_jsx(ConfigProvider, {
+    theme: {
+      token: {
+        colorBgElevated: cssVar.colorBgContainer
+      }
+    },
+    children: /*#__PURE__*/_jsx(AntModal, _objectSpread(_objectSpread({
+      closable: true,
+      mask: {
+        closable: true
+      },
+      cancelText: cancelText,
+      className: cx(styles.content, className),
+      closeIcon: /*#__PURE__*/_jsx(Icon, {
+        icon: X,
+        size: 20
+      }),
+      confirmLoading: confirmLoading,
+      destroyOnHidden: destroyOnHidden,
+      footer: hideFooter ? null : footer,
+      okButtonProps: okButtonProps,
+      okText: okText,
+      open: open,
+      panelRef: panelRef,
+      title: title,
+      width: width,
+      cancelButtonProps: _objectSpread({
+        color: 'default',
+        variant: 'filled'
+      }, cancelButtonProps),
+      classNames: typeof classNames === 'function' ? classNames : _objectSpread(_objectSpread({}, classNames), {}, {
+        wrapper: cx(styles.wrap, classNames === null || classNames === void 0 ? void 0 : classNames.wrapper)
+      }),
+      styles: typeof customStyles === 'function' ? customStyles : _objectSpread(_objectSpread({}, customStyles), {}, {
+        body: _objectSpread({
+          maxHeight: height,
+          overflow: 'hidden auto',
+          paddingBlock: "0 ".concat(footer === null ? '16px' : 0),
+          paddingInline: (_paddings$desktop2 = paddings === null || paddings === void 0 ? void 0 : paddings.desktop) !== null && _paddings$desktop2 !== void 0 ? _paddings$desktop2 : 16
+        }, customStyles === null || customStyles === void 0 ? void 0 : customStyles.body)
+      }),
+      onCancel: onCancel,
+      onOk: onOk
+    }, rest), {}, {
+      children: children
+    }))
+  });
+});
+Modal.displayName = 'Modal';
+export default Modal;

package/dist/AiConversation/_lobe/Modal/ModalProvider.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { ModalContextValue } from './type';
+export declare const ModalContext: import("react").Context<ModalContextValue>;
+export declare const ModalProvider: import("react").NamedExoticComponent<{
+    children: ReactNode;
+    value: ModalContextValue;
+}>;
+export declare const useModalContext: () => ModalContextValue;

package/dist/AiConversation/_lobe/Modal/ModalProvider.js

@@ -0,0 +1,23 @@
+'use client';
+
+import { createContext, memo, use } from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var ModalContext = /*#__PURE__*/createContext({
+  close: function close() {
+    return undefined;
+  },
+  setCanDismissByClickOutside: function setCanDismissByClickOutside() {
+    return undefined;
+  }
+});
+export var ModalProvider = /*#__PURE__*/memo(function (_ref) {
+  var children = _ref.children,
+    value = _ref.value;
+  return /*#__PURE__*/_jsx(ModalContext, {
+    value: value,
+    children: children
+  });
+});
+export var useModalContext = function useModalContext() {
+  return use(ModalContext);
+};