vue-element-ui-x 1.1.0 → 1.1.1

package/lib/mixins/index.js

@@ -56,9 +56,9 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 ;// ./src/mixins/recordMixin.js
-/**
- * @description 提供语音识别的混入，允许语音输入并处理开始、结束、结果及错误等各种事件。
- * @mixin recordMixin
+/**
+ * @description 提供语音识别的混入，允许语音输入并处理开始、结束、结果及错误等各种事件。
+ * @mixin recordMixin
  */
 
 /* harmony default export */ const recordMixin = ({
@@ -80,13 +80,13 @@ __webpack_require__.d(__webpack_exports__, {
     };
   },
   methods: {
-    /**
-     * 初始化语音识别配置
-     * @param {Object} options - 配置选项
-     * @param {Function} [options.onError] - 错误回调
-     * @param {Function} [options.onStart] - 开始回调
-     * @param {Function} [options.onEnd] - 结束回调
-     * @param {Function} [options.onResult] - 结果回调
+    /**
+     * 初始化语音识别配置
+     * @param {Object} options - 配置选项
+     * @param {Function} [options.onError] - 错误回调
+     * @param {Function} [options.onStart] - 开始回调
+     * @param {Function} [options.onEnd] - 结束回调
+     * @param {Function} [options.onResult] - 结果回调
      */
     initRecord(options = {}) {
       this.recordOptions = {
@@ -94,8 +94,8 @@ __webpack_require__.d(__webpack_exports__, {
         ...options
       };
     },
-    /**
-     * 开始语音识别
+    /**
+     * 开始语音识别
      */
     startRecord() {
       if ('webkitSpeechRecognition' in window) {
@@ -143,16 +143,16 @@ __webpack_require__.d(__webpack_exports__, {
         }
       }
     },
-    /**
-     * 停止语音识别
+    /**
+     * 停止语音识别
      */
     stopRecord() {
       if (this.recordRecognition) {
         this.recordRecognition.stop();
       }
     },
-    /**
-     * 清理语音识别资源
+    /**
+     * 清理语音识别资源
      */
     cleanupRecord() {
       this.stopRecord();
@@ -164,8 +164,8 @@ __webpack_require__.d(__webpack_exports__, {
   }
 });
 ;// ./src/mixins/sendMixin.js
-/**
- * XRequest 类 - 用于处理 SSE 和 Fetch 请求
+/**
+ * XRequest 类 - 用于处理 SSE 和 Fetch 请求
  */
 class XRequest {
   constructor(options = {}) {
@@ -263,10 +263,10 @@ class XRequest {
       this._controller && this._controller.abort();
     });
   }
-  /**
-   * 处理缓冲区数据，提取完整的行
-   * @param {string} buffer - 缓冲区数据
-   * @returns {string} 剩余的不完整数据
+  /**
+   * 处理缓冲区数据，提取完整的行
+   * @param {string} buffer - 缓冲区数据
+   * @returns {string} 剩余的不完整数据
    */
   processBuffer(buffer) {
     const lines = buffer.split('\n');
@@ -281,9 +281,9 @@ class XRequest {
     return remainingData || '';
   }
 
-  /**
-   * 处理单行数据
-   * @param {string} line - 单行数据
+  /**
+   * 处理单行数据
+   * @param {string} line - 单行数据
    */
   processLine(line) {
     // 跳过空行
@@ -334,9 +334,9 @@ class XRequest {
     }
   }
 
-  /**
-   * 处理缓冲区中剩余的数据（在流结束时调用）
-   * @param {string} buffer - 剩余的缓冲区数据
+  /**
+   * 处理缓冲区中剩余的数据（在流结束时调用）
+   * @param {string} buffer - 剩余的缓冲区数据
    */
   processBufferData(buffer) {
     const lines = buffer.split('\n');
@@ -438,9 +438,9 @@ class XRequest {
   }
 }
 
-/**
- * sendMixin -
- * 用于处理发送操作管理请求状态的 mixin，支持可选的中止功能，同时支持 Promise 和 SSE（服务端事件）
+/**
+ * sendMixin -
+ * 用于处理发送操作管理请求状态的 mixin，支持可选的中止功能，同时支持 Promise 和 SSE（服务端事件）
  */
 const sendMixin = {
   data() {
@@ -451,13 +451,13 @@ const sendMixin = {
     };
   },
   methods: {
-    /**
-     * 初始化发送配置
-     * @param {Object} options - 配置选项
-     * @param {Function} options.onAbort - 中止回调
-     * @param {Function} options.sendHandler - 发送处理器
-     * @param {Function} options.abortHandler - 中止处理器
-     * @param {Function} options.finishHandler - 完成处理器
+    /**
+     * 初始化发送配置
+     * @param {Object} options - 配置选项
+     * @param {Function} options.onAbort - 中止回调
+     * @param {Function} options.sendHandler - 发送处理器
+     * @param {Function} options.abortHandler - 中止处理器
+     * @param {Function} options.finishHandler - 完成处理器
      */
     initSend(options = {}) {
       this._sendOptions = {
@@ -467,9 +467,9 @@ const sendMixin = {
         finishHandler: options.finishHandler
       };
     },
-    /**
-     * 发送操作
-     * @param {...any} args - 传递给 sendHandler 的参数
+    /**
+     * 发送操作
+     * @param {...any} args - 传递给 sendHandler 的参数
      */
     handleSend(...args) {
       if (this.loading) {
@@ -480,8 +480,8 @@ const sendMixin = {
       }
       this.loading = true;
     },
-    /**
-     * 中止操作
+    /**
+     * 中止操作
      */
     handleAbort() {
       this.loading = false;
@@ -492,8 +492,8 @@ const sendMixin = {
         this._sendOptions.onAbort();
       }
     },
-    /**
-     * 完成操作
+    /**
+     * 完成操作
      */
     handleFinish() {
       this.loading = false;
@@ -501,10 +501,10 @@ const sendMixin = {
         this._sendOptions.finishHandler();
       }
     },
-    /**
-     * 创建 XRequest 实例的便捷方法
-     * @param {Object} options - XRequest 配置选项
-     * @returns {XRequest} XRequest 实例
+    /**
+     * 创建 XRequest 实例的便捷方法
+     * @param {Object} options - XRequest 配置选项
+     * @returns {XRequest} XRequest 实例
      */
     createXRequest(options = {}) {
       return new XRequest({
@@ -532,10 +532,10 @@ const sendMixin = {
   }
 };
 
-/**
- * 工具函数版本 - 用于非组件场景
- * @param {Object} options - 配置选项
- * @returns {Object} 包含发送相关方法的对象
+/**
+ * 工具函数版本 - 用于非组件场景
+ * @param {Object} options - 配置选项
+ * @returns {Object} 包含发送相关方法的对象
  */
 function createSendUtils(options = {}) {
   const state = {
@@ -574,99 +574,99 @@ function createSendUtils(options = {}) {
 }
 /* harmony default export */ const mixins_sendMixin = ((/* unused pure expression or super */ null && (sendMixin)));
 ;// ./src/mixins/streamMixin.js
-/**
- * @fileoverview  流式数据处理 Mixin
- * 支持 SSE 数据解析和中断功能
+/**
+ * @fileoverview  流式数据处理 Mixin
+ * 支持 SSE 数据解析和中断功能
  */
 
-/**
- * 默认流分隔符
- * @type {string}
- * @constant
+/**
+ * 默认流分隔符
+ * @type {string}
+ * @constant
  */
 const DEFAULT_STREAM_SEPARATOR = '\n\n';
 
-/**
- * 默认部分分隔符
- * @type {string}
- * @constant
+/**
+ * 默认部分分隔符
+ * @type {string}
+ * @constant
  */
 const DEFAULT_PART_SEPARATOR = '\n';
 
-/**
- * 默认键值分隔符
- * @type {string}
- * @constant
+/**
+ * 默认键值分隔符
+ * @type {string}
+ * @constant
  */
 const DEFAULT_KV_SEPARATOR = ':';
 
-/**
- * SSE 字段类型定义
- * @typedef {'data'|'event'|'id'|'retry'} SSEFields
+/**
+ * SSE 字段类型定义
+ * @typedef {'data'|'event'|'id'|'retry'} SSEFields
  */
 
-/**
- * SSE 输出对象类型
- * @typedef {Object} SSEOutput
- * @property {string} [data] - 数据字段
- * @property {string} [event] - 事件字段
- * @property {string} [id] - ID字段
- * @property {string} [retry] - 重试字段
+/**
+ * SSE 输出对象类型
+ * @typedef {Object} SSEOutput
+ * @property {string} [data] - 数据字段
+ * @property {string} [event] - 事件字段
+ * @property {string} [id] - ID字段
+ * @property {string} [retry] - 重试字段
  */
 
-/**
- * 流配置选项
- * @typedef {Object} XStreamOptions
- * @property {ReadableStream<Uint8Array>} readableStream - 可读流
- * @property {TransformStream<string, *>} [transformStream] - 可选的转换流
+/**
+ * 流配置选项
+ * @typedef {Object} XStreamOptions
+ * @property {ReadableStream<Uint8Array>} readableStream - 可读流
+ * @property {TransformStream<string, *>} [transformStream] - 可选的转换流
  */
 
-/**
- * 流状态对象
- * @typedef {Object} StreamState
- * @property {Array<*>} data - 流数据数组
- * @property {Error|null} error - 错误信息
- * @property {boolean} loading - 加载状态
+/**
+ * 流状态对象
+ * @typedef {Object} StreamState
+ * @property {Array<*>} data - 流数据数组
+ * @property {Error|null} error - 错误信息
+ * @property {boolean} loading - 加载状态
  */
 
-/**
- * 流回调函数配置
- * @typedef {Object} StreamCallbacks
- * @property {function(*): void} [onData] - 数据回调函数
- * @property {function(Array<*>): void} [onComplete] - 完成回调函数
- * @property {function(Error): void} [onError] - 错误回调函数
- * @property {function(): void} [onCancel] - 取消回调函数
- * @property {function(): void} [onFinish] - 结束回调函数
+/**
+ * 流回调函数配置
+ * @typedef {Object} StreamCallbacks
+ * @property {function(*): void} [onData] - 数据回调函数
+ * @property {function(Array<*>): void} [onComplete] - 完成回调函数
+ * @property {function(Error): void} [onError] - 错误回调函数
+ * @property {function(): void} [onCancel] - 取消回调函数
+ * @property {function(): void} [onFinish] - 结束回调函数
  */
 
-/**
- * 流工具函数返回对象
- * @typedef {Object} StreamUtils
- * @property {StreamState} state - 流状态
- * @property {function(XStreamOptions): Promise<void>} startStream - 启动流处理
- * @property {function(): void} cancel - 取消流处理
- * @property {function(): void} reset - 重置流状态
+/**
+ * 流工具函数返回对象
+ * @typedef {Object} StreamUtils
+ * @property {StreamState} state - 流状态
+ * @property {function(XStreamOptions): Promise<void>} startStream - 启动流处理
+ * @property {function(): void} cancel - 取消流处理
+ * @property {function(): void} reset - 重置流状态
  */
 
-/**
- * 验证字符串是否有效（非空且非空白）
- * @param {string} str - 待验证的字符串
- * @returns {boolean} 是否为有效字符串
+/**
+ * 验证字符串是否有效（非空且非空白）
+ * @param {string} str - 待验证的字符串
+ * @returns {boolean} 是否为有效字符串
  */
 const isValidString = str => (str === null || str === undefined ? '' : str).trim() !== '';
 
-/**
- * 创建流分割转换器
- * 按照默认分隔符分割流数据
- * @returns {TransformStream<string, string>} 流分割转换器
+/**
+ * 创建流分割转换器
+ * 按照默认分隔符分割流数据
+ * @returns {TransformStream<string, string>} 流分割转换器
  */
 function splitStream() {
   let buffer = '';
   return new TransformStream({
-    /**
-     * 转换函数
-     * @param {string} chunk - 数据块
-     * @param {TransformStreamDefaultController<string>} controller - 控制器
+    /**
+     * 转换函数
+     * @param {string} chunk - 数据块
+     * @param {TransformStreamDefaultController<string>} controller - 控制器
      */
     transform(chunk, controller) {
       buffer += chunk;
@@ -676,9 +676,9 @@ function splitStream() {
       });
       buffer = parts[parts.length - 1];
     },
-    /**
-     * 刷新函数
-     * @param {TransformStreamDefaultController<string>} controller - 控制器
+    /**
+     * 刷新函数
+     * @param {TransformStreamDefaultController<string>} controller - 控制器
      */
     flush(controller) {
       if (isValidString(buffer)) controller.enqueue(buffer);
@@ -686,17 +686,17 @@ function splitStream() {
   });
 }
 
-/**
- * 创建 SSE 数据解析转换器
- * 将文本数据解析为 SSE 格式对象
- * @returns {TransformStream<string, SSEOutput>} SSE 解析转换器
+/**
+ * 创建 SSE 数据解析转换器
+ * 将文本数据解析为 SSE 格式对象
+ * @returns {TransformStream<string, SSEOutput>} SSE 解析转换器
  */
 function splitPart() {
   return new TransformStream({
-    /**
-     * 转换函数
-     * @param {string} partChunk - 数据块
-     * @param {TransformStreamDefaultController<SSEOutput>} controller - 控制器
+    /**
+     * 转换函数
+     * @param {string} partChunk - 数据块
+     * @param {TransformStreamDefaultController<SSEOutput>} controller - 控制器
      */
     transform(partChunk, controller) {
       const lines = partChunk.split(DEFAULT_PART_SEPARATOR);
@@ -716,14 +716,14 @@ function splitPart() {
   });
 }
 
-/**
- * 核心流处理函数（支持中断）
- * @param {XStreamOptions} options - 配置选项
- * @param {ReadableStream<Uint8Array>} options.readableStream - 可读流
- * @param {TransformStream<string, *>} [options.transformStream] - 可选的转换流
- * @param {AbortSignal} [signal] - 中断信号
- * @returns {ReadableStream<*>} 处理后的流，支持异步迭代
- * @throws {TypeError} 当 readableStream 不是 ReadableStream 实例时抛出
+/**
+ * 核心流处理函数（支持中断）
+ * @param {XStreamOptions} options - 配置选项
+ * @param {ReadableStream<Uint8Array>} options.readableStream - 可读流
+ * @param {TransformStream<string, *>} [options.transformStream] - 可选的转换流
+ * @param {AbortSignal} [signal] - 中断信号
+ * @returns {ReadableStream<*>} 处理后的流，支持异步迭代
+ * @throws {TypeError} 当 readableStream 不是 ReadableStream 实例时抛出
  */
 function XStream(options, signal) {
   const {
@@ -760,21 +760,21 @@ function XStream(options, signal) {
   return processedStream;
 }
 
-/**
- * streamMixin
- * 用于处理流式数据的 mixin，支持 SSE 数据解析和中断功能
- * @namespace streamMixin
- * @type {Object}
+/**
+ * streamMixin
+ * 用于处理流式数据的 mixin，支持 SSE 数据解析和中断功能
+ * @namespace streamMixin
+ * @type {Object}
  */
 const streamMixin = {
-  /**
-   * 组件数据
-   * @returns {Object} 响应式数据对象
-   * @property {Array<*>} streamData - 流数据数组
-   * @property {Error|null} streamError - 流错误信息
-   * @property {boolean} streamLoading - 流处理状态
-   * @property {AbortController|null} _abortController - 私有：中断控制器
-   * @property {ReadableStream|null} _currentStream - 私有：当前流引用
+  /**
+   * 组件数据
+   * @returns {Object} 响应式数据对象
+   * @property {Array<*>} streamData - 流数据数组
+   * @property {Error|null} streamError - 流错误信息
+   * @property {boolean} streamLoading - 流处理状态
+   * @property {AbortController|null} _abortController - 私有：中断控制器
+   * @property {ReadableStream|null} _currentStream - 私有：当前流引用
    */
   data() {
     return {
@@ -786,28 +786,28 @@ const streamMixin = {
     };
   },
   methods: {
-    /**
-     * 启动流式请求
-     * @async
-     * @param {XStreamOptions} options - 流配置选项
-     * @param {ReadableStream<Uint8Array>} options.readableStream - 可读流
-     * @param {TransformStream<string, *>} [options.transformStream] - 可选的转换流
-     * @returns {Promise<void>} 流处理完成的 Promise
-     * @fires streamMixin#stream-data - 收到新数据时触发
-     * @fires streamMixin#stream-complete - 流完成时触发
-     * @fires streamMixin#stream-error - 流错误时触发
-     * @fires streamMixin#stream-finish - 流处理结束时触发
-     * @example
-     * // 基础使用
-     * const response = await fetch('/api/stream')
-     * await this.startStream({ readableStream: response.body })
-     *
-     * // 使用自定义转换流
-     * const customTransform = new TransformStream({ ... })
-     * await this.startStream({
-     *   readableStream: response.body,
-     *   transformStream: customTransform
-     * })
+    /**
+     * 启动流式请求
+     * @async
+     * @param {XStreamOptions} options - 流配置选项
+     * @param {ReadableStream<Uint8Array>} options.readableStream - 可读流
+     * @param {TransformStream<string, *>} [options.transformStream] - 可选的转换流
+     * @returns {Promise<void>} 流处理完成的 Promise
+     * @fires streamMixin#stream-data - 收到新数据时触发
+     * @fires streamMixin#stream-complete - 流完成时触发
+     * @fires streamMixin#stream-error - 流错误时触发
+     * @fires streamMixin#stream-finish - 流处理结束时触发
+     * @example
+     * // 基础使用
+     * const response = await fetch('/api/stream')
+     * await this.startStream({ readableStream: response.body })
+     *
+     * // 使用自定义转换流
+     * const customTransform = new TransformStream({ ... })
+     * await this.startStream({
+     *   readableStream: response.body,
+     *   transformStream: customTransform
+     * })
      */
     async startStream(options) {
       this.streamLoading = true;
@@ -819,27 +819,27 @@ const streamMixin = {
         for await (const item of this._currentStream) {
           this.streamData.push(item);
           // 触发数据更新事件
-          /**
-           * 流数据事件
-           * @event streamMixin#stream-data
-           * @type {*} 流数据项
+          /**
+           * 流数据事件
+           * @event streamMixin#stream-data
+           * @type {*} 流数据项
            */
           this.$emit('stream-data', item);
         }
         // 流完成事件
-        /**
-         * 流完成事件
-         * @event streamMixin#stream-complete
-         * @type {Array<*>} 所有流数据
+        /**
+         * 流完成事件
+         * @event streamMixin#stream-complete
+         * @type {Array<*>} 所有流数据
          */
         this.$emit('stream-complete', this.streamData);
       } catch (err) {
         if (err instanceof Error) {
           this.streamError = err;
-          /**
-           * 流错误事件
-           * @event streamMixin#stream-error
-           * @type {Error} 错误对象
+          /**
+           * 流错误事件
+           * @event streamMixin#stream-error
+           * @type {Error} 错误对象
            */
           this.$emit('stream-error', err);
         }
@@ -847,36 +847,36 @@ const streamMixin = {
         this.streamLoading = false;
         this._currentStream = null; // 释放流引用
         this._abortController = null; // 释放控制器
-        /**
-         * 流处理结束事件
-         * @event streamMixin#stream-finish
+        /**
+         * 流处理结束事件
+         * @event streamMixin#stream-finish
          */
         this.$emit('stream-finish');
       }
     },
-    /**
-     * 中断流式请求（强制关闭流）
-     * @returns {void}
-     * @fires streamMixin#stream-cancel - 流被中断时触发
-     * @example
-     * this.cancelStream()
+    /**
+     * 中断流式请求（强制关闭流）
+     * @returns {void}
+     * @fires streamMixin#stream-cancel - 流被中断时触发
+     * @example
+     * this.cancelStream()
      */
     cancelStream() {
       if (this._abortController) {
         this._abortController.abort();
-        /**
-         * 流取消事件
-         * @event streamMixin#stream-cancel
+        /**
+         * 流取消事件
+         * @event streamMixin#stream-cancel
          */
         this.$emit('stream-cancel');
       }
     },
-    /**
-     * 重置流状态
-     * 清空所有数据和状态，但不触发事件
-     * @returns {void}
-     * @example
-     * this.resetStream()
+    /**
+     * 重置流状态
+     * 清空所有数据和状态，但不触发事件
+     * @returns {void}
+     * @example
+     * this.resetStream()
      */
     resetStream() {
       this.streamData = [];
@@ -885,14 +885,14 @@ const streamMixin = {
       this._abortController = null;
       this._currentStream = null;
     },
-    /**
-     * 创建流处理器的便捷方法
-     * @param {ReadableStream<Uint8Array>} readableStream - 可读流
-     * @param {TransformStream<string, *>} [transformStream] - 可选的转换流
-     * @returns {XStreamOptions} 流处理器配置对象
-     * @example
-     * const processor = this.createStreamProcessor(response.body)
-     * await this.startStream(processor)
+    /**
+     * 创建流处理器的便捷方法
+     * @param {ReadableStream<Uint8Array>} readableStream - 可读流
+     * @param {TransformStream<string, *>} [transformStream] - 可选的转换流
+     * @returns {XStreamOptions} 流处理器配置对象
+     * @example
+     * const processor = this.createStreamProcessor(response.body)
+     * await this.startStream(processor)
      */
     createStreamProcessor(readableStream, transformStream) {
       return {
@@ -901,10 +901,10 @@ const streamMixin = {
       };
     }
   },
-  /**
-   * 组件销毁前的生命周期钩子
-   * 自动清理流资源
-   * @returns {void}
+  /**
+   * 组件销毁前的生命周期钩子
+   * 自动清理流资源
+   * @returns {void}
    */
   beforeDestroy() {
     // 组件销毁时清理资源
@@ -912,30 +912,30 @@ const streamMixin = {
   }
 };
 
-/**
- * 工具函数版本 - 用于非组件场景
- * @param {StreamCallbacks} [callbacks={}] - 回调函数配置
- * @param {function(*): void} [callbacks.onData] - 数据回调函数
- * @param {function(Array<*>): void} [callbacks.onComplete] - 完成回调函数
- * @param {function(Error): void} [callbacks.onError] - 错误回调函数
- * @param {function(): void} [callbacks.onCancel] - 取消回调函数
- * @param {function(): void} [callbacks.onFinish] - 结束回调函数
- * @returns {StreamUtils} 包含流处理相关方法的对象
- * @example
- * // 基础使用
- * const streamUtils = createStreamUtils({
- *   onData: (item) => console.log('数据:', item),
- *   onComplete: (allData) => console.log('完成:', allData),
- *   onError: (error) => console.error('错误:', error)
- * })
- *
- * const response = await fetch('/api/stream')
- * await streamUtils.startStream({ readableStream: response.body })
+/**
+ * 工具函数版本 - 用于非组件场景
+ * @param {StreamCallbacks} [callbacks={}] - 回调函数配置
+ * @param {function(*): void} [callbacks.onData] - 数据回调函数
+ * @param {function(Array<*>): void} [callbacks.onComplete] - 完成回调函数
+ * @param {function(Error): void} [callbacks.onError] - 错误回调函数
+ * @param {function(): void} [callbacks.onCancel] - 取消回调函数
+ * @param {function(): void} [callbacks.onFinish] - 结束回调函数
+ * @returns {StreamUtils} 包含流处理相关方法的对象
+ * @example
+ * // 基础使用
+ * const streamUtils = createStreamUtils({
+ *   onData: (item) => console.log('数据:', item),
+ *   onComplete: (allData) => console.log('完成:', allData),
+ *   onError: (error) => console.error('错误:', error)
+ * })
+ *
+ * const response = await fetch('/api/stream')
+ * await streamUtils.startStream({ readableStream: response.body })
  */
 function createStreamUtils(callbacks = {}) {
-  /**
-   * 流状态对象
-   * @type {StreamState}
+  /**
+   * 流状态对象
+   * @type {StreamState}
    */
   const state = {
     data: [],
@@ -945,11 +945,11 @@ function createStreamUtils(callbacks = {}) {
   let abortController = null;
   let currentStream = null;
 
-  /**
-   * 启动流处理
-   * @async
-   * @param {XStreamOptions} options - 流配置选项
-   * @returns {Promise<void>} 流处理完成的 Promise
+  /**
+   * 启动流处理
+   * @async
+   * @param {XStreamOptions} options - 流配置选项
+   * @returns {Promise<void>} 流处理完成的 Promise
    */
   const startStream = async options => {
     state.loading = true;
@@ -984,9 +984,9 @@ function createStreamUtils(callbacks = {}) {
     }
   };
 
-  /**
-   * 取消流处理
-   * @returns {void}
+  /**
+   * 取消流处理
+   * @returns {void}
    */
   const cancel = () => {
     if (abortController) {
@@ -997,9 +997,9 @@ function createStreamUtils(callbacks = {}) {
     }
   };
 
-  /**
-   * 重置流状态
-   * @returns {void}
+  /**
+   * 重置流状态
+   * @returns {void}
    */
   const reset = () => {
     state.data = [];
@@ -1019,14 +1019,14 @@ function createStreamUtils(callbacks = {}) {
 // 导出常量和工具函数
 
 
-/**
- * 默认导出 streamMixin
- * @type {Object}
+/**
+ * 默认导出 streamMixin
+ * @type {Object}
  */
 /* harmony default export */ const mixins_streamMixin = ((/* unused pure expression or super */ null && (streamMixin)));
 ;// ./src/mixins/index.js
-/**
- * Mixins 入口文件
+/**
+ * Mixins 入口文件
  */