@tarojs/taro 3.3.10 → 3.3.14

package/types/api/network/upload.d.ts

@@ -1,4 +1,6 @@
-declare namespace Taro {
+import Taro from '../../index'
+
+declare module '../../index' {
   namespace uploadFile {
     interface Option {
       /** 开发者服务器地址 */
@@ -8,9 +10,9 @@ declare namespace Taro {
       /** 文件对应的 key，开发者在服务端可以通过这个 key 获取文件的二进制内容 */
       name: string
       /** HTTP 请求 Header，Header 中不能设置 Referer */
-      header?: General.IAnyObject
+      header?: TaroGeneral.IAnyObject
       /** HTTP 请求中其他额外的 form data */
-      formData?: General.IAnyObject
+      formData?: TaroGeneral.IAnyObject
       /** 超时时间，单位为毫秒 */
       timeout?: number
       /** 上传的文件名
@@ -18,15 +20,15 @@ declare namespace Taro {
        */
       fileName?: string
       /** 接口调用结束的回调函数（调用成功、失败都会执行） */
-      complete?: (res: General.CallbackResult) => void
+      complete?: (res: TaroGeneral.CallbackResult) => void
       /** 接口调用失败的回调函数 */
-      fail?: (res: General.CallbackResult) => void
+      fail?: (res: TaroGeneral.CallbackResult) => void
       /** 接口调用成功的回调函数 */
       success?: (
         result: SuccessCallbackResult,
       ) => void
     }
-    interface SuccessCallbackResult extends General.CallbackResult {
+    interface SuccessCallbackResult extends TaroGeneral.CallbackResult {
       /** 开发者服务器返回的数据 */
       data: string
       /** 开发者服务器返回的 HTTP 状态码 */
@@ -39,11 +41,11 @@ declare namespace Taro {
   namespace UploadTask {
     /** HTTP Response Header 事件的回调函数 */
     type OffHeadersReceivedCallback = (
-      res: General.CallbackResult,
+      res: TaroGeneral.CallbackResult,
     ) => void
     /** 上传进度变化事件的回调函数 */
     type OffProgressUpdateCallback = (
-      res: General.CallbackResult,
+      res: TaroGeneral.CallbackResult,
     ) => void
     /** HTTP Response Header 事件的回调函数 */
     type OnHeadersReceivedCallback = (
@@ -55,7 +57,7 @@ declare namespace Taro {
     ) => void
     interface OnHeadersReceivedCallbackResult {
       /** 开发者服务器返回的 HTTP Response Header */
-      header: General.IAnyObject
+      header: TaroGeneral.IAnyObject
     }
     interface OnProgressUpdateCallbackResult {
       /** 上传进度百分比 */
@@ -67,53 +69,6 @@ declare namespace Taro {
     }
   }
 
-  /** 将本地资源上传到服务器。客户端发起一个 HTTPS POST 请求，其中 `content-type` 为 `multipart/form-data`。使用前请注意阅读[相关说明](https://developers.weixin.qq.com/miniprogram/dev/framework/ability/network.html)。
-   * @supported weapp, swan, alipay, h5
-   * @example
-   * ```tsx
-   * Taro.chooseImage({
-   *   success (res) {
-   *     const tempFilePaths = res.tempFilePaths
-   *     Taro.uploadFile({
-   *       url: 'https://example.weixin.qq.com/upload', //仅为示例，非真实的接口地址
-   *       filePath: tempFilePaths[0],
-   *       name: 'file',
-   *       formData: {
-   *         'user': 'test'
-   *       },
-   *       success (res){
-   *         const data = res.data
-   *         //do something
-   *       }
-   *     })
-   *   }
-   * })
-   * ```
-   * @example
-   * ```tsx
-   * const uploadTask = Taro.uploadFile({
-   *   url: 'http://example.weixin.qq.com/upload', //仅为示例，非真实的接口地址
-   *   filePath: tempFilePaths[0],
-   *   name: 'file',
-   *   formData:{
-   *     'user': 'test'
-   *   },
-   *   success: function (res){
-   *     var data = res.data
-   *     //do something
-   *   }
-   * })
-   * uploadTask.progress((res) => {
-   *   console.log('上传进度', res.progress)
-   *   console.log('已经上传的数据长度', res.totalBytesSent)
-   *   console.log('预期需要上传的数据总长度', res.totalBytesExpectedToSend)
-   * })
-   * uploadTask.abort() // 取消上传任务
-   * ```
-   * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/upload/wx.uploadFile.html
-   */
-  function uploadFile(option: uploadFile.Option): Promise<uploadFile.SuccessCallbackResult & UploadTask> & UploadTask
-
   /** 一个可以监听上传进度变化事件，以及取消上传任务的对象
    * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/upload/UploadTask.html
    */
@@ -164,4 +119,53 @@ declare namespace Taro {
       callback: UploadTask.OnProgressUpdateCallback,
     ): void
   }
+
+  interface TaroStatic {
+    /** 将本地资源上传到服务器。客户端发起一个 HTTPS POST 请求，其中 `content-type` 为 `multipart/form-data`。使用前请注意阅读[相关说明](https://developers.weixin.qq.com/miniprogram/dev/framework/ability/network.html)。
+     * @supported weapp, swan, alipay, h5
+     * @example
+     * ```tsx
+     * Taro.chooseImage({
+     *   success (res) {
+     *     const tempFilePaths = res.tempFilePaths
+     *     Taro.uploadFile({
+     *       url: 'https://example.weixin.qq.com/upload', //仅为示例，非真实的接口地址
+     *       filePath: tempFilePaths[0],
+     *       name: 'file',
+     *       formData: {
+     *         'user': 'test'
+     *       },
+     *       success (res){
+     *         const data = res.data
+     *         //do something
+     *       }
+     *     })
+     *   }
+     * })
+     * ```
+     * @example
+     * ```tsx
+     * const uploadTask = Taro.uploadFile({
+     *   url: 'http://example.weixin.qq.com/upload', //仅为示例，非真实的接口地址
+     *   filePath: tempFilePaths[0],
+     *   name: 'file',
+     *   formData:{
+     *     'user': 'test'
+     *   },
+     *   success: function (res){
+     *     var data = res.data
+     *     //do something
+     *   }
+     * })
+     * uploadTask.progress((res) => {
+     *   console.log('上传进度', res.progress)
+     *   console.log('已经上传的数据长度', res.totalBytesSent)
+     *   console.log('预期需要上传的数据总长度', res.totalBytesExpectedToSend)
+     * })
+     * uploadTask.abort() // 取消上传任务
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/upload/wx.uploadFile.html
+     */
+    uploadFile(option: uploadFile.Option): Promise<uploadFile.SuccessCallbackResult & UploadTask> & UploadTask
+  }
 }

package/types/api/network/websocket.d.ts

@@ -1,72 +1,27 @@
-declare namespace Taro {
+import Taro from '../../index'
+
+declare module '../../index' {
   namespace sendSocketMessage {
     interface Option {
       /** 需要发送的内容 */
       data: string | ArrayBuffer
       /** 接口调用结束的回调函数（调用成功、失败都会执行） */
-      complete?: (res: General.CallbackResult) => void
+      complete?: (res: TaroGeneral.CallbackResult) => void
       /** 接口调用失败的回调函数 */
-      fail?: (res: General.CallbackResult) => void
+      fail?: (res: TaroGeneral.CallbackResult) => void
       /** 接口调用成功的回调函数 */
-      success?: (res: General.CallbackResult) => void
+      success?: (res: TaroGeneral.CallbackResult) => void
     }
   }
 
-  /** 通过 WebSocket 连接发送数据。需要先 Taro.connectSocket，并在 Taro.onSocketOpen 回调之后才能发送。
-   * @supported weapp, alipay, swan
-   * @example
-   * ```tsx
-   * let socketOpen = false
-   * const socketMsgQueue = []
-   * Taro.connectSocket({
-   *   url: 'test.php'
-   * })
-   * Taro.onSocketOpen(function(res) {
-   *   socketOpen = true
-   *   for (let i = 0; i < socketMsgQueue.length; i++){
-   *     sendSocketMessage(socketMsgQueue[i])
-   *   }
-   *   socketMsgQueue = []
-   * })
-   * function sendSocketMessage(msg) {
-   *   if (socketOpen) {
-   *     Taro.sendSocketMessage({
-   *       data:msg
-   *     })
-   *   } else {
-   *     socketMsgQueue.push(msg)
-   *   }
-   * }
-   * ```
-   @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.sendSocketMessage.html
-   */
-  function sendSocketMessage(option: sendSocketMessage.Option): Promise<General.CallbackResult>
-
   namespace onSocketOpen {
     /** WebSocket 连接打开事件的回调函数 */
     type Callback = (result: OpenCallbackResult) => void
     interface OpenCallbackResult {
       /** 连接成功的 HTTP 响应 Header */
-      header: General.IAnyObject
+      header: TaroGeneral.IAnyObject
     }
   }
-  /** 监听 WebSocket 连接打开事件
-   * @supported weapp, alipay, swan
-   * @example
-   * ```tsx
-   * Taro.connectSocket({
-   *   url: 'test.php'
-   * })
-   * Taro.onSocketOpen(function (res) {
-   *   console.log('WebSocket连接已打开！')
-   * })
-   * ```
-   * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.onSocketOpen.html
-   */
-  function onSocketOpen(
-    /** WebSocket 连接打开事件的回调函数 */
-    callback: onSocketOpen.Callback
-  ): void
 
   namespace onSocketMessage {
     /** WebSocket 接受到服务器的消息事件的回调函数 */
@@ -77,52 +32,14 @@ declare namespace Taro {
     }
   }
 
-  /** 监听 WebSocket 接受到服务器的消息事件
-   * @supported weapp, alipay, swan
-   * @example
-   * ```tsx
-   * Taro.connectSocket({
-   *   url: 'test.php'
-   * })
-   * Taro.onSocketMessage(function (res) {
-   *   console.log('收到服务器内容：' + res.data)
-   * })
-   * ```
-   * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.onSocketMessage.html
-   */
-  function onSocketMessage<T = any>(
-    /** WebSocket 接受到服务器的消息事件的回调函数 */
-    callback: onSocketMessage.Callback<T>
-  ): void
-
   namespace onSocketError {
     /** WebSocket 错误事件的回调函数 */
     type Callback = (result: CallbackResult) => void
-    interface CallbackResult extends General.CallbackResult {
+    interface CallbackResult extends TaroGeneral.CallbackResult {
       /** 错误信息 */
       errMsg: string
     }
   }
-  /** 监听 WebSocket 错误事件
-   * @supported weapp, alipay, swan
-   * @example
-   * ```tsx
-   * Taro.connectSocket({
-   *   url: 'test.php'
-   * })
-   * Taro.onSocketOpen(function (res){
-   *   console.log('WebSocket连接已打开！')
-   * })
-   * Taro.onSocketError(function (res){
-   *   console.log('WebSocket连接打开失败，请检查！')
-   * })
-   * ```
-   * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.onSocketError.html
-   */
-  function onSocketError(
-    /** WebSocket 错误事件的回调函数 */
-    callback: (result: onSocketError.Callback) => void
-  ): void
 
   namespace onSocketClose {
     /** WebSocket 连接关闭事件的回调函数 */
@@ -134,141 +51,53 @@ declare namespace Taro {
       reason: string
     }
   }
-  /** 监听 WebSocket 连接关闭事件
-   * @supported weapp, alipay, swan
-   * @example
-   * ```tsx
-   * Taro.connectSocket({
-   *   url: 'test.php'
-   * })
-   * //注意这里有时序问题，
-   * //如果 Taro.connectSocket 还没回调 Taro.onSocketOpen，而先调用 Taro.closeSocket，那么就做不到关闭 WebSocket 的目的。
-   * //必须在 WebSocket 打开期间调用 Taro.closeSocket 才能关闭。
-   * Taro.onSocketOpen(function () {
-   *   Taro.closeSocket()
-   * })
-   * Taro.onSocketClose(function (res) {
-   *   console.log('WebSocket 已关闭！')
-   * })
-   * ```
-   * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.onSocketClose.html
-   */
-  function onSocketClose(
-    /** WebSocket 连接关闭事件的回调函数 */
-    callback: onSocketClose.Callback
-  ): void
 
   namespace connectSocket {
     interface Option {
       /** 开发者服务器 wss 接口地址 */
       url: string
       /** 接口调用结束的回调函数（调用成功、失败都会执行） */
-      complete?: (res: General.CallbackResult) => void
+      complete?: (res: TaroGeneral.CallbackResult) => void
       /** 接口调用失败的回调函数 */
-      fail?: (res: General.CallbackResult) => void
+      fail?: (res: TaroGeneral.CallbackResult) => void
       /** HTTP Header，Header 中不能设置 Referer */
-      header?: General.IAnyObject
+      header?: TaroGeneral.IAnyObject
       /** 子协议数组 */
       protocols?: string[]
       /** 接口调用成功的回调函数 */
-      success?: (res: General.CallbackResult) => void
+      success?: (res: TaroGeneral.CallbackResult) => void
       /** 建立 TCP 连接的时候的 TCP_NODELAY 设置 */
       tcpNoDelay?: boolean
     }
   }
 
-  /** 创建一个 WebSocket 连接。使用前请注意阅读[相关说明](https://developers.weixin.qq.com/miniprogram/dev/framework/ability/network.html)。
-   *
-   * **并发数**
-   * - 1.7.0 及以上版本，最多可以同时存在 5 个 WebSocket 连接。
-   * - 1.7.0 以下版本，一个小程序同时只能有一个 WebSocket 连接，如果当前已存在一个 WebSocket 连接，会自动关闭该连接，并重新创建一个 WebSocket 连接。
-   * @supported weapp, h5, rn, alipay, swan
-   * @example
-   * ```tsx
-   * Taro.connectSocket({
-   *   url: 'wss://example.qq.com',
-   *   header:{
-   *     'content-type': 'application/json'
-   *   },
-   *   protocols: ['protocol1']
-   * })
-   * ```
-   * @example
-   * ```tsx
-   * Taro.connectSocket({
-   *   url: 'ws://echo.websocket.org/echo',
-   *   success: function () {
-   *     console.log('connect success')
-   *   }
-   * }).then(task => {
-   *   task.onOpen(function () {
-   *     console.log('onOpen')
-   *     task.send({ data: 'xxx' })
-   *   })
-   *   task.onMessage(function (msg) {
-   *     console.log('onMessage: ', msg)
-   *     task.close()
-   *   })
-   *   task.onError(function () {
-   *     console.log('onError')
-   *   })
-   *   task.onClose(function (e) {
-   *     console.log('onClose: ', e)
-   *   })
-   * })
-   * ```
-   * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.connectSocket.html
-   */
-  function connectSocket(option: connectSocket.Option): Promise<SocketTask>
-
   namespace closeSocket {
     interface Option {
       /** 一个数字值表示关闭连接的状态号，表示连接被关闭的原因。 */
       code?: number
       /** 接口调用结束的回调函数（调用成功、失败都会执行） */
-      complete?: (res: General.CallbackResult) => void
+      complete?: (res: TaroGeneral.CallbackResult) => void
       /** 接口调用失败的回调函数 */
-      fail?: (res: General.CallbackResult) => void
+      fail?: (res: TaroGeneral.CallbackResult) => void
       /** 一个可读的字符串，表示连接被关闭的原因。这个字符串必须是不长于 123 字节的 UTF-8 文本（不是字符）。 */
       reason?: string
       /** 接口调用成功的回调函数 */
-      success?: (res: General.CallbackResult) => void
+      success?: (res: TaroGeneral.CallbackResult) => void
     }
   }
 
-  /** 关闭 WebSocket 连接
-   * @supported weapp, alipay, swan
-   * @example
-   * ```tsx
-   * Taro.connectSocket({
-   *   url: 'test.php'
-   * })
-   * //注意这里有时序问题，
-   * //如果 Taro.connectSocket 还没回调 Taro.onSocketOpen，而先调用 Taro.closeSocket，那么就做不到关闭 WebSocket 的目的。
-   * //必须在 WebSocket 打开期间调用 Taro.closeSocket 才能关闭。
-   * Taro.onSocketOpen(function() {
-   *   Taro.closeSocket()
-   * })
-   * Taro.onSocketClose(function(res) {
-   *   console.log('WebSocket 已关闭！')
-   * })
-   * ```
-   * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.closeSocket.html
-   */
-  function closeSocket(option?: closeSocket.Option): Promise<General.CallbackResult>
-
   namespace SocketTask {
     interface CloseOption {
       /** 一个数字值表示关闭连接的状态号，表示连接被关闭的原因。 */
       code?: number
       /** 接口调用结束的回调函数（调用成功、失败都会执行） */
-      complete?: (res: General.CallbackResult) => void
+      complete?: (res: TaroGeneral.CallbackResult) => void
       /** 接口调用失败的回调函数 */
-      fail?: (res: General.CallbackResult) => void
+      fail?: (res: TaroGeneral.CallbackResult) => void
       /** 一个可读的字符串，表示连接被关闭的原因。这个字符串必须是不长于 123 字节的 UTF-8 文本（不是字符）。 */
       reason?: string
       /** 接口调用成功的回调函数 */
-      success?: (res: General.CallbackResult) => void
+      success?: (res: TaroGeneral.CallbackResult) => void
     }
     /** WebSocket 连接关闭事件的回调函数 */
     type OnCloseCallback = (result: OnCloseCallbackResult) => void
@@ -280,7 +109,7 @@ declare namespace Taro {
     }
     /** WebSocket 错误事件的回调函数 */
     type OnErrorCallback = (result: OnErrorCallbackResult) => void
-    interface OnErrorCallbackResult extends General.CallbackResult {
+    interface OnErrorCallbackResult extends TaroGeneral.CallbackResult {
       /** 错误信息 */
       errMsg: string
     }
@@ -294,17 +123,17 @@ declare namespace Taro {
     type OnOpenCallback = (result: OnOpenCallbackResult) => void
     interface OnOpenCallbackResult {
       /** 连接成功的 HTTP 响应 Header*/
-      header: General.IAnyObject
+      header: TaroGeneral.IAnyObject
     }
     interface SendOption {
       /** 需要发送的内容 */
       data: string | ArrayBuffer
       /** 接口调用结束的回调函数（调用成功、失败都会执行） */
-      complete?: (res: General.CallbackResult) => void
+      complete?: (res: TaroGeneral.CallbackResult) => void
       /** 接口调用失败的回调函数 */
-      fail?: (res: General.CallbackResult) => void
+      fail?: (res: TaroGeneral.CallbackResult) => void
       /** 接口调用成功的回调函数 */
-      success?: (res: General.CallbackResult) => void
+      success?: (res: TaroGeneral.CallbackResult) => void
     }
   }
 
@@ -372,4 +201,182 @@ declare namespace Taro {
     /** 浏览器 websocket 实例。（h5 端独有） */
     readonly ws: WebSocket
   }
+
+  interface TaroStatic {
+    /** 通过 WebSocket 连接发送数据。需要先 Taro.connectSocket，并在 Taro.onSocketOpen 回调之后才能发送。
+     * @supported weapp, alipay, swan
+     * @example
+     * ```tsx
+     * let socketOpen = false
+     * const socketMsgQueue = []
+     * Taro.connectSocket({
+     *   url: 'test.php'
+     * })
+     * Taro.onSocketOpen(function(res) {
+     *   socketOpen = true
+     *   for (let i = 0; i < socketMsgQueue.length; i++){
+     *     sendSocketMessage(socketMsgQueue[i])
+     *   }
+     *   socketMsgQueue = []
+     * })
+     * function sendSocketMessage(msg) {
+     *   if (socketOpen) {
+     *     Taro.sendSocketMessage({
+     *       data:msg
+     *     })
+     *   } else {
+     *     socketMsgQueue.push(msg)
+     *   }
+     * }
+     * ```
+     @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.sendSocketMessage.html
+     */
+    sendSocketMessage(option: sendSocketMessage.Option): Promise<TaroGeneral.CallbackResult>
+
+    /** 监听 WebSocket 连接打开事件
+     * @supported weapp, alipay, swan
+     * @example
+     * ```tsx
+     * Taro.connectSocket({
+     *   url: 'test.php'
+     * })
+     * Taro.onSocketOpen(function (res) {
+     *   console.log('WebSocket连接已打开！')
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.onSocketOpen.html
+     */
+    onSocketOpen(
+      /** WebSocket 连接打开事件的回调函数 */
+      callback: onSocketOpen.Callback
+    ): void
+
+    /** 监听 WebSocket 接受到服务器的消息事件
+     * @supported weapp, alipay, swan
+     * @example
+     * ```tsx
+     * Taro.connectSocket({
+     *   url: 'test.php'
+     * })
+     * Taro.onSocketMessage(function (res) {
+     *   console.log('收到服务器内容：' + res.data)
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.onSocketMessage.html
+     */
+    onSocketMessage<T = any>(
+      /** WebSocket 接受到服务器的消息事件的回调函数 */
+      callback: onSocketMessage.Callback<T>
+    ): void
+
+    /** 监听 WebSocket 错误事件
+     * @supported weapp, alipay, swan
+     * @example
+     * ```tsx
+     * Taro.connectSocket({
+     *   url: 'test.php'
+     * })
+     * Taro.onSocketOpen(function (res){
+     *   console.log('WebSocket连接已打开！')
+     * })
+     * Taro.onSocketError(function (res){
+     *   console.log('WebSocket连接打开失败，请检查！')
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.onSocketError.html
+     */
+    onSocketError(
+      /** WebSocket 错误事件的回调函数 */
+      callback: (result: onSocketError.Callback) => void
+    ): void
+
+    /** 监听 WebSocket 连接关闭事件
+     * @supported weapp, alipay, swan
+     * @example
+     * ```tsx
+     * Taro.connectSocket({
+     *   url: 'test.php'
+     * })
+     * //注意这里有时序问题，
+     * //如果 Taro.connectSocket 还没回调 Taro.onSocketOpen，而先调用 Taro.closeSocket，那么就做不到关闭 WebSocket 的目的。
+     * //必须在 WebSocket 打开期间调用 Taro.closeSocket 才能关闭。
+     * Taro.onSocketOpen(function () {
+     *   Taro.closeSocket()
+     * })
+     * Taro.onSocketClose(function (res) {
+     *   console.log('WebSocket 已关闭！')
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.onSocketClose.html
+     */
+    onSocketClose(
+      /** WebSocket 连接关闭事件的回调函数 */
+      callback: onSocketClose.Callback
+    ): void
+
+    /** 创建一个 WebSocket 连接。使用前请注意阅读[相关说明](https://developers.weixin.qq.com/miniprogram/dev/framework/ability/network.html)。
+     *
+     * **并发数**
+     * - 1.7.0 及以上版本，最多可以同时存在 5 个 WebSocket 连接。
+     * - 1.7.0 以下版本，一个小程序同时只能有一个 WebSocket 连接，如果当前已存在一个 WebSocket 连接，会自动关闭该连接，并重新创建一个 WebSocket 连接。
+     * @supported weapp, h5, rn, alipay, swan
+     * @example
+     * ```tsx
+     * Taro.connectSocket({
+     *   url: 'wss://example.qq.com',
+     *   header:{
+     *     'content-type': 'application/json'
+     *   },
+     *   protocols: ['protocol1']
+     * })
+     * ```
+     * @example
+     * ```tsx
+     * Taro.connectSocket({
+     *   url: 'ws://echo.websocket.org/echo',
+     *   success: function () {
+     *     console.log('connect success')
+     *   }
+     * }).then(task => {
+     *   task.onOpen(function () {
+     *     console.log('onOpen')
+     *     task.send({ data: 'xxx' })
+     *   })
+     *   task.onMessage(function (msg) {
+     *     console.log('onMessage: ', msg)
+     *     task.close()
+     *   })
+     *   task.onError(function () {
+     *     console.log('onError')
+     *   })
+     *   task.onClose(function (e) {
+     *     console.log('onClose: ', e)
+     *   })
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.connectSocket.html
+     */
+    connectSocket(option: connectSocket.Option): Promise<SocketTask>
+
+    /** 关闭 WebSocket 连接
+     * @supported weapp, alipay, swan
+     * @example
+     * ```tsx
+     * Taro.connectSocket({
+     *   url: 'test.php'
+     * })
+     * //注意这里有时序问题，
+     * //如果 Taro.connectSocket 还没回调 Taro.onSocketOpen，而先调用 Taro.closeSocket，那么就做不到关闭 WebSocket 的目的。
+     * //必须在 WebSocket 打开期间调用 Taro.closeSocket 才能关闭。
+     * Taro.onSocketOpen(function() {
+     *   Taro.closeSocket()
+     * })
+     * Taro.onSocketClose(function(res) {
+     *   console.log('WebSocket 已关闭！')
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/network/websocket/wx.closeSocket.html
+     */
+    closeSocket(option?: closeSocket.Option): Promise<TaroGeneral.CallbackResult>
+  }
 }