@mpxjs/api-proxy 2.9.69 → 2.9.70-alpha.0

package/src/platform/api/modal/tenonModal.js

@@ -0,0 +1,154 @@
+import { ToPromise, successHandle } from '../../../common/js'
+import '../../../common/stylus/Modal.styl'
+import { getClassStyle } from '@hummer/tenon-vue'
+
+// 汉字为两个字符，字母/数字为一个字符
+const _getLength = t => {
+  let len = 0
+  for (let i = 0; i < t.length; i++) {
+    if (t.charCodeAt(i) > 127 || t.charCodeAt(i) === 94) {
+      len += 2
+    } else {
+      len++
+    }
+  }
+  return len
+}
+function createDom (Element, attrs = {}, children = []) {
+  const dom = new Element()
+  Object.keys(attrs).forEach(k => Reflect.set(dom, k, attrs[k]))
+  children.length && children.forEach(child => dom.appendChild(child))
+  return dom
+}
+export default class Modal extends ToPromise {
+  constructor () {
+    super()
+    this.defaultOpts = {
+      title: '',
+      content: '',
+      showCancel: true,
+      cancelText: '取消',
+      cancelColor: '#000000',
+      confirmText: '确定',
+      confirmColor: '#576B95',
+      success: (...args) => {},
+      fail: (...args) => {},
+      complete: (...args) => {}
+    }
+    this.hideTimer = null
+  }
+
+  show (options = {}) {
+    if (options.confirmText && _getLength(options.confirmText) > 8) {
+      // eslint-disable-next-line
+      return Promise.reject({
+        errMsg:
+          'showModal:fail confirmText length should not larger than 4 Chinese characters'
+      })
+    }
+    if (options.cancelText && _getLength(options.cancelText) > 8) {
+      // eslint-disable-next-line
+      return Promise.reject({
+        errMsg:
+          'showModal:fail cancelText length should not larger than 4 Chinese characters'
+      })
+    }
+    if (this.hideTimer) {
+      clearTimeout(this.hideTimer)
+      this.hideTimer = null
+    }
+
+    this.box = createDom(
+      View,
+      { style: getClassStyle(null, '__mpx_modal_box__') },
+      [
+        createDom(
+          View,
+          { style: getClassStyle(null, '__mpx_modal_title_view__') },
+          [
+            (this.title = createDom(Text, {
+              style: getClassStyle(null, '__mpx_modal_title__')
+            }))
+          ]
+        ),
+        createDom(
+          View,
+          { style: getClassStyle(null, '__mpx_modal_content_view__') },
+          [
+            (this.content = createDom(Text, {
+              style: getClassStyle(null, '__mpx_modal_content__')
+            }))
+          ]
+        ),
+        (this.btns = createDom(
+          View,
+          { style: getClassStyle(null, '__mpx_modal_btns__') },
+          [
+            (this.cancelBtn = createDom(Text, {
+              style: getClassStyle(null, '__mpx_modal_cancel__')
+            })),
+            (this.confirmBtn = createDom(Text, {
+              style: getClassStyle(null, '__mpx_modal_confirm__')
+            }))
+          ]
+        ))
+      ]
+    )
+
+    const opts = Object.assign({}, this.defaultOpts, options)
+    this.title.text = opts.title
+    this.content.text = opts.content
+    this.dialog = new Dialog()
+    this.dialog.cancelable = false
+    this.cancelBtn.text = opts.cancelText
+    this.confirmBtn.text = opts.confirmText
+    this.confirmBtn.style = Object.assign(this.confirmBtn.style, { color: opts.confirmColor })
+    if (opts.showCancel !== true) {
+      this.cancelBtn.style = Object.assign(
+        this.cancelBtn.style,
+        getClassStyle(null, '__mpx_modal_hide__')
+      )
+    } else {
+      this.cancelBtn.style = Object.assign(
+        this.cancelBtn.style,
+        { color: opts.cancelColor }
+      )
+    }
+
+    this.cancelBtn.addEventListener('tap', event => {
+      this.hide()
+      const result = {
+        errMsg: 'showModal:ok',
+        cancel: true,
+        confirm: false
+      }
+      successHandle(result, opts.success, opts.complete)
+      this.toPromiseResolve(result)
+    })
+
+    this.confirmBtn.addEventListener('tap', event => {
+      this.hide()
+      const result = {
+        errMsg: 'showModal:ok',
+        cancel: false,
+        confirm: true
+      }
+      successHandle(result, opts.success, opts.complete)
+      this.toPromiseResolve(result)
+    })
+
+    this.dialog.custom(this.box)
+    return this.toPromiseInitPromise()
+  }
+
+  hide () {
+    if (this.hideTimer) {
+      clearTimeout(this.hideTimer)
+      this.hideTimer = null
+    }
+
+    this.hideTimer = setTimeout(() => {
+      this.dialog.dismiss()
+    }, 0)
+  }
+}

package/src/platform/api/next-tick/index.tenon.js

@@ -0,0 +1,11 @@
+function nextTick (cb) {
+  if (typeof Promise !== 'undefined') {
+    Promise.resolve().then(cb)
+  } else {
+    setTimeout(cb, 0)
+  }
+}
+
+export {
+  nextTick
+}

package/src/platform/api/request/index.tenon.js

@@ -0,0 +1,85 @@
+import { successHandle, failHandle } from '../../../common/js'
+import { buildQueryStringUrl, parseHeader, tryJsonParse } from './tenonUtil'
+const { Request } = __GLOBAL__
+const requestFn = new Request()
+
+function request (options = {}) {
+  let {
+    data = {},
+    method = 'GET',
+    dataType = 'form',
+    responseType = 'json',
+    timeout = 60 * 1000,
+    header = {},
+    success = null,
+    fail = null,
+    complete = null,
+    url = ''
+  } = options
+
+  method = method.toUpperCase()
+
+  if (['GET', 'PUT', 'DELETE'].indexOf(method) > -1) {
+    url = buildQueryStringUrl(data, url)
+
+    if (method === 'GET') {
+      data = {}
+    }
+  }
+
+  switch (dataType) {
+    case 'form':
+      header = {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        ...header
+      }
+      break
+
+    case 'json':
+      header = {
+        'Content-Type': 'application/json',
+        ...header
+      }
+      break
+  }
+
+  requestFn.url = url
+  requestFn.method = method
+  requestFn.timeout = timeout
+  requestFn.param = data
+  requestFn.header = header
+
+  return new Promise((resolve, reject) => {
+    requestFn.send((response) => {
+      let { status, header: resHeader, data: resData, error } = response
+      // 返回的数据处理
+      if (status >= 200 && status < 300) {
+        if (responseType === 'json' && typeof resData === 'string') {
+          try {
+            resData = JSON.parse(resData)
+          } catch (e) {
+            console.log('resDataType默认为"json", 尝试对返回内容进行JSON.parse, 但似乎出了些问题(若不希望对结果进行parse, 可传入resDataType: "text"): ', e)
+          }
+        }
+        const result = {
+          errMsg: 'request:ok',
+          data: resData,
+          statusCode: status,
+          header: resHeader
+        }
+        successHandle(result, success, complete)
+        resolve(result)
+      } else {
+        if (responseType === 'json') {
+          resData = tryJsonParse(resData)
+        }
+        header = parseHeader(header)
+        const res = { errMsg: `request:fail ${error.msg}`, data: resData, header }
+        failHandle(res, fail, complete)
+        reject(res)
+      }
+    })
+  })
+}
+
+export { request }

package/src/platform/api/route/index.tenon.js

@@ -0,0 +1,121 @@
+import { successHandle } from '../../../common/js'
+import { EventChannel } from '../event-channel'
+const { Navigator } = __GLOBAL__
+
+function handleUrl (url) {
+  const [urlString, queryString] = url.split('?')
+  const queryObj = {}
+
+  if (!queryString) {
+    return {
+      query: queryObj,
+      url: urlString
+    }
+  }
+
+  const paramsArray = queryString.split('&')
+  for (const pair of paramsArray) {
+    const [key, value] = pair.split('=')
+    queryObj[key] = decodeURIComponent(value)
+  }
+
+  return {
+    query: queryObj,
+    url: urlString
+  }
+}
+
+function redirectTo (options = {}) {
+  const { url, query } = handleUrl(options.url || '')
+  if (Navigator) {
+    return new Promise((resolve, reject) => {
+      // 关闭本页面的跳转
+      Navigator.openPage(
+        {
+          url,
+          animated: false,
+          params: Object.assign({}, query, options.query || {}),
+          closeSelf: true
+        },
+        // 执行环境变了 得不到执行的机会 故回调无效
+        () => {}
+      )
+      const res = { errMsg: 'redirectTo:ok' }
+      successHandle(res, options.success, options.complete)
+      resolve(res)
+    })
+  }
+}
+
+function navigateTo (options = {}) {
+  const { url, query } = handleUrl(options.url || '')
+  const events = options.events
+
+  if (Navigator) {
+    const eventChannel = new EventChannel()
+    if (events) {
+      eventChannel._addListeners(events)
+    }
+    return new Promise((resolve, reject) => {
+      // 不关闭本页面的跳转
+      Navigator.openPage({
+        url,
+        animated: true,
+        params: Object.assign({}, query, options.query || {})
+      })
+      const res = { errMsg: 'redirectTo:ok', eventChannel }
+      successHandle(res, options.success, options.complete)
+      resolve(res)
+    })
+  }
+}
+
+function navigateBack (options = {}) {
+  if (Navigator) {
+    const delta = options.delta || 1
+    Navigator.popBack(delta, {
+      animated: true
+    })
+    const res = { errMsg: 'navigateBack:ok' }
+    successHandle(res, options.success, options.complete)
+    return Promise.resolve(res)
+  }
+}
+
+function reLaunch (options = {}) {
+  if (Navigator) {
+    Navigator.__mpxAction = {
+      type: 'reLaunch'
+    }
+    Navigator.popToRootPage()
+
+    const res = { errMsg: 'reLaunch:ok' }
+    successHandle(res, options.success, options.complete)
+    return Promise.resolve(res)
+  }
+}
+
+function switchTab (options = {}) {
+  if (Navigator) {
+    Navigator.__mpxAction = {
+      type: 'switch',
+      path: options.url,
+      replaced: true
+    }
+    return new Promise((resolve, reject) => {
+      Navigator.openPage(
+        {
+          url: options.url,
+          closeSelf: true
+        },
+        // 执行环境变了 得不到执行的机会 故回调无效
+        () => {}
+      )
+      const res = { errMsg: 'redirectTo:ok' }
+      successHandle(res, options.success, options.complete)
+      resolve(res)
+    })
+  }
+}
+
+export { redirectTo, navigateTo, navigateBack, reLaunch, switchTab }

package/src/platform/api/set-navigation-bar/index.tenon.js

@@ -0,0 +1,17 @@
+import { successHandle } from '../../../common/js'
+const {
+  Hummer
+} = __GLOBAL__
+
+function setNavigationBarTitle (options = {}) {
+  const { title, success, complete } = options
+  Hummer.setTitle(title)
+  successHandle({ errMsg: 'setTitle:ok' }, success, complete)
+}
+
+function setNavigationBarColor (options = {}) {}
+
+export {
+  setNavigationBarTitle,
+  setNavigationBarColor
+}

package/src/platform/api/socket/SocketTask.tenon.js

@@ -0,0 +1,105 @@
+import { successHandle, failHandle, warn } from '../../../common/js'
+const { WebSocket } = __GLOBAL__
+
+class SocketTask {
+  constructor (url, protocols) {
+    this._openCb = null
+    this._closeCb = null
+    this._messageCb = null
+    this._errorCb = null
+    this._closeData = null
+
+    WebSocket.connect(url)
+    this.addListener(WebSocket)
+  }
+
+  get CONNECTING () {
+    warn('不支持CONNECTING')
+  }
+
+  get OPEN () {
+    warn('不支持OPEN')
+  }
+
+  get CLOSING () {
+    warn('不支持CLOSING')
+  }
+
+  get CLOSED () {
+    warn('不支持CLOSED')
+  }
+
+  get readyState () {
+    warn('不支持readyState')
+  }
+
+  send (options) {
+    // todo fail options needs tobe convert
+    // const { data = '', success, fail, complete } = options
+    const { data = '', success, complete } = options
+    WebSocket.send(data)
+    const res = { errMsg: 'sendSocketMessage:ok' }
+    successHandle(res, success, complete)
+    return Promise.resolve(res)
+  }
+
+  close (options) {
+    const { code = 1000, reason = '', success, fail, complete } = options
+    this._closeData = {
+      code,
+      reason
+    }
+    try {
+      WebSocket.close()
+      const res = { errMsg: 'closeSocket:ok' }
+      successHandle(res, success, complete)
+      return Promise.resolve(res)
+    } catch (err) {
+      const res = { errMsg: `closeSocket:fail ${err}` }
+      failHandle(res, fail, complete)
+      if (!fail) {
+        return Promise.reject(res)
+      }
+    }
+  }
+
+  addListener (socket) {
+    socket.onOpen((event) => {
+      typeof this._openCb === 'function' && this._openCb(event)
+    })
+    socket.onMessage((event) => {
+      typeof this._messageCb === 'function' && this._messageCb(event)
+    })
+    socket.onError((event) => {
+      typeof this._errorCb === 'function' && this._errorCb(event)
+    })
+    socket.onClose((event) => {
+      if (typeof this._closeCb !== 'function') {
+        return
+      }
+      if (this._closeData) {
+        this._closeCb(event)
+      } else {
+        this._closeCb({ code: 2000, reason: `${event}` })
+      }
+    })
+  }
+
+  onOpen (cb) {
+    this._openCb = cb
+  }
+
+  onMessage (cb) {
+    this._messageCb = cb
+  }
+
+  onError (cb) {
+    this._errorCb = cb
+  }
+
+  onClose (cb) {
+    this._closeCb = cb
+  }
+}
+
+export default SocketTask

package/src/platform/api/socket/index.tenon.js

@@ -0,0 +1,48 @@
+import { warn, successHandle, failHandle } from '../../../common/js'
+import SocketTask from './SocketTask'
+
+function connectSocket (options = { url: '' }) {
+  const { url, protocols, success, fail, complete } = options
+
+  try {
+    const socketTask = new SocketTask(url, protocols)
+    successHandle({ errMsg: 'connectSocket:ok' }, success, complete)
+    return socketTask
+  } catch (e) {
+    failHandle({ errMsg: `connectSocket:fail ${e}` }, fail, complete)
+  }
+}
+
+function sendSocketMessage () {
+  warn('sendSocketMessage 请使用 socketTask.send')
+}
+
+function closeSocket () {
+  warn('closeSocket 请使用 socketTask.close')
+}
+
+function onSocketOpen () {
+  warn('onSocketOpen 请使用 socketTask.onOpen')
+}
+
+function onSocketError () {
+  warn('onSocketError 请使用 socketTask.onError')
+}
+
+function onSocketMessage () {
+  warn('onSocketMessage 请使用 socketTask.onMessage')
+}
+
+function onSocketClose () {
+  warn('onSocketClose 请使用 socketTask.onClose')
+}
+
+export {
+  connectSocket,
+  sendSocketMessage,
+  closeSocket,
+  onSocketOpen,
+  onSocketError,
+  onSocketMessage,
+  onSocketClose
+}

package/src/platform/api/storage/index.tenon.js

@@ -0,0 +1,144 @@
+import { successHandle, failHandle, warn } from '../../../common/js'
+import { hasOwn } from '@mpxjs/utils'
+const { Storage } = __GLOBAL__
+
+function setStorage (options = {}) {
+  const { key, data, success, fail, complete } = options
+
+  try {
+    setStorageSync(key, data)
+
+    const res = { errMsg: 'setStorage:ok' }
+    successHandle(res, success, complete)
+    return Promise.resolve(res)
+  } catch (err) {
+    const res = { errMsg: `setStorage:fail ${err}` }
+    failHandle(res, fail, complete)
+    return Promise.reject(res)
+  }
+}
+
+function setStorageSync (key = '', data) {
+  let obj = {}
+
+  if (typeof data === 'symbol') {
+    obj = { data: '' }
+  } else {
+    obj = { data }
+  }
+  Storage.set(key, JSON.stringify(obj))
+}
+
+function getStorage (options = {}) {
+  const { key, success, fail, complete } = options
+  const { result, data } = getItem(key)
+
+  if (result) {
+    const res = { errMsg: 'getStorage:ok', data: data }
+    successHandle(res, success, complete)
+    return Promise.resolve(res)
+  } else {
+    const res = { errMsg: 'getStorage:fail', data: null }
+    failHandle(res, fail, complete)
+    return Promise.reject(res)
+  }
+}
+
+function getStorageSync (key) {
+  const res = getItem(key)
+  if (res.result) return res.data
+
+  return ''
+}
+
+function getItem (key) {
+  let item
+  try {
+    item = JSON.parse(Storage.get(key))
+  } catch (e) {}
+
+  if (item && typeof item === 'object' && hasOwn(item, 'data')) {
+    return { result: true, data: item.data }
+  } else {
+    return { result: false }
+  }
+}
+
+function getStorageInfo (options = {}) {
+  const { success, fail, complete } = options
+
+  try {
+    const info = getStorageInfoSync()
+
+    const res = Object.assign({}, { errMsg: 'getStorageInfo:ok' }, info)
+    successHandle(res, success, complete)
+    return Promise.resolve(res)
+  } catch (err) {
+    const res = { errMsg: `getStorageInfo:fail ${err}` }
+    failHandle(res, fail, complete)
+    return Promise.reject(res)
+  }
+}
+
+function getStorageInfoSync () {
+  return {
+    keys: Object.keys(Storage),
+    limitSize: null,
+    currentSize: null
+  }
+}
+
+function removeStorage (options = { key: '' }) {
+  const { key, success, fail, complete } = options
+
+  try {
+    removeStorageSync(key)
+
+    const res = { errMsg: 'removeStorage:ok' }
+    successHandle(res, success, complete)
+    return Promise.resolve(res)
+  } catch (err) {
+    const res = { errMsg: `removeStorage:fail ${err}` }
+    failHandle(res, fail, complete)
+    return Promise.reject(res)
+  }
+}
+
+function removeStorageSync (key) {
+  Storage.remove(key)
+}
+
+function clearStorage (options = {}) {
+  warn('不支持clearStorageSync')
+  // const { success, fail, complete } = options
+
+  // try {
+  //   clearStorageSync()
+
+  //   const res = { errMsg: 'clearStorage:ok' }
+  //   successHandle(res, success, complete)
+  //   return Promise.resolve(res)
+  // } catch (err) {
+  //   const res = { errMsg: `clearStorage:fail ${err}` }
+  //   failHandle(res, fail, complete)
+  //   return Promise.reject(res)
+  // }
+}
+
+function clearStorageSync () {
+  // Storage.clear()
+  warn('不支持clearStorageSync')
+}
+
+export {
+  setStorage,
+  setStorageSync,
+  getStorage,
+  getStorageSync,
+  getStorageInfo,
+  getStorageInfoSync,
+  removeStorage,
+  removeStorageSync,
+  clearStorage,
+  clearStorageSync
+}

package/src/platform/api/storage/index.web.js

@@ -69,7 +69,7 @@ function getItem (key) {
   } catch (e) {
   }
 
-  if (item && typeof item === 'object' && hasOwn(item, 'data')) {
+  if (hasOwn(item, 'data')) {
     return { result: true, data: item.data }
   } else {
     return { result: false }

package/src/platform/api/storage/rnStorage.js

@@ -49,7 +49,7 @@ function getStorage (options = {}) {
       item = JSON.parse(res)
     } catch (e) {
     }
-    if (item && typeof item === 'object' && hasOwn(item, 'data')) {
+    if (hasOwn(item, 'data')) {
       data = item.data
     }
     const result = {