js-bridge-adapter/dist/JsBridgeAdapter.js

web 端 bridge 适配器，适用于对接任意 native 端 bridge 方案

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('js-dynamic-function')) :
  typeof define === 'function' && define.amd ? define(['exports', 'js-dynamic-function'], factory) :
  (global = global || self, factory(global.JsBridgeAdapter = {}, global.DynamicFunction));
}(this, function (exports, DynamicFunction) { 'use strict';

  var DynamicFunction__default = 'default' in DynamicFunction ? DynamicFunction['default'] : DynamicFunction;

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  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 _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;

    for (i = 0; i < sourceKeys.length; i++) {
      key = sourceKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      target[key] = source[key];
    }

    return target;
  }

  function _objectWithoutProperties(source, excluded) {
    if (source == null) return {};

    var target = _objectWithoutPropertiesLoose(source, excluded);

    var key, i;

    if (Object.getOwnPropertySymbols) {
      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

      for (i = 0; i < sourceSymbolKeys.length; i++) {
        key = sourceSymbolKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
        target[key] = source[key];
      }
    }

    return target;
  }

  // 值类型判断 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  var isUndefined = function isUndefined(val) {
    return typeof val === 'undefined';
  };
  var isFunction = function isFunction(val) {
    return typeof val === 'function';
  };
  var isString = function isString(val) {
    return typeof val === 'string';
  }; // 值类型判断 -------------------------------------------------------------

  var get = function get(obj) {
    var keys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
    var defaultValue = arguments.length > 2 ? arguments[2] : undefined;

    try {
      var result = (isString(keys) ? keys.split('.') : keys).reduce(function (res, key) {
        return res[key];
      }, obj);
      return isUndefined(result) ? defaultValue : result;
    } catch (e) {
      return defaultValue;
    }
  };
  var run = function run(obj) {
    var keys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
    keys = isString(keys) ? keys.split('.') : keys;
    var func = get(obj, keys);
    var context = get(obj, keys.slice(0, -1));

    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
      args[_key - 2] = arguments[_key];
    }

    return isFunction(func) ? func.call.apply(func, [context].concat(args)) : func;
  };

  var parseConfig = function parseConfig(config) {
    if (typeof config === 'function') {
      return {
        runner: config
      };
    }

    return config;
  };

  var Api = function Api() {
    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    _classCallCheck(this, Api);

    var _parseConfig = parseConfig(config),
        _parseConfig$runner = _parseConfig.runner,
        runner = _parseConfig$runner === void 0 ? Api["default"].runner : _parseConfig$runner,
        _parseConfig$name = _parseConfig.name,
        name = _parseConfig$name === void 0 ? get(runner, 'name') : _parseConfig$name,
        _parseConfig$isSuppor = _parseConfig.isSupported,
        isSupported = _parseConfig$isSuppor === void 0 ? Api["default"].isSupported : _parseConfig$isSuppor,
        _parseConfig$getRunne = _parseConfig.getRunner,
        getExecutor = _parseConfig$getRunne === void 0 ? DynamicFunction.gen(isSupported, function (isSupported) {
      return isSupported && isFunction(runner) ? runner : undefined;
    }) : _parseConfig$getRunne;

    var func = new DynamicFunction__default({
      name: name,
      getExecutor: getExecutor
    });
    func.isSupported = func.isExecutable;
    func.getRunner = func.getExecutor;
    delete func.isExecutable;
    delete func.getExecutor;
    return func;
  };

  _defineProperty(Api, "default", {
    isSupported: function isSupported() {
      return true;
    },
    runner: undefined
  });

  var Bridge = function Bridge() {
    var _this = this;

    var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'anonymous';

    _classCallCheck(this, Bridge);

    _defineProperty(this, "apis", {});

    _defineProperty(this, "silent", Bridge["default"].silent);

    _defineProperty(this, "bridgeSupport", function () {
      return false;
    });

    _defineProperty(this, "getRunner", function () {
      return function () {
        return undefined;
      };
    });

    _defineProperty(this, "log", function (level) {
      if (_this.silent) {
        return;
      }

      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

      run.apply(void 0, [console, level].concat(args));
    });

    _defineProperty(this, "config", function () {
      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
          support = _ref.support,
          api = _ref.api,
          rest = _objectWithoutProperties(_ref, ["support", "api"]);

      return Object.assign(_this, rest, {
        getRunner: api,
        bridgeSupport: support
      });
    });

    _defineProperty(this, "register", function () {
      var apis = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      Object.assign(_this.apis, run(apis, undefined, _this.api));
      return _this;
    });

    _defineProperty(this, "api", function (key) {
      var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
          _ref2$getRunner = _ref2.getRunner,
          _getRunner = _ref2$getRunner === void 0 ? function () {
        return _this.getRunner(key);
      } : _ref2$getRunner;

      var bridgeRunner = new Api({
        name: key,
        runner: function runner() {
          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            args[_key2] = arguments[_key2];
          }

          return run.apply(void 0, [_getRunner(), undefined].concat(args));
        },
        isSupported: function isSupported() {
          return _this.bridgeSupport(key);
        }
      });

      bridgeRunner.customize = function (getCustomizedRunner) {
        return _this.api(key, {
          getRunner: function getRunner() {
            return getCustomizedRunner(_getRunner());
          }
        });
      };

      return bridgeRunner;
    });

    _defineProperty(this, "support", function (key) {
      return _this.has(key) && run(_this.apis, "".concat(key, ".isSupported"));
    });

    _defineProperty(this, "has", function (key) {
      return key in _this.apis;
    });

    _defineProperty(this, "get", function (key) {
      return get(_this.apis, key);
    });

    _defineProperty(this, "call", function (key) {
      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
        args[_key3 - 1] = arguments[_key3];
      }

      var unregisteredTips = "[Unregistered] Api \"".concat(key, "\" is unregistered in Bridge \"").concat(_this.name, "\"");
      var notSupportedTips = "[Not Supported] Api \"".concat(key, "\" is not supported by Bridge \"").concat(_this.name, "\"");

      if (!_this.has(key)) {
        return _this.log('warn', unregisteredTips);
      }

      return DynamicFunction.gen(function () {
        return run(_this.apis, "".concat(key, ".getRunner"));
      }, function (runner) {
        if (!isFunction(runner)) {
          return _this.log('warn', notSupportedTips);
        }

        return runner.apply(void 0, args);
      })();
    });

    this.name = name;
  };

  _defineProperty(Bridge, "Api", Api);

  _defineProperty(Bridge, "default", {
    silent: false
  });

  var uuid = 0;

  var uniqueId = function uniqueId() {
    var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
    return "".concat(prefix, "_").concat(++uuid, "_").concat(Date.now(), "_").concat(Math.floor(Math.random() * 1000000));
  };

  var getGlobal = function getGlobal() {
    if (typeof self !== 'undefined') {
      return self;
    }

    if (typeof window !== 'undefined') {
      return window;
    }

    if (typeof global !== 'undefined') {
      return global;
    }

    throw new Error('unable to locate global object');
  };

  var globalize = function globalize(handler) {
    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
        _ref$name = _ref.name,
        name = _ref$name === void 0 ? uniqueId('__globalFunction') : _ref$name,
        _ref$once = _ref.once,
        once = _ref$once === void 0 ? false : _ref$once;

    if (isString(handler)) {
      return handler;
    }

    getGlobal()[name] = function () {
      if (once) {
        delete getGlobal()[name];
      }

      if (isFunction(handler)) {
        return handler.apply(void 0, arguments);
      }

      return;
    };

    return name;
  };

  globalize.getGlobal = getGlobal;

  exports.Api = Api;
  exports.Bridge = Bridge;
  exports.default = Bridge;
  exports.globalize = globalize;
  exports.uniqueId = uniqueId;

  Object.defineProperty(exports, '__esModule', { value: true });

}));