@vunk/plus 1.1.4 → 1.2.0

package/components/recorder-button/src/index.vue.d.ts

@@ -0,0 +1,309 @@
+import type { Ref } from 'vue';
+import 'recorder-core/src/engine/mp3';
+import 'recorder-core/src/engine/wav';
+import 'recorder-core/src/engine/mp3-engine';
+import 'recorder-core/src/extensions/waveview';
+import 'recorder-core/src/app-support/app';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    speenchToTextUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    onTextZone: {
+        type: import("vue").PropType<import("./types").OnTextZone>;
+        default: any;
+    };
+}>, {
+    onmousedown: (e: MouseEvent | TouchEvent) => void;
+    onmousemove: (e: MouseEvent | TouchEvent) => void;
+    onmouseup: (e: MouseEvent | TouchEvent) => void;
+    recording: Ref<boolean, boolean>;
+    recordingNode: Ref<HTMLSpanElement, HTMLSpanElement>;
+    blobUrl: Ref<string, string>;
+    isDragging: Ref<boolean, boolean>;
+    cancelZone: Ref<boolean, boolean>;
+    isTextZone: Ref<boolean, boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    submitText: (text: string) => boolean;
+    submit: (_: import("./types").SubmitRawEvent) => boolean;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    speenchToTextUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    onTextZone: {
+        type: import("vue").PropType<import("./types").OnTextZone>;
+        default: any;
+    };
+}>> & Readonly<{
+    onSubmit?: (_: import("./types").SubmitRawEvent) => any;
+    onSubmitText?: (text: string) => any;
+}>, {
+    speenchToTextUrl: string;
+    onTextZone: import("./types").OnTextZone;
+}, {}, {
+    ElButton: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: (val: unknown) => boolean;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+        readonly icon: {
+            readonly type: import("vue").PropType<unknown>;
+            readonly required: false;
+            readonly validator: (val: unknown) => boolean;
+            __epPropKey: true;
+        };
+        readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
+        readonly loading: BooleanConstructor;
+        readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
+        readonly plain: BooleanConstructor;
+        readonly text: BooleanConstructor;
+        readonly link: BooleanConstructor;
+        readonly bg: BooleanConstructor;
+        readonly autofocus: BooleanConstructor;
+        readonly round: BooleanConstructor;
+        readonly circle: BooleanConstructor;
+        readonly color: StringConstructor;
+        readonly dark: BooleanConstructor;
+        readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: (val: unknown) => boolean;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+            readonly icon: {
+                readonly type: import("vue").PropType<unknown>;
+                readonly required: false;
+                readonly validator: (val: unknown) => boolean;
+                __epPropKey: true;
+            };
+            readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
+            readonly loading: BooleanConstructor;
+            readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
+            readonly plain: BooleanConstructor;
+            readonly text: BooleanConstructor;
+            readonly link: BooleanConstructor;
+            readonly bg: BooleanConstructor;
+            readonly autofocus: BooleanConstructor;
+            readonly round: BooleanConstructor;
+            readonly circle: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly dark: BooleanConstructor;
+            readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+            readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
+        }>> & {
+            onClick?: (evt: MouseEvent) => any;
+        }>>;
+        emit: (event: "click", evt: MouseEvent) => void;
+        buttonStyle: import("vue").ComputedRef<Record<string, string>>;
+        ns: {
+            namespace: import("vue").ComputedRef<string>;
+            b: (blockSuffix?: string) => string;
+            e: (element?: string) => string;
+            m: (modifier?: string) => string;
+            be: (blockSuffix?: string, element?: string) => string;
+            em: (element?: string, modifier?: string) => string;
+            bm: (blockSuffix?: string, modifier?: string) => string;
+            bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+            is: {
+                (name: string, state: boolean): string;
+                (name: string): string;
+            };
+            cssVar: (object: Record<string, string>) => Record<string, string>;
+            cssVarName: (name: string) => string;
+            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+            cssVarBlockName: (name: string) => string;
+        };
+        _ref: Ref<HTMLButtonElement, HTMLButtonElement>;
+        _size: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+        _type: import("vue").ComputedRef<"" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger">;
+        _disabled: import("vue").ComputedRef<boolean>;
+        _props: import("vue").ComputedRef<{
+            ariaDisabled: boolean;
+            disabled: boolean;
+            autofocus: boolean;
+            type: import("element-plus").ButtonType<StringConstructor, "button" | "reset" | "submit", unknown>;
+        } | {
+            ariaDisabled?: undefined;
+            disabled?: undefined;
+            autofocus?: undefined;
+            type?: undefined;
+        }>;
+        shouldAddSpace: import("vue").ComputedRef<boolean>;
+        handleClick: (evt: MouseEvent) => void;
+        buttonKls: import("vue").ComputedRef<string[]>;
+        ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: (val: unknown) => boolean;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: (val: unknown) => boolean;
+                __epPropKey: true;
+            };
+        }, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly color: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+            }>> & {
+                [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
+            }>>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                is: {
+                    (name: string, state: boolean): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+            style: import("vue").ComputedRef<import("vue").CSSProperties>;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: (val: unknown) => boolean;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: (val: unknown) => boolean;
+                __epPropKey: true;
+            };
+        }>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>> & Record<string, any>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (evt: MouseEvent) => boolean;
+    }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: (val: unknown) => boolean;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+        readonly icon: {
+            readonly type: import("vue").PropType<unknown>;
+            readonly required: false;
+            readonly validator: (val: unknown) => boolean;
+            __epPropKey: true;
+        };
+        readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
+        readonly loading: BooleanConstructor;
+        readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
+        readonly plain: BooleanConstructor;
+        readonly text: BooleanConstructor;
+        readonly link: BooleanConstructor;
+        readonly bg: BooleanConstructor;
+        readonly autofocus: BooleanConstructor;
+        readonly round: BooleanConstructor;
+        readonly circle: BooleanConstructor;
+        readonly color: StringConstructor;
+        readonly dark: BooleanConstructor;
+        readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
+    }>> & {
+        onClick?: (evt: MouseEvent) => any;
+    }, {
+        readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown>;
+        readonly link: boolean;
+        readonly dark: boolean;
+        readonly disabled: boolean;
+        readonly text: boolean;
+        readonly autofocus: boolean;
+        readonly round: boolean;
+        readonly circle: boolean;
+        readonly tag: unknown;
+        readonly loading: boolean;
+        readonly nativeType: import("element-plus").ButtonType<StringConstructor, "button" | "reset" | "submit", unknown>;
+        readonly loadingIcon: unknown;
+        readonly autoInsertSpace: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
+        readonly plain: boolean;
+        readonly bg: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>> & {
+        ButtonGroup: import("vue").DefineComponent<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: (val: unknown) => boolean;
+                __epPropKey: true;
+            };
+            readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+        }, {
+            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                    readonly required: false;
+                    readonly validator: (val: unknown) => boolean;
+                    __epPropKey: true;
+                };
+                readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+            }>> & {
+                [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
+            }>>;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+                is: {
+                    (name: string, state: boolean): string;
+                    (name: string): string;
+                };
+                cssVar: (object: Record<string, string>) => Record<string, string>;
+                cssVarName: (name: string) => string;
+                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                cssVarBlockName: (name: string) => string;
+            };
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: (val: unknown) => boolean;
+                __epPropKey: true;
+            };
+            readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown, "", boolean>;
+        }>>, {
+            readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown>;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    };
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/recorder-button/src/speech-to-text.d.ts

@@ -0,0 +1 @@
+export declare function speechToText(url: string, blob: Blob): Promise<string>;

package/components/recorder-button/src/types.d.ts

@@ -0,0 +1,6 @@
+import type { ReturnVoid } from '@vunk/shared';
+export interface SubmitRawEvent {
+    blob: Blob;
+    url: string;
+}
+export type OnTextZone = (e: SubmitRawEvent) => ReturnVoid;

package/components/sender/index.css

@@ -0,0 +1,29 @@
+.vk-sender .ant-sender-content{
+  display: grid;
+  /* 两列 auto 1fr */
+  grid-template-columns: auto 1fr;
+}
+.vk-sender .ant-sender-actions-list {
+  margin-top: 1em;
+  /* 独占两列 */
+  grid-column: 1 / -1;
+}
+.vk-sender .ant-sender-prefix {
+  /* 要素考上 */
+  align-self: start;
+}
+.vk-sender-actions{
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  width: 100%;
+}
+.vk-sender-actions__before,
+.vk-sender-actions__after {
+  display: flex;
+  align-items: center;
+}
+.vk-sender-actions__before > * + *,
+.vk-sender-actions__after > * + * {
+  margin-left: 8px;
+}

package/components/sender/index.d.ts

@@ -0,0 +1,4 @@
+import VkSender from './src/index.vue';
+export * as __VkSender from './src/types';
+export { VkSender, };
+export default VkSender;

package/components/sender/index.mjs

@@ -0,0 +1,172 @@
+import { defineComponent, ref, createVNode, resolveComponent, openBlock, createBlock, withCtx } from 'vue';
+import { useModelComputed, useDeferred } from '@vunk/core/composables';
+import { Button, Tooltip } from 'ant-design-vue';
+import { Sender, Attachments } from 'ant-design-x-vue';
+import { L as LinkOutlined, C as CloudUploadOutlined, S as SendOutlined } from '../SendOutlined.mjs';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+
+const props = {
+  /**
+   * @description v-model 绑定文本
+   */
+  modelValue: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description 是否加载中，表现在发送按钮上
+   */
+  loading: {
+    type: Boolean,
+    default: void 0
+  }
+};
+const emits = {
+  "update:modelValue": (_) => true,
+  "submit": (_) => true,
+  "cancel": null
+};
+
+var _sfc_main = /* @__PURE__ */ defineComponent({
+  name: "VkSender",
+  components: {
+    Sender,
+    LinkOutlined,
+    AntButton: Button,
+    SenderHeader: Sender.Header,
+    Attachments
+  },
+  props,
+  emits,
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const loading = useModelComputed({
+      key: "loading",
+      default: false
+    }, props2, emit);
+    const headerOpen = ref(false);
+    const actionsRender = (_, info) => {
+      const {
+        SendButton,
+        LoadingButton
+      } = info.components;
+      const loadingRender = () => {
+        return createVNode(Tooltip, {
+          "title": "\u70B9\u51FB\u53D6\u6D88"
+        }, {
+          default: () => [createVNode(LoadingButton, null, null)]
+        });
+      };
+      const sendRender = () => {
+        return createVNode(Tooltip, {
+          "title": props2.modelValue ? "\u70B9\u51FB\u53D1\u9001" : "\u8BF7\u8F93\u5165\u5185\u5BB9"
+        }, {
+          default: () => [createVNode(SendButton, {
+            "type": "text",
+            "icon": createVNode(SendOutlined, null, null)
+          }, null)]
+        });
+      };
+      const sendAction = () => loading.value ? loadingRender() : sendRender();
+      return createVNode("div", {
+        "class": "vk-sender-actions"
+      }, [createVNode("div", {
+        "class": "vk-sender-actions__before"
+      }, [slots.actions_before?.()]), createVNode("div", {
+        "class": "vk-sender-actions__after"
+      }, [slots.actions_after?.(), sendAction()])]);
+    };
+    const attachmentsPlaceholder = type => {
+      if (type === "drop") {
+        return {
+          title: "\u8BF7\u5C06\u6587\u4EF6\u62D6\u5230\u6B64\u5904"
+        };
+      } else {
+        return {
+          icon: createVNode(CloudUploadOutlined, null, null),
+          title: "\u4E0A\u4F20\u6587\u4EF6",
+          description: "\u70B9\u51FB\u4E0A\u4F20\u6216\u62D6\u62FD\u6587\u4EF6\u5230\u6B64\u5904"
+        };
+      }
+    };
+    const fileList = ref([]);
+    const attachmentsDef = useDeferred();
+    const handlePasteFile = async file => {
+      headerOpen.value = true;
+      const attachmentsNode = await attachmentsDef.promise;
+      attachmentsNode.upload(file);
+    };
+    return {
+      actionsRender,
+      headerOpen,
+      attachmentsPlaceholder,
+      handlePasteFile,
+      attachmentsResolve: attachmentsDef.resolve,
+      fileList
+    };
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_Attachments = resolveComponent("Attachments");
+  const _component_SenderHeader = resolveComponent("SenderHeader");
+  const _component_LinkOutlined = resolveComponent("LinkOutlined");
+  const _component_AntButton = resolveComponent("AntButton");
+  const _component_Sender = resolveComponent("Sender");
+  return openBlock(), createBlock(_component_Sender, {
+    class: "vk-sender",
+    value: _ctx.modelValue,
+    loading: _ctx.loading,
+    "allow-speech": true,
+    actions: _ctx.actionsRender,
+    "on-submit": (e) => _ctx.$emit("submit", e),
+    "on-cancel": () => _ctx.$emit("cancel"),
+    "onUpdate:value": _cache[2] || (_cache[2] = ($event) => _ctx.$emit("update:modelValue", $event)),
+    onPasteFile: _ctx.handlePasteFile
+  }, {
+    header: withCtx(() => [
+      createVNode(_component_SenderHeader, {
+        open: _ctx.headerOpen,
+        title: "\u6DFB\u52A0\u9644\u4EF6",
+        onOpenChange: _cache[0] || (_cache[0] = (v) => _ctx.headerOpen = v)
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_Attachments, {
+            ref: _ctx.attachmentsResolve,
+            placeholder: _ctx.attachmentsPlaceholder,
+            "file-list": _ctx.fileList
+          }, null, 8, ["placeholder", "file-list"])
+        ]),
+        _: 1
+        /* STABLE */
+      }, 8, ["open"])
+    ]),
+    prefix: withCtx(() => [
+      createVNode(_component_AntButton, {
+        type: "text",
+        onClick: _cache[1] || (_cache[1] = ($event) => _ctx.headerOpen = !_ctx.headerOpen)
+      }, {
+        icon: withCtx(() => [
+          createVNode(_component_LinkOutlined)
+        ]),
+        _: 1
+        /* STABLE */
+      })
+    ]),
+    _: 1
+    /* STABLE */
+  }, 8, ["value", "loading", "actions", "on-submit", "on-cancel", "onPasteFile"]);
+}
+var VkSender = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/sender/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkSender.install = (app) => {
+  app.component(VkSender.name || "VkSender", VkSender);
+};
+
+export { VkSender, types as __VkSender, VkSender as default };

package/components/sender/src/ctx.d.ts

@@ -0,0 +1,21 @@
+export declare const props: {
+    /**
+     * @description v-model 绑定文本
+     */
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * @description 是否加载中，表现在发送按钮上
+     */
+    loading: {
+        type: BooleanConstructor;
+        default: any;
+    };
+};
+export declare const emits: {
+    'update:modelValue': (_: string) => boolean;
+    submit: (_: string) => boolean;
+    cancel: any;
+};