@tarojs/taro-h5 3.4.0-beta.2 → 3.4.2

package/dist/api/media/recorder.js

@@ -0,0 +1,5 @@
+import { temporarilyNotSupport } from '../utils';
+// 录音
+export const stopRecord = temporarilyNotSupport('stopRecord');
+export const startRecord = temporarilyNotSupport('startRecord');
+export const getRecorderManager = temporarilyNotSupport('getRecorderManager');

package/dist/api/media/video/index.js

@@ -0,0 +1,74 @@
+import { MethodHandler } from '../../utils/handler';
+import { findDOM, shouldBeObject, temporarilyNotSupport } from '../../utils';
+// 视频
+export const saveVideoToPhotosAlbum = temporarilyNotSupport('saveVideoToPhotosAlbum');
+export const openVideoEditor = temporarilyNotSupport('openVideoEditor');
+export const getVideoInfo = temporarilyNotSupport('getVideoInfo');
+/**
+ * 创建 video 上下文 VideoContext 对象。
+ */
+export const createVideoContext = (id, inst) => {
+    const el = findDOM(inst);
+    // TODO HTMLVideoElement to VideoContext
+    return el === null || el === void 0 ? void 0 : el.querySelector(`taro-video-core[id=${id}]`);
+};
+export const compressVideo = temporarilyNotSupport('compressVideo');
+/**
+ * 拍摄视频或从手机相册中选视频。
+ */
+export const chooseVideo = (options) => {
+    // options must be an Object
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `chooseVideo:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'chooseVideo', success, fail, complete });
+    const res = {
+        tempFilePath: '',
+        duration: 0,
+        size: 0,
+        height: 0,
+        width: 0
+    };
+    const inputEl = document.createElement('input');
+    inputEl.setAttribute('type', 'file');
+    inputEl.setAttribute('multiple', 'multiple');
+    inputEl.setAttribute('accept', 'video/*');
+    inputEl.setAttribute('style', 'position: fixed; top: -4000px; left: -3000px; z-index: -300;');
+    document.body.appendChild(inputEl);
+    return new Promise(resolve => {
+        const TaroMouseEvents = document.createEvent('MouseEvents');
+        TaroMouseEvents.initEvent('click', true, true);
+        inputEl.dispatchEvent(TaroMouseEvents);
+        inputEl.onchange = function (e) {
+            var _a;
+            const target = e.target;
+            const file = (_a = target.files) === null || _a === void 0 ? void 0 : _a[0];
+            const reader = new FileReader();
+            reader.onload = function (event) {
+                var _a;
+                const videoEl = document.createElement('video');
+                const url = (_a = event.target) === null || _a === void 0 ? void 0 : _a.result;
+                videoEl.preload = 'metadata';
+                videoEl.src = url;
+                videoEl.onloadedmetadata = () => {
+                    res.tempFilePath = url;
+                    res.duration = videoEl.duration;
+                    res.size = event.total;
+                    res.height = videoEl.videoHeight;
+                    res.width = videoEl.videoHeight;
+                    return handle.success(res, resolve);
+                };
+            };
+            if (file) {
+                reader.readAsDataURL(file);
+            }
+        };
+    }).finally(() => {
+        document.body.removeChild(inputEl);
+    });
+};
+export const chooseMedia = temporarilyNotSupport('chooseMedia');

package/dist/api/media/video-decoder.js

@@ -0,0 +1,3 @@
+import { temporarilyNotSupport } from '../utils';
+// 视频解码器
+export const createVideoDecoder = temporarilyNotSupport('createVideoDecoder');

package/dist/api/media/video-processing.js

@@ -0,0 +1,3 @@
+import { temporarilyNotSupport } from '../utils';
+// 音视频合成
+export const createMediaContainer = temporarilyNotSupport('createMediaContainer');

package/dist/api/media/voip.js

@@ -0,0 +1,16 @@
+import { temporarilyNotSupport } from '../utils';
+// 实时语音
+export const updateVoIPChatMuteConfig = temporarilyNotSupport('updateVoIPChatMuteConfig');
+export const subscribeVoIPVideoMembers = temporarilyNotSupport('subscribeVoIPVideoMembers');
+export const setEnable1v1Chat = temporarilyNotSupport('setEnable1v1Chat');
+export const onVoIPVideoMembersChanged = temporarilyNotSupport('onVoIPVideoMembersChanged');
+export const onVoIPChatStateChanged = temporarilyNotSupport('onVoIPChatStateChanged');
+export const onVoIPChatSpeakersChanged = temporarilyNotSupport('onVoIPChatSpeakersChanged');
+export const onVoIPChatMembersChanged = temporarilyNotSupport('onVoIPChatMembersChanged');
+export const onVoIPChatInterrupted = temporarilyNotSupport('onVoIPChatInterrupted');
+export const offVoIPVideoMembersChanged = temporarilyNotSupport('offVoIPVideoMembersChanged');
+export const offVoIPChatStateChanged = temporarilyNotSupport('offVoIPChatStateChanged');
+export const offVoIPChatMembersChanged = temporarilyNotSupport('offVoIPChatMembersChanged');
+export const offVoIPChatInterrupted = temporarilyNotSupport('offVoIPChatInterrupted');
+export const joinVoIPChat = temporarilyNotSupport('joinVoIPChat');
+export const exitVoIPChat = temporarilyNotSupport('exitVoIPChat');

package/dist/api/navigate/index.js

@@ -0,0 +1,6 @@
+import { temporarilyNotSupport } from '../utils';
+// 跳转
+export const openEmbeddedMiniProgram = temporarilyNotSupport('openEmbeddedMiniProgram');
+export const navigateToMiniProgram = temporarilyNotSupport('navigateToMiniProgram');
+export const navigateBackMiniProgram = temporarilyNotSupport('navigateBackMiniProgram');
+export const exitMiniProgram = temporarilyNotSupport('exitMiniProgram');

package/dist/api/network/download.js

@@ -0,0 +1,124 @@
+import { CallbackManager } from '../utils/handler';
+import { NETWORK_TIMEOUT, setHeader, XHR_STATS } from './utils';
+const createDownloadTask = ({ url, header, success, error }) => {
+    let timeout;
+    const apiName = 'downloadFile';
+    const xhr = new XMLHttpRequest();
+    const callbackManager = {
+        headersReceived: new CallbackManager(),
+        progressUpdate: new CallbackManager()
+    };
+    xhr.open('GET', url, true);
+    xhr.responseType = 'blob';
+    setHeader(xhr, header);
+    xhr.onprogress = e => {
+        const { loaded, total } = e;
+        callbackManager.progressUpdate.trigger({
+            progress: Math.round(loaded / total * 100),
+            totalBytesWritten: loaded,
+            totalBytesExpectedToWrite: total
+        });
+    };
+    xhr.onreadystatechange = () => {
+        if (xhr.readyState !== XHR_STATS.HEADERS_RECEIVED)
+            return;
+        callbackManager.headersReceived.trigger({
+            header: xhr.getAllResponseHeaders()
+        });
+    };
+    xhr.onload = () => {
+        const response = xhr.response;
+        const status = xhr.status;
+        success({
+            errMsg: `${apiName}:ok`,
+            statusCode: status,
+            tempFilePath: window.URL.createObjectURL(response)
+        });
+    };
+    xhr.onabort = () => {
+        clearTimeout(timeout);
+        error({
+            errMsg: `${apiName}:fail abort`
+        });
+    };
+    xhr.onerror = (e) => {
+        error({
+            errMsg: `${apiName}:fail ${e.message}`
+        });
+    };
+    /**
+     * 中断任务
+     */
+    const abort = () => {
+        xhr.abort();
+    };
+    const send = () => {
+        xhr.send();
+        timeout = setTimeout(() => {
+            xhr.onabort = null;
+            xhr.onload = null;
+            xhr.onprogress = null;
+            xhr.onreadystatechange = null;
+            xhr.onerror = null;
+            abort();
+            error({
+                errMsg: `${apiName}:fail timeout`
+            });
+        }, NETWORK_TIMEOUT);
+    };
+    send();
+    /**
+     * 监听 HTTP Response Header 事件。会比请求完成事件更早
+     * @param {HeadersReceivedCallback} callback HTTP Response Header 事件的回调函数
+     */
+    const onHeadersReceived = callbackManager.headersReceived.add;
+    /**
+     * 取消监听 HTTP Response Header 事件
+     * @param {HeadersReceivedCallback} callback HTTP Response Header 事件的回调函数
+     */
+    const offHeadersReceived = callbackManager.headersReceived.remove;
+    /**
+     * 监听进度变化事件
+     * @param {ProgressUpdateCallback} callback HTTP Response Header 事件的回调函数
+     */
+    const onProgressUpdate = callbackManager.progressUpdate.add;
+    /**
+     * 取消监听进度变化事件
+     * @param {ProgressUpdateCallback} callback HTTP Response Header 事件的回调函数
+     */
+    const offProgressUpdate = callbackManager.progressUpdate.remove;
+    return {
+        abort,
+        onHeadersReceived,
+        offHeadersReceived,
+        onProgressUpdate,
+        offProgressUpdate
+    };
+};
+/**
+ * 下载文件资源到本地。客户端直接发起一个 HTTPS GET 请求，返回文件的本地临时路径。使用前请注意阅读相关说明。
+ * 注意：请在服务端响应的 header 中指定合理的 Content-Type 字段，以保证客户端正确处理文件类型。
+ */
+export const downloadFile = ({ url, header, success, fail, complete }) => {
+    let task;
+    const result = new Promise((resolve, reject) => {
+        task = createDownloadTask({
+            url,
+            header,
+            success: res => {
+                success && success(res);
+                complete && complete(res);
+                resolve(res);
+            },
+            error: res => {
+                fail && fail(res);
+                complete && complete(res);
+                reject(res);
+            }
+        });
+    });
+    result.headersReceive = task.onHeadersReceived;
+    result.progress = task.onProgressUpdate;
+    result.abort = task.abort;
+    return result;
+};

package/dist/api/network/index.js

@@ -0,0 +1,7 @@
+export * from './download';
+export * from './mdns';
+export * from './request';
+export * from './tcp';
+export * from './udp';
+export * from './upload';
+export * from './websocket';

package/dist/api/network/mdns.js

@@ -0,0 +1,12 @@
+import { temporarilyNotSupport } from '../utils';
+// mDNS
+export const stopLocalServiceDiscovery = temporarilyNotSupport('stopLocalServiceDiscovery');
+export const startLocalServiceDiscovery = temporarilyNotSupport('startLocalServiceDiscovery');
+export const onLocalServiceResolveFail = temporarilyNotSupport('onLocalServiceResolveFail');
+export const onLocalServiceLost = temporarilyNotSupport('onLocalServiceLost');
+export const onLocalServiceFound = temporarilyNotSupport('onLocalServiceFound');
+export const onLocalServiceDiscoveryStop = temporarilyNotSupport('onLocalServiceDiscoveryStop');
+export const offLocalServiceResolveFail = temporarilyNotSupport('offLocalServiceResolveFail');
+export const offLocalServiceLost = temporarilyNotSupport('offLocalServiceLost');
+export const offLocalServiceFound = temporarilyNotSupport('offLocalServiceFound');
+export const offLocalServiceDiscoveryStop = temporarilyNotSupport('offLocalServiceDiscoveryStop');

package/dist/api/network/request/index.js

@@ -0,0 +1,125 @@
+import Taro from '@tarojs/api';
+import 'whatwg-fetch';
+import jsonpRetry from 'jsonp-retry';
+import { serializeParams } from '../../utils';
+// @ts-ignore
+const { Link } = Taro;
+function generateRequestUrlWithParams(url, params) {
+    params = typeof params === 'string' ? params : serializeParams(params);
+    if (params) {
+        url += (~url.indexOf('?') ? '&' : '?') + params;
+    }
+    url = url.replace('?&', '?');
+    return url;
+}
+// FIXME 移除 any 标注
+function _request(options) {
+    options = options || {};
+    if (typeof options === 'string') {
+        options = {
+            url: options
+        };
+    }
+    const { success, complete, fail } = options;
+    let url = options.url;
+    const params = {};
+    const res = {};
+    if (options.jsonp) {
+        Object.assign(params, options);
+        params.params = options.data;
+        params.cache = options.jsonpCache;
+        if (typeof options.jsonp === 'string') {
+            params.name = options.jsonp;
+        }
+        delete params.jsonp;
+        return jsonpRetry(url, params)
+            .then(data => {
+            res.statusCode = 200;
+            res.data = data;
+            typeof success === 'function' && success(res);
+            typeof complete === 'function' && complete(res);
+            return res;
+        })
+            .catch(err => {
+            typeof fail === 'function' && fail(err);
+            typeof complete === 'function' && complete(res);
+            return Promise.reject(err);
+        });
+    }
+    params.method = options.method || 'GET';
+    const methodUpper = params.method.toUpperCase();
+    params.cache = options.cache || 'default';
+    if (methodUpper === 'GET' || methodUpper === 'HEAD') {
+        url = generateRequestUrlWithParams(url, options.data);
+    }
+    else if (typeof options.data === 'object') {
+        options.header = options.header || {};
+        const keyOfContentType = Object.keys(options.header).find(item => item.toLowerCase() === 'content-type');
+        if (!keyOfContentType) {
+            options.header['Content-Type'] = 'application/json';
+        }
+        const contentType = options.header[keyOfContentType || 'Content-Type'];
+        if (contentType.indexOf('application/json') >= 0) {
+            params.body = JSON.stringify(options.data);
+        }
+        else if (contentType.indexOf('application/x-www-form-urlencoded') >= 0) {
+            params.body = serializeParams(options.data);
+        }
+        else {
+            params.body = options.data;
+        }
+    }
+    else {
+        params.body = options.data;
+    }
+    if (options.header) {
+        params.headers = options.header;
+    }
+    if (options.mode) {
+        params.mode = options.mode;
+    }
+    if (options.signal) {
+        params.signal = options.signal;
+    }
+    params.credentials = options.credentials;
+    return fetch(url, params)
+        .then(response => {
+        res.statusCode = response.status;
+        res.header = {};
+        for (const key of response.headers.keys()) {
+            res.header[key] = response.headers.get(key);
+        }
+        if (!response.ok) {
+            throw response;
+        }
+        if (options.responseType === 'arraybuffer') {
+            return response.arrayBuffer();
+        }
+        if (res.statusCode !== 204) {
+            if (options.dataType === 'json' || typeof options.dataType === 'undefined') {
+                return response.json();
+            }
+        }
+        if (options.responseType === 'text' || options.dataType === 'text') {
+            return response.text();
+        }
+        return Promise.resolve(null);
+    })
+        .then(data => {
+        res.data = data;
+        typeof success === 'function' && success(res);
+        typeof complete === 'function' && complete(res);
+        return res;
+    })
+        .catch(err => {
+        typeof fail === 'function' && fail(err);
+        typeof complete === 'function' && complete(res);
+        return Promise.reject(err);
+    });
+}
+function taroInterceptor(chain) {
+    return _request(chain.requestParams);
+}
+const link = new Link(taroInterceptor);
+export const request = link.request.bind(link);
+export const addInterceptor = link.addInterceptor.bind(link);

package/dist/api/network/tcp.js

@@ -0,0 +1,3 @@
+import { temporarilyNotSupport } from '../utils';
+// TCP 通信
+export const createTCPSocket = temporarilyNotSupport('createTCPSocket');

package/dist/api/network/udp.js

@@ -0,0 +1,3 @@
+import { temporarilyNotSupport } from '../utils';
+// UDP 通信
+export const createUDPSocket = temporarilyNotSupport('createUDPSocket');

package/dist/api/network/upload.js

@@ -0,0 +1,146 @@
+import { CallbackManager } from '../utils/handler';
+import { convertObjectUrlToBlob, NETWORK_TIMEOUT, setHeader, XHR_STATS } from './utils';
+const createUploadTask = ({ url, filePath, formData = {}, name, header, timeout, fileName, success, error }) => {
+    let timeoutInter;
+    let formKey;
+    const apiName = 'uploadFile';
+    const xhr = new XMLHttpRequest();
+    const form = new FormData();
+    const callbackManager = {
+        headersReceived: new CallbackManager(),
+        progressUpdate: new CallbackManager()
+    };
+    xhr.open('POST', url);
+    setHeader(xhr, header);
+    for (formKey in formData) {
+        form.append(formKey, formData[formKey]);
+    }
+    xhr.upload.onprogress = e => {
+        const { loaded, total } = e;
+        callbackManager.progressUpdate.trigger({
+            progress: Math.round(loaded / total * 100),
+            totalBytesSent: loaded,
+            totalBytesExpectedToSent: total
+        });
+    };
+    xhr.onreadystatechange = () => {
+        if (xhr.readyState !== XHR_STATS.HEADERS_RECEIVED)
+            return;
+        callbackManager.headersReceived.trigger({
+            header: xhr.getAllResponseHeaders()
+        });
+    };
+    xhr.onload = () => {
+        const status = xhr.status;
+        clearTimeout(timeoutInter);
+        success({
+            errMsg: `${apiName}:ok`,
+            statusCode: status,
+            data: xhr.responseText || xhr.response
+        });
+    };
+    xhr.onabort = () => {
+        clearTimeout(timeoutInter);
+        error({
+            errMsg: `${apiName}:fail abort`
+        });
+    };
+    xhr.onerror = (e) => {
+        clearTimeout(timeoutInter);
+        error({
+            errMsg: `${apiName}:fail ${e.message}`
+        });
+    };
+    /**
+     * 中断任务
+     */
+    const abort = () => {
+        clearTimeout(timeoutInter);
+        xhr.abort();
+    };
+    const send = () => {
+        xhr.send(form);
+        timeoutInter = setTimeout(() => {
+            xhr.onabort = null;
+            xhr.onload = null;
+            xhr.upload.onprogress = null;
+            xhr.onreadystatechange = null;
+            xhr.onerror = null;
+            abort();
+            error({
+                errMsg: `${apiName}:fail timeout`
+            });
+        }, timeout || NETWORK_TIMEOUT);
+    };
+    convertObjectUrlToBlob(filePath)
+        .then((fileObj) => {
+        if (!fileName) {
+            fileName = typeof fileObj !== 'string' && fileObj.name;
+        }
+        form.append(name, fileObj, fileName || `file-${Date.now()}`);
+        send();
+    })
+        .catch(e => {
+        error({
+            errMsg: `${apiName}:fail ${e.message}`
+        });
+    });
+    /**
+     * 监听 HTTP Response Header 事件。会比请求完成事件更早
+     * @param {HeadersReceivedCallback} callback HTTP Response Header 事件的回调函数
+     */
+    const onHeadersReceived = callbackManager.headersReceived.add;
+    /**
+     * 取消监听 HTTP Response Header 事件
+     * @param {HeadersReceivedCallback} callback HTTP Response Header 事件的回调函数
+     */
+    const offHeadersReceived = callbackManager.headersReceived.remove;
+    /**
+     * 监听进度变化事件
+     * @param {ProgressUpdateCallback} callback HTTP Response Header 事件的回调函数
+     */
+    const onProgressUpdate = callbackManager.progressUpdate.add;
+    /**
+     * 取消监听进度变化事件
+     * @param {ProgressUpdateCallback} callback HTTP Response Header 事件的回调函数
+     */
+    const offProgressUpdate = callbackManager.progressUpdate.remove;
+    return {
+        abort,
+        onHeadersReceived,
+        offHeadersReceived,
+        onProgressUpdate,
+        offProgressUpdate
+    };
+};
+/**
+ * 将本地资源上传到服务器。客户端发起一个 HTTPS POST 请求，其中 content-type 为 multipart/form-data。使用前请注意阅读相关说明。
+ */
+export const uploadFile = ({ url, filePath, name, header, formData, timeout, fileName, success, fail, complete }) => {
+    let task;
+    const result = new Promise((resolve, reject) => {
+        task = createUploadTask({
+            url,
+            header,
+            name,
+            filePath,
+            formData,
+            timeout,
+            fileName,
+            success: res => {
+                success && success(res);
+                complete && complete(res);
+                resolve(res);
+            },
+            error: res => {
+                fail && fail(res);
+                complete && complete(res);
+                reject(res);
+            }
+        });
+    });
+    result.headersReceive = task.onHeadersReceived;
+    result.progress = task.onProgressUpdate;
+    result.abort = task.abort;
+    return result;
+};

package/dist/api/network/utils.js

@@ -0,0 +1,65 @@
+/**
+ * HTTP Response Header 事件回调函数的参数
+ * @typedef {Object} HeadersReceivedParam
+ * @property {Object} header 开发者服务器返回的 HTTP Response Header
+ */
+/**
+ * HTTP Response Header 事件的回调函数
+ * @callback HeadersReceivedCallback
+ * @param {HeadersReceivedParam} res 参数
+ */
+/**
+ * 进度变化回调函数的参数
+ * @typedef {Object} ProgressUpdateParam
+ * @property {number} progress 进度百分比
+ * @property {number} [totalBytesWritten] 已经下载的数据长度，单位 Bytes
+ * @property {number} [totalBytesSent] 已经上传的数据长度，单位 Bytes
+ * @property {number} [totalBytesExpectedToWrite] 预期需要下载的数据总长度，单位 Bytes
+ * @property {number} [totalBytesExpectedToSend] 预期需要上传的数据总长度，单位 Bytes
+ */
+/**
+ * 进度变化事件的回调函数
+ * @callback ProgressUpdateCallback
+ * @param {ProgressUpdateParam} res 参数
+ */
+export const NETWORK_TIMEOUT = 60000;
+export const XHR_STATS = {
+    UNSENT: 0,
+    OPENED: 1,
+    HEADERS_RECEIVED: 2,
+    LOADING: 3,
+    DONE: 4 // The operation is complete.
+};
+/**
+ * 设置xhr的header
+ * @param {XMLHttpRequest} xhr
+ * @param {Object} header
+ */
+export const setHeader = (xhr, header) => {
+    let headerKey;
+    for (headerKey in header) {
+        xhr.setRequestHeader(headerKey, header[headerKey]);
+    }
+};
+/**
+ * 将 blob url 转化为文件
+ * @param {string} url 要转换的 blob url
+ * @returns {Promise<File>}
+ */
+export const convertObjectUrlToBlob = url => {
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open('GET', url, true);
+        xhr.responseType = 'blob';
+        xhr.onload = function () {
+            if (this.status === 200) {
+                resolve(this.response);
+            }
+            else {
+                /* eslint-disable prefer-promise-reject-errors */
+                reject({ status: this.status });
+            }
+        };
+        xhr.send();
+    });
+};

package/dist/api/network/websocket/index.js

@@ -0,0 +1,70 @@
+import { SocketTask } from './socketTask';
+import { shouldBeObject, getParameterError } from '../../utils';
+import { MethodHandler } from '../../utils/handler';
+let socketTasks = [];
+let socketsCounter = 1;
+export function sendSocketMessage() {
+    console.warn('Deprecated.Please use socketTask.send instead.');
+}
+export function onSocketOpen() {
+    console.warn('Deprecated.Please use socketTask.onOpen instead.');
+}
+export function onSocketMessage() {
+    console.warn('Deprecated.Please use socketTask.onMessage instead.');
+}
+export function onSocketError() {
+    console.warn('Deprecated.Please use socketTask.onError instead.');
+}
+export function onSocketClose() {
+    console.warn('Deprecated.Please use socketTask.onClose instead.');
+}
+export function connectSocket(options) {
+    const name = 'connectSocket';
+    return new Promise((resolve, reject) => {
+        // options must be an Object
+        const isObject = shouldBeObject(options);
+        if (!isObject.flag) {
+            const res = { errMsg: `${name}:fail ${isObject.msg}` };
+            console.error(res.errMsg);
+            return reject(res);
+        }
+        const { url, protocols, success, fail, complete } = options;
+        const handle = new MethodHandler({ name, success, fail, complete });
+        // options.url must be String
+        if (typeof url !== 'string') {
+            return handle.fail({
+                errMsg: getParameterError({
+                    para: 'url',
+                    correct: 'String',
+                    wrong: url
+                })
+            }, reject);
+        }
+        // options.url must be invalid
+        if (!url.startsWith('ws://') && !url.startsWith('wss://')) {
+            return handle.fail({
+                errMsg: `request:fail invalid url "${url}"`
+            }, reject);
+        }
+        // protocols must be array
+        const _protocols = Array.isArray(protocols) ? protocols : null;
+        // 2 connection at most
+        if (socketTasks.length > 1) {
+            return handle.fail({
+                errMsg: '同时最多发起 2 个 socket 请求，更多请参考文档。'
+            }, reject);
+        }
+        const task = new SocketTask(url, _protocols);
+        task._destroyWhenClose = function () {
+            socketTasks = socketTasks.filter(socketTask => socketTask !== this);
+        };
+        socketTasks.push(task);
+        handle.success({
+            socketTaskId: socketsCounter++
+        });
+        return resolve(task);
+    });
+}
+export function closeSocket() {
+    console.warn('Deprecated.Please use socketTask.close instead.');
+}