mtl-js-sdk/lib/common/nativeExecProxy.js

"use strict";

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

/**
 * 原生方法代理
 * 由于原生只能通过方法名(String) 回调，所以将 api 中 success/fail/complete 回调
 * 封装到 callback 中，并用一个 uuid 与 callback 关联。
 */
define(["./uuid"], function (uuid) {
  var CALLBACK_TYPE_COMMON = 0;
  var CALLBACK_TYPE_EXTRA = 1;
  var _callbackCaches = {};

  function setCallback(_ref) {
    var funcName = _ref.funcName,
        success = _ref.success,
        fail = _ref.fail,
        complete = _ref.complete;
    var callbackId = uuid(8);
    var callbackInfo = {
      type: CALLBACK_TYPE_COMMON,
      funcName: funcName,
      funcGroup: {
        success: success,
        fail: fail,
        complete: complete
      }
    };
    _callbackCaches[callbackId] = callbackInfo;
    return callbackId;
  } // 处理 params 参数中传递的额外回调，如多端协同中等待授权申请回应。


  function setExtraCallback(func, funcName) {
    var callbackId = uuid(8);
    var callbackInfo = {
      type: CALLBACK_TYPE_EXTRA,
      funcName: funcName,
      func: func
    };
    _callbackCaches[callbackId] = callbackInfo;
    return callbackId;
  }

  window.mtl_handleCallback = function (result) {
    var callbackId = result.callbackId,
        keepCallback = result.keepCallback,
        code = result.code,
        message = result.msg,
        data = result.data;
    var callbackInfo = _callbackCaches[callbackId];

    if (callbackInfo.type === CALLBACK_TYPE_COMMON) {
      var _callbackInfo$funcGro = callbackInfo.funcGroup,
          success = _callbackInfo$funcGro.success,
          fail = _callbackInfo$funcGro.fail,
          complete = _callbackInfo$funcGro.complete;

      if (code == 0) {
        success && success(data);
      } else {
        fail && fail({
          code: code,
          message: message
        });
      }

      complete && complete({
        code: code,
        message: message,
        data: data
      });
    } else if (callbackInfo.type === CALLBACK_TYPE_EXTRA) {
      var func = callbackInfo.func;
      func && func(data);
    }

    if (!keepCallback) {
      delete _callbackCaches[callbackId];
    }
  }; // 使用 callbackId 替换参数中的 function 类型属性


  function recurseReplaceFunc(object) {
    if (typeof object === "function") {
      return setExtraCallback(object);
    }

    if (_typeof(object) === "object") {
      if (object instanceof Array) {
        return object.map(function (o) {
          return recurseReplaceFunc(o);
        });
      }

      var copy = {};

      for (var key in object) {
        if (object.hasOwnProperty(key)) {
          var element = object[key];
          copy[key] = recurseReplaceFunc(element);
        }
      }

      return copy;
    }

    return object;
  }

  function proxy(func) {
    return function () {
      var object = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var isFunc = typeof object === "function";

      var _object = isFunc ? {} : _objectSpread({}, object);

      delete _object.success;
      delete _object.fail;
      delete _object.complete;

      if (_object.callback && _object.callback.length > 0) {
        _object.registerCallback = "mtl_registerCallback()";
        _object.callbackName = _object.callback;
      }

      if (_object.mtlRegisterCallbackName && _object.mtlRegisterCallbackName.length > 0) {
        return func(_object);
      }

      _object.callback = "mtl_handleCallback()";
      _object.callbackId = setCallback(isFunc ? {
        success: object
      } : object);
      return func(recurseReplaceFunc(_object));
    };
  }

  return proxy;
});