@agentscope-ai/chat 1.1.4

package/dist/sender/components/SpeechButton/index.js

@@ -0,0 +1,30 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import { AudioMutedOutlined, AudioOutlined } from '@ant-design/icons';
+import * as React from 'react';
+import ActionButton, { ActionButtonContext } from "../ActionButton";
+import RecordingIcon from "./RecordingIcon";
+function SpeechButton(props, ref) {
+  var _React$useContext = React.useContext(ActionButtonContext),
+    speechRecording = _React$useContext.speechRecording,
+    onSpeechDisabled = _React$useContext.onSpeechDisabled,
+    prefixCls = _React$useContext.prefixCls;
+  var icon = null;
+  if (speechRecording) {
+    icon = /*#__PURE__*/React.createElement(RecordingIcon, {
+      className: "".concat(prefixCls, "-recording-icon")
+    });
+  } else if (onSpeechDisabled) {
+    icon = /*#__PURE__*/React.createElement(AudioMutedOutlined, null);
+  } else {
+    icon = /*#__PURE__*/React.createElement(AudioOutlined, null);
+  }
+  return /*#__PURE__*/React.createElement(ActionButton, _extends({
+    icon: icon,
+    color: "primary",
+    variant: "text"
+  }, props, {
+    action: "onSpeech",
+    ref: ref
+  }));
+}
+export default /*#__PURE__*/React.forwardRef(SpeechButton);

package/dist/sender/index.d.ts

@@ -0,0 +1,61 @@
+import { Input } from 'antd';
+import React from 'react';
+import SenderHeader from './SenderHeader';
+import { type AllowSpeech } from './useSpeech';
+import type { InputRef as AntdInputRef, ButtonProps, GetProps } from 'antd';
+export type SubmitType = 'enter' | 'shiftEnter' | false;
+type TextareaProps = GetProps<typeof Input.TextArea>;
+export interface SenderComponents {
+    input?: React.ComponentType<TextareaProps>;
+}
+export type ActionsRender = (ori: React.ReactNode, info: {
+    components: {
+        SendButton: React.ComponentType<ButtonProps>;
+        ClearButton: React.ComponentType<ButtonProps>;
+        LoadingButton: React.ComponentType<ButtonProps>;
+    };
+}) => React.ReactNode;
+export interface SenderProps extends Pick<TextareaProps, 'placeholder' | 'onKeyPress'> {
+    prefixCls?: string;
+    defaultValue?: string;
+    value?: string;
+    loading?: boolean;
+    readOnly?: boolean;
+    submitType?: SubmitType;
+    disabled?: boolean;
+    onSubmit?: (message: string) => void;
+    onChange?: (value: string, event?: React.FormEvent<HTMLTextAreaElement> | React.ChangeEvent<HTMLTextAreaElement>) => void;
+    onCancel?: VoidFunction;
+    onKeyDown?: React.KeyboardEventHandler<any>;
+    onPaste?: React.ClipboardEventHandler<HTMLElement>;
+    onPasteFile?: (file: File) => void;
+    components?: SenderComponents;
+    styles?: {
+        prefix?: React.CSSProperties;
+        input?: React.CSSProperties;
+        actions?: React.CSSProperties;
+    };
+    rootClassName?: string;
+    classNames?: {
+        prefix?: string;
+        input?: string;
+        actions?: string;
+    };
+    style?: React.CSSProperties;
+    className?: string;
+    actions?: React.ReactNode | ActionsRender;
+    allowSpeech?: AllowSpeech;
+    prefix?: React.ReactNode | React.ReactNode[];
+    header?: React.ReactNode;
+    maxLength?: number;
+    zoomable?: boolean;
+}
+export type SenderRef = {
+    nativeElement: HTMLDivElement;
+} & Pick<AntdInputRef, 'focus' | 'blur'>;
+declare const ForwardSender: React.ForwardRefExoticComponent<SenderProps & React.RefAttributes<SenderRef>>;
+type CompoundedSender = typeof ForwardSender & {
+    Header: typeof SenderHeader;
+};
+declare const Sender: CompoundedSender;
+export default Sender;

package/dist/sender/index.js

@@ -0,0 +1,307 @@
+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 = ["prefixCls", "styles", "classNames", "className", "rootClassName", "style", "defaultValue", "value", "readOnly", "submitType", "onSubmit", "loading", "components", "onCancel", "onChange", "actions", "onKeyPress", "onKeyDown", "disabled", "allowSpeech", "header", "onPaste", "onPasteFile"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+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 _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 _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, Flex, Input } from 'antd';
+import classnames from 'classnames';
+import { useMergedState } from 'rc-util';
+import pickAttrs from 'rc-util/lib/pickAttrs';
+import getValue from 'rc-util/lib/utils/get';
+import React, { useState } from 'react';
+import useProxyImperativeHandle from "../_util/hooks/use-proxy-imperative-handle";
+import { useProviderContext } from "./..";
+import SenderHeader, { SendHeaderContext } from "./SenderHeader";
+import { ActionButtonContext } from "./components/ActionButton";
+import ClearButton from "./components/ClearButton";
+import LoadingButton from "./components/LoadingButton";
+import SendButton from "./components/SendButton";
+import SpeechButton from "./components/SpeechButton";
+import useStyle from "./style";
+import useSpeech from "./useSpeech";
+import { FullscreenExitOutlined, FullscreenOutlined } from '@ant-design/icons';
+function getComponent(components, path, defaultComponent) {
+  return getValue(components, path) || defaultComponent;
+}
+var ForwardSender = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var customizePrefixCls = props.prefixCls,
+    _props$styles = props.styles,
+    styles = _props$styles === void 0 ? {} : _props$styles,
+    _props$classNames = props.classNames,
+    classNames = _props$classNames === void 0 ? {} : _props$classNames,
+    className = props.className,
+    rootClassName = props.rootClassName,
+    style = props.style,
+    defaultValue = props.defaultValue,
+    value = props.value,
+    readOnly = props.readOnly,
+    _props$submitType = props.submitType,
+    submitType = _props$submitType === void 0 ? 'enter' : _props$submitType,
+    onSubmit = props.onSubmit,
+    loading = props.loading,
+    components = props.components,
+    onCancel = props.onCancel,
+    onChange = props.onChange,
+    actions = props.actions,
+    onKeyPress = props.onKeyPress,
+    onKeyDown = props.onKeyDown,
+    disabled = props.disabled,
+    allowSpeech = props.allowSpeech,
+    header = props.header,
+    onPaste = props.onPaste,
+    onPasteFile = props.onPasteFile,
+    rest = _objectWithoutProperties(props, _excluded);
+  var _useState = useState(props.zoomable ? false : undefined),
+    _useState2 = _slicedToArray(_useState, 2),
+    zoom = _useState2[0],
+    setZoom = _useState2[1];
+  var autoSize = React.useMemo(function () {
+    return zoom ? {
+      maxRows: 8,
+      minRows: 8
+    } : {
+      maxRows: 2,
+      minRows: 2
+    };
+  }, [props.zoomable, zoom]);
+  var prefix = React.useMemo(function () {
+    var nodes = Array.isArray(props.prefix) ? _toConsumableArray(props.prefix) : [props.prefix];
+    if (props.zoomable) {
+      nodes.push( /*#__PURE__*/React.createElement(Button, {
+        key: "zoom",
+        onClick: function onClick() {
+          return setZoom(!zoom);
+        },
+        type: "text",
+        icon: zoom ? /*#__PURE__*/React.createElement(FullscreenExitOutlined, null) : /*#__PURE__*/React.createElement(FullscreenOutlined, null)
+      }));
+    }
+    return nodes;
+  }, [props.prefix, props.zoomable, zoom]);
+
+  // ============================= MISC =============================
+  var _useProviderContext = useProviderContext(),
+    direction = _useProviderContext.direction,
+    getPrefixCls = _useProviderContext.getPrefixCls;
+  var prefixCls = getPrefixCls('sender', customizePrefixCls);
+
+  // ============================= Refs =============================
+  var containerRef = React.useRef(null);
+  var inputRef = React.useRef(null);
+  useProxyImperativeHandle(ref, function () {
+    var _inputRef$current, _inputRef$current2;
+    return {
+      nativeElement: containerRef.current,
+      focus: (_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _inputRef$current.focus,
+      blur: (_inputRef$current2 = inputRef.current) === null || _inputRef$current2 === void 0 ? void 0 : _inputRef$current2.blur
+    };
+  });
+  var inputCls = "".concat(prefixCls, "-input");
+
+  // ============================ Styles ============================
+  var _useStyle = useStyle(prefixCls),
+    _useStyle2 = _slicedToArray(_useStyle, 3),
+    wrapCSSVar = _useStyle2[0],
+    hashId = _useStyle2[1],
+    cssVarCls = _useStyle2[2];
+  var mergedCls = classnames(prefixCls, className, rootClassName, hashId, cssVarCls, _defineProperty(_defineProperty({}, "".concat(prefixCls, "-rtl"), direction === 'rtl'), "".concat(prefixCls, "-disabled"), disabled));
+  var actionBtnCls = "".concat(prefixCls, "-actions-btn");
+  var actionListCls = "".concat(prefixCls, "-actions-list");
+
+  // ============================ Value =============================
+  var _useMergedState = useMergedState(defaultValue || '', {
+      value: value
+    }),
+    _useMergedState2 = _slicedToArray(_useMergedState, 2),
+    innerValue = _useMergedState2[0],
+    setInnerValue = _useMergedState2[1];
+  var triggerValueChange = function triggerValueChange(nextValue, event) {
+    setInnerValue(nextValue);
+    if (onChange) {
+      onChange(nextValue, event);
+    }
+  };
+
+  // ============================ Speech ============================
+  var _useSpeech = useSpeech(function (transcript) {
+      triggerValueChange("".concat(innerValue, " ").concat(transcript));
+    }, allowSpeech),
+    _useSpeech2 = _slicedToArray(_useSpeech, 3),
+    speechPermission = _useSpeech2[0],
+    triggerSpeech = _useSpeech2[1],
+    speechRecording = _useSpeech2[2];
+
+  // ========================== Components ==========================
+  var InputTextArea = getComponent(components, ['input'], Input.TextArea);
+  var domProps = pickAttrs(rest, {
+    attr: true,
+    aria: true,
+    data: true
+  });
+  var inputProps = _objectSpread(_objectSpread({}, domProps), {}, {
+    ref: inputRef
+  });
+
+  // ============================ Events ============================
+  var triggerSend = function triggerSend() {
+    if (innerValue && onSubmit && !loading) {
+      onSubmit(innerValue);
+    }
+  };
+  var triggerClear = function triggerClear() {
+    triggerValueChange('');
+  };
+
+  // ============================ Submit ============================
+  var isCompositionRef = React.useRef(false);
+  var onInternalCompositionStart = function onInternalCompositionStart() {
+    isCompositionRef.current = true;
+  };
+  var onInternalCompositionEnd = function onInternalCompositionEnd() {
+    isCompositionRef.current = false;
+  };
+  var onInternalKeyPress = function onInternalKeyPress(e) {
+    var canSubmit = e.key === 'Enter' && !isCompositionRef.current;
+
+    // Check for `submitType` to submit
+    switch (submitType) {
+      case 'enter':
+        if (canSubmit && !e.shiftKey) {
+          e.preventDefault();
+          triggerSend();
+        }
+        break;
+      case 'shiftEnter':
+        if (canSubmit && e.shiftKey) {
+          e.preventDefault();
+          triggerSend();
+        }
+        break;
+    }
+    if (onKeyPress) {
+      onKeyPress(e);
+    }
+  };
+
+  // ============================ Paste =============================
+  var onInternalPaste = function onInternalPaste(e) {
+    var _e$clipboardData;
+    // Get file
+    var file = (_e$clipboardData = e.clipboardData) === null || _e$clipboardData === void 0 ? void 0 : _e$clipboardData.files[0];
+    if (file && onPasteFile) {
+      onPasteFile(file);
+      e.preventDefault();
+    }
+    onPaste === null || onPaste === void 0 || onPaste(e);
+  };
+
+  // ============================ Focus =============================
+  var onContentMouseDown = function onContentMouseDown(e) {
+    var _containerRef$current, _inputRef$current3;
+    // If input focused but click on the container,
+    // input will lose focus.
+    // We call `preventDefault` to prevent this behavior
+    if (e.target !== ((_containerRef$current = containerRef.current) === null || _containerRef$current === void 0 ? void 0 : _containerRef$current.querySelector(".".concat(inputCls)))) {
+      e.preventDefault();
+    }
+    (_inputRef$current3 = inputRef.current) === null || _inputRef$current3 === void 0 || _inputRef$current3.focus();
+  };
+
+  // ============================ Action ============================
+  var actionNode = /*#__PURE__*/React.createElement(Flex, {
+    className: "".concat(actionListCls, "-presets")
+  }, allowSpeech && /*#__PURE__*/React.createElement(SpeechButton, null), loading ? /*#__PURE__*/React.createElement(LoadingButton, null) : /*#__PURE__*/React.createElement(SendButton, null));
+
+  // Custom actions
+  if (typeof actions === 'function') {
+    actionNode = actions(actionNode, {
+      components: {
+        SendButton: SendButton,
+        ClearButton: ClearButton,
+        LoadingButton: LoadingButton
+      }
+    });
+  } else if (actions) {
+    actionNode = actions;
+  }
+
+  // ============================ Render ============================
+  return wrapCSSVar( /*#__PURE__*/React.createElement("div", {
+    ref: containerRef,
+    className: mergedCls,
+    style: style
+  }, header && /*#__PURE__*/React.createElement(SendHeaderContext.Provider, {
+    value: {
+      prefixCls: prefixCls
+    }
+  }, header), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-content"),
+    onMouseDown: onContentMouseDown
+  }, /*#__PURE__*/React.createElement(InputTextArea, _extends({}, inputProps, {
+    disabled: disabled,
+    style: styles.input,
+    className: classnames(inputCls, classNames.input),
+    autoSize: autoSize,
+    value: innerValue.slice(0, props.maxLength || Number.MAX_SAFE_INTEGER),
+    onChange: function onChange(event) {
+      triggerValueChange(event.target.value, event);
+      triggerSpeech(true);
+    },
+    onPressEnter: onInternalKeyPress,
+    onCompositionStart: onInternalCompositionStart,
+    onCompositionEnd: onInternalCompositionEnd,
+    onKeyDown: onKeyDown,
+    onPaste: onInternalPaste,
+    variant: "borderless",
+    readOnly: readOnly
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-content-bottom")
+  }, prefix.length > 0 && /*#__PURE__*/React.createElement("div", {
+    className: classnames("".concat(prefixCls, "-prefix"), classNames.prefix),
+    style: styles.prefix
+  }, /*#__PURE__*/React.createElement(Flex, {
+    gap: 8
+  }, prefix)), /*#__PURE__*/React.createElement("div", {
+    className: classnames(actionListCls, classNames.actions),
+    style: styles.actions
+  }, props.maxLength ? /*#__PURE__*/React.createElement("div", {
+    className: "".concat(actionListCls, "-length")
+  }, innerValue.length, "/", props.maxLength) : null, /*#__PURE__*/React.createElement(ActionButtonContext.Provider, {
+    value: {
+      prefixCls: actionBtnCls,
+      onSend: triggerSend,
+      onSendDisabled: !innerValue,
+      onClear: triggerClear,
+      onClearDisabled: !innerValue,
+      onCancel: onCancel,
+      onCancelDisabled: !loading,
+      onSpeech: function onSpeech() {
+        return triggerSpeech(false);
+      },
+      onSpeechDisabled: !speechPermission,
+      speechRecording: speechRecording,
+      disabled: disabled
+    }
+  }, actionNode))))));
+});
+var Sender = ForwardSender;
+if (process.env.NODE_ENV !== 'production') {
+  Sender.displayName = 'Sender';
+}
+Sender.Header = SenderHeader;
+export default Sender;

package/dist/sender/style/header.d.ts

@@ -0,0 +1,4 @@
+import type { SenderToken } from '.';
+import type { GenerateStyle } from '../../theme/cssinjs-utils';
+declare const genSenderHeaderStyle: GenerateStyle<SenderToken>;
+export default genSenderHeaderStyle;

package/dist/sender/style/header.js

@@ -0,0 +1,46 @@
+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 _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); }
+var genSenderHeaderStyle = function genSenderHeaderStyle(token) {
+  var componentCls = token.componentCls,
+    calc = token.calc;
+  var headerCls = "".concat(componentCls, "-header");
+  return _defineProperty({}, componentCls, _defineProperty({}, headerCls, {
+    // borderBottomWidth: token.lineWidth,
+    // borderBottomStyle: 'solid',
+    // borderBottomColor: token.colorBorder,
+
+    // ======================== Header ========================
+    '&-header': _defineProperty({
+      background: token.colorFillAlter,
+      fontSize: token.fontSize,
+      lineHeight: token.lineHeight,
+      paddingBlock: calc(token.paddingSM).sub(token.lineWidthBold).equal(),
+      paddingInlineStart: token.padding,
+      paddingInlineEnd: token.paddingXS,
+      display: 'flex'
+    }, "".concat(headerCls, "-title"), {
+      flex: 'auto',
+      color: token.colorText
+    }),
+    // ======================= Content ========================
+    '&-content': {
+      // padding: token.padding,
+    },
+    // ======================== Motion ========================
+    '&-motion': {
+      transition: ['height', 'border'].map(function (prop) {
+        return "".concat(prop, " ").concat(token.motionDurationSlow);
+      }).join(','),
+      overflow: 'hidden',
+      '&-enter-start, &-leave-active': {
+        borderBottomColor: 'transparent'
+      },
+      '&-hidden': {
+        display: 'none'
+      }
+    }
+  }));
+};
+export default genSenderHeaderStyle;

package/dist/sender/style/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import type { FullToken, GetDefaultToken } from '../../theme/cssinjs-utils';
+export interface ComponentToken {
+}
+export interface SenderToken extends FullToken<'Sender'> {
+    SenderContentMaxWidth: number | string;
+}
+export declare const prepareComponentToken: GetDefaultToken<'Sender'>;
+declare const _default: (prefixCls: string, rootCls?: string) => readonly [(node: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>, string, string];
+export default _default;

package/dist/sender/style/index.js

@@ -0,0 +1,123 @@
+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 _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 { unit } from '@ant-design/cssinjs';
+import { mergeToken } from '@ant-design/cssinjs-utils';
+import { genStyleHooks } from "../../theme/genStyleUtils";
+import genSenderHeaderStyle from "./header";
+var genSenderStyle = function genSenderStyle(token) {
+  var componentCls = token.componentCls,
+    padding = token.padding,
+    paddingSM = token.paddingSM,
+    paddingXS = token.paddingXS,
+    lineWidth = token.lineWidth,
+    lineWidthBold = token.lineWidthBold,
+    calc = token.calc;
+  return _defineProperty({}, componentCls, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({
+    position: 'relative',
+    width: '100%',
+    boxSizing: 'border-box',
+    boxShadow: '0px 12px 24px -16px rgba(54, 54, 73, 0.04),0px 12px 40px 0px rgba(51, 51, 71, 0.08),0px 0px 1px 0px rgba(44, 44, 54, 0.02)',
+    transition: "background ".concat(token.motionDurationSlow),
+    backgroundColor: token.colorBgBase,
+    // Border
+    borderRadius: {
+      _skip_check_: true,
+      value: 8
+    },
+    borderColor: token.colorBorder,
+    borderWidth: 0,
+    borderStyle: 'solid',
+    // Border
+    '&:after': {
+      content: '""',
+      position: 'absolute',
+      inset: 0,
+      pointerEvents: 'none',
+      transition: "border-color ".concat(token.motionDurationSlow),
+      borderRadius: {
+        _skip_check_: true,
+        value: 'inherit'
+      },
+      borderStyle: 'inherit',
+      borderColor: 'inherit',
+      borderWidth: lineWidth
+    },
+    // Focus
+    '&:focus-within': {
+      boxShadow: "0px 12px 24px -16px rgba(54, 54, 73, 0.04),0px 12px 40px 0px rgba(51, 51, 71, 0.08),0px 0px 1px 0px rgba(44, 44, 54, 0.02)",
+      borderColor: token.colorPrimaryHover,
+      '&:after': {
+        borderWidth: lineWidth
+      }
+    },
+    '&-disabled': {
+      background: token.colorBgContainerDisabled
+    }
+  }, "&".concat(componentCls, "-rtl"), {
+    direction: 'rtl'
+  }), "".concat(componentCls, "-content"), {
+    width: '100%',
+    padding: 8,
+    boxSizing: 'border-box',
+    overflow: 'hidden',
+    borderRadius: 10
+  }), "".concat(componentCls, "-content-bottom"), {
+    display: 'flex',
+    marginTop: 8
+  }), "".concat(componentCls, "-prefix"), {
+    // flex: 'none',
+    flex: 1
+  }), "".concat(componentCls, "-input"), {
+    padding: '6px 8px',
+    borderRadius: 0,
+    alignSelf: 'center',
+    fontSize: 14,
+    lineHeight: 1.7
+  }), "".concat(componentCls, "-actions-list"), {
+    flex: 'none',
+    display: 'flex',
+    margin: '0 0 0 auto',
+    '&-presets': {
+      gap: token.paddingXS
+    },
+    '&-length': {
+      fontSize: 12,
+      lineHeight: 1,
+      display: 'flex',
+      alignItems: 'center',
+      padding: '0 12px',
+      color: token.colorTextTertiary
+    }
+  }), "".concat(componentCls, "-actions-btn"), {
+    '&-disabled': {
+      opacity: 0.45
+    },
+    '&-loading-button': {
+      padding: 0,
+      border: 0
+    },
+    '&-loading-icon': {
+      height: token.controlHeight,
+      width: token.controlHeight,
+      verticalAlign: 'top'
+    },
+    '&-recording-icon': {
+      height: '1.2em',
+      width: '1.2em',
+      verticalAlign: 'top'
+    }
+  }));
+};
+export var prepareComponentToken = function prepareComponentToken() {
+  return {};
+};
+export default genStyleHooks('Sender', function (token) {
+  var paddingXS = token.paddingXS,
+    calc = token.calc;
+  var SenderToken = mergeToken(token, {
+    SenderContentMaxWidth: "calc(100% - ".concat(unit(calc(paddingXS).add(32).equal()), ")")
+  });
+  return [genSenderStyle(SenderToken), genSenderHeaderStyle(SenderToken)];
+}, prepareComponentToken);

package/dist/sender/useSpeech.d.ts

@@ -0,0 +1,6 @@
+export type ControlledSpeechConfig = {
+    recording?: boolean;
+    onRecordingChange: (recording: boolean) => void;
+};
+export type AllowSpeech = boolean | ControlledSpeechConfig;
+export default function useSpeech(onSpeech: (transcript: string) => void, allowSpeech?: AllowSpeech): readonly [boolean, (forceBreak: boolean) => void, boolean];