yach.open.jssdk 4.4.3-beta2 → 4.4.3-beta4

package/es/lib/helper/event.d.ts

@@ -0,0 +1,9 @@
+declare class Event {
+    eventsHandle: {};
+    constructor();
+    on: (event: any, fn: any) => void;
+    off: (event: any, fn: any) => void;
+    execEvent: (event: any, data: any) => void;
+}
+declare const event: Event;
+export default event;

package/es/lib/helper/event.js

@@ -0,0 +1,40 @@
+import _createClass from "@babel/runtime-corejs3/helpers/createClass";
+import _classCallCheck from "@babel/runtime-corejs3/helpers/classCallCheck";
+import _Array$isArray from "@babel/runtime-corejs3/core-js/array/is-array";
+import _indexOfInstanceProperty from "@babel/runtime-corejs3/core-js/instance/index-of";
+import _spliceInstanceProperty from "@babel/runtime-corejs3/core-js/instance/splice";
+import _forEachInstanceProperty from "@babel/runtime-corejs3/core-js/instance/for-each";
+var Event = /*#__PURE__*/_createClass(function Event() {
+  var _this = this;
+  _classCallCheck(this, Event);
+  this.on = function (event, fn) {
+    if (!event || 'function' !== typeof fn) throw 'eventName is null or handle is not a function, on fail';
+    if (!_Array$isArray(_this.eventsHandle[event])) _this.eventsHandle[event] = [];
+    _this.eventsHandle[event].push(fn);
+  };
+  this.off = function (event, fn) {
+    if (!event) throw 'eventName is null, invoke off fail';
+    if (!fn) {
+      _this.eventsHandle[event] = [];
+      return;
+    }
+    if (_Array$isArray(_this.eventsHandle[event])) {
+      var _context, _context2;
+      var n = _indexOfInstanceProperty(_context = _this.eventsHandle[event]).call(_context, fn);
+      -1 !== n && _spliceInstanceProperty(_context2 = _this.eventsHandle[event]).call(_context2, n, 1);
+    }
+  };
+  this.execEvent = function (event, data) {
+    var _context3;
+    _Array$isArray(this.eventsHandle[event]) && _forEachInstanceProperty(_context3 = this.eventsHandle[event]).call(_context3, function (fn) {
+      try {
+        fn(data);
+      } catch (t) {
+        console.error(data);
+      }
+    });
+  };
+  this.eventsHandle = {};
+});
+var event = new Event();
+export default event;

package/es/lib/helper/pcIframe.d.ts

@@ -0,0 +1,44 @@
+declare global {
+    interface Window {
+        sendToHost: any;
+        sendTo: any;
+        receiveBrowserViewData: any;
+    }
+}
+interface APIParams {
+    invokeType?: 'browserView' | '';
+    [propName: string]: any;
+}
+declare class GenPostMsg {
+    private id;
+    private PromiseObj;
+    private methodName;
+    private plainMsg;
+    callback: (v: any) => void;
+    result: Promise<any>;
+    invokeType: 'browserView' | '';
+    constructor(method: string, param: APIParams, callback: any);
+    genid: () => string;
+    receiveResponse: (data: any) => void;
+    getPayload: () => {
+        msgId: string;
+        methodName: string;
+        body: object;
+        type: string;
+        invokeType: "" | "browserView";
+    };
+}
+declare class Frame {
+    pendingMsgs: {};
+    constructor();
+    addPending: (e: any) => void;
+    deletePending: (e: any) => void;
+    getPending: (t: any) => any;
+    invokeAPIInBrowserView: (payload: string) => void;
+    invokeAPIInWebview: (payload: string) => void;
+    invokeAPI: (method: string, param: any, callback: any) => GenPostMsg;
+    handleCallback: (datas: any, invokeType?: 'browserView' | '') => void;
+    init: () => void;
+}
+declare const frame: Frame;
+export default frame;

package/es/lib/helper/pcIframe.js

@@ -0,0 +1,150 @@
+import _createClass from "@babel/runtime-corejs3/helpers/createClass";
+import _classCallCheck from "@babel/runtime-corejs3/helpers/classCallCheck";
+import _Date$now from "@babel/runtime-corejs3/core-js/date/now";
+import _JSON$stringify from "@babel/runtime-corejs3/core-js/json/stringify";
+import { log } from '../../utils';
+import Event from './event';
+// 处理posmessage参数
+var GenPostMsg = /*#__PURE__*/_createClass(function GenPostMsg(method, param, callback) {
+  var _this = this;
+  _classCallCheck(this, GenPostMsg);
+  this.genid = function () {
+    var idStr = _Date$now().toString(36);
+    idStr += Math.random().toString(36).substr(3);
+    return idStr;
+  };
+  this.receiveResponse = function (data) {
+    //this.PromiseObj.resolve(data);
+    _this.callback(data);
+  };
+  this.getPayload = function () {
+    return {
+      msgId: _this.id,
+      methodName: _this.methodName,
+      body: _this.plainMsg,
+      type: 'request',
+      invokeType: _this.invokeType
+    };
+  };
+  this.id = this.genid();
+  this.PromiseObj = {
+    resolve: null,
+    reject: null
+  };
+  this.methodName = method;
+  this.plainMsg = param;
+  this.invokeType = param === null || param === void 0 ? void 0 : param.invokeType;
+  this.callback = callback;
+  // this.result = new Promise(
+  //   function (resolve, reject) {
+  //     this.PromiseObj = {
+  //       resolve,
+  //       reject,
+  //     };
+  //   }.bind(this)
+  // );
+});
+var Frame = /*#__PURE__*/_createClass(function Frame() {
+  var _this2 = this;
+  _classCallCheck(this, Frame);
+  this.addPending = function (e) {
+    _this2.pendingMsgs[e.id] = e;
+  };
+  this.deletePending = function (e) {
+    delete _this2.pendingMsgs[e.id];
+  };
+  this.getPending = function (t) {
+    return this.pendingMsgs[t];
+  };
+  this.invokeAPIInBrowserView = function (payload) {
+    window.sendTo(payload);
+  };
+  this.invokeAPIInWebview = function (payload) {
+    window.sendToHost(payload);
+  };
+  this.invokeAPI = function (method, param, callback) {
+    var genPostMsg = new GenPostMsg(method, param, callback);
+    var payload = _JSON$stringify(genPostMsg.getPayload());
+    var _param$invokeType = param.invokeType,
+      invokeType = _param$invokeType === void 0 ? '' : _param$invokeType;
+    invokeType === 'browserView' ? _this2.invokeAPIInBrowserView(payload) : _this2.invokeAPIInWebview(payload);
+    _this2.addPending(genPostMsg);
+    return genPostMsg;
+  };
+  this.handleCallback = function (datas, invokeType) {
+    var type = datas.type,
+      methodName = datas.methodName,
+      eventName = datas.eventName,
+      msgId = datas.msgId,
+      _datas$data = datas.data,
+      data = _datas$data === void 0 ? {} : _datas$data,
+      code = datas.code,
+      message = datas.message,
+      msg = datas.msg;
+    if (type === 'request') {
+      // 壳子的调用
+      switch (methodName) {
+        case 'refresh':
+          window.location.reload();
+          break;
+        case 'back':
+          window.history.back();
+          break;
+        case 'forward':
+          window.history.forward();
+          break;
+        case 'event':
+          Event.execEvent(eventName, data);
+          break;
+        case 'zoomInClick':
+          var scrollTopVal = document.documentElement.scrollTop || document.body.scrollTop,
+            url = window.location.href;
+          if (invokeType === 'browserView') {
+            window.sendTo(_JSON$stringify({
+              type: type,
+              methodName: methodName,
+              body: {
+                scrollTopVal: scrollTopVal,
+                url: url,
+                title: data && data.title
+              }
+            }));
+          } else {
+            window.sendToHost(_JSON$stringify({
+              type: type,
+              methodName: methodName,
+              body: {
+                scrollTopVal: scrollTopVal,
+                url: url,
+                title: data && data.title
+              }
+            }));
+          }
+          break;
+        default:
+          break;
+      }
+    } else if (type === 'response') {
+      // 响应壳子的回调
+      var pending = _this2.getPending(msgId);
+      pending && pending.receiveResponse({
+        data: data,
+        code: code,
+        message: message || msg || data.msg || data.message
+      });
+      code != -3 && _this2.deletePending(msgId);
+    }
+  };
+  this.init = function () {
+    window.addEventListener('message', function (msg) {
+      log('electron res: ', msg);
+      _this2.handleCallback(msg.data || {});
+    });
+    window.receiveBrowserViewData && window.receiveBrowserViewData(function (e, response) {
+      return _this2.handleCallback(response);
+    });
+  };
+  this.pendingMsgs = {};
+});
+var frame = new Frame();
+export default frame;

package/es/lib/index.d.ts

@@ -0,0 +1,4 @@
+import Sdk from './sdk';
+declare const yachSdk: Sdk;
+declare function initSdk(): void;
+export { yachSdk, initSdk };

package/es/lib/index.js

@@ -0,0 +1,78 @@
+import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
+import _Promise from "@babel/runtime-corejs3/core-js/promise";
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = _Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+import { getENV } from '../utils';
+import Sdk from './sdk';
+import { mobileBridge, mobileBridgeInit, PcBridgeInit, pcBridge } from './bridge';
+import Event from './helper/event';
+var env = getENV();
+var platform = env.platform;
+var yachSdk = new Sdk(env);
+function initSdk() {
+  var _this = this;
+  var bridgeInit;
+  if (platform === 'pc') {
+    bridgeInit = function bridgeInit() {
+      return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              PcBridgeInit();
+              return _context.abrupt("return", pcBridge);
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+    };
+  } else {
+    bridgeInit = function bridgeInit() {
+      return mobileBridgeInit().then(function () {
+        return mobileBridge;
+      });
+    };
+  }
+  var config = {
+    platform: platform,
+    authMethod: 'config',
+    bridgeInit: bridgeInit,
+    event: {
+      on: function on(event, fn) {
+        Event.on(event, fn);
+      },
+      off: function off(event, fn) {
+        Event.off(event, fn);
+      }
+    }
+  };
+  yachSdk.setPlatform(config);
+}
+initSdk();
+export { yachSdk, initSdk };

package/es/lib/sdk/index.d.ts

@@ -0,0 +1,19 @@
+import { IInvokeAPIConfigMap, IPlatformConfig, IENV, IUNCore } from './sdk.typings';
+declare class Sdk {
+    private invokeAPIConfigMapByMethod;
+    private configJsApiList;
+    private platformConfigMap;
+    private hadConfig;
+    private env;
+    private bridgeInitFnPromise;
+    private cacheP;
+    private config$;
+    constructor(env: IENV);
+    exportSdk: IUNCore;
+    setAPI(method: string, config: IInvokeAPIConfigMap): void;
+    setPlatform(value: IPlatformConfig): void;
+    bridgeInitFn(): any;
+    _onFail(method: any, errorcode: any, message: any, onFail: any): void;
+    invokeAPI(method: string, params?: any): void;
+}
+export default Sdk;

package/es/lib/sdk/index.js

@@ -0,0 +1,169 @@
+import _classCallCheck from "@babel/runtime-corejs3/helpers/classCallCheck";
+import _createClass from "@babel/runtime-corejs3/helpers/createClass";
+import _Promise from "@babel/runtime-corejs3/core-js/promise";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/concat";
+import { bpitLog, log } from '../../utils';
+import { compareVersions } from '../../utils/compareVersions';
+import packageInfo from '../../../package.json';
+var Sdk = /*#__PURE__*/function () {
+  function Sdk(env) {
+    var _this = this;
+    _classCallCheck(this, Sdk);
+    this.invokeAPIConfigMapByMethod = {};
+    this.configJsApiList = [];
+    this.platformConfigMap = {};
+    this.hadConfig = false;
+    this.bridgeInitFnPromise = null;
+    this.cacheP = {};
+    this.config$ = new _Promise(function (a, b) {
+      _this.cacheP.resolve = a;
+      _this.cacheP.reject = b;
+    });
+    this.env = env;
+    this.exportSdk = {
+      version: env.version,
+      sdkVersion: packageInfo.version,
+      // sdkVersion: '0.0.0',
+      env: env,
+      platform: env.platform,
+      platformV2: env.platformV2,
+      config: function config() {
+        var _config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        // 鉴权
+        var _config$jsApiList = _config.jsApiList,
+          jsApiList = _config$jsApiList === void 0 ? [] : _config$jsApiList;
+        if (_this.hadConfig) {
+          console.log('Config has been executed');
+        } else {
+          _this.bridgeInitFn().then(function (fn) {
+            fn('config', _config).then(function (value) {
+              // 鉴权成功
+              _this.cacheP.resolve(value);
+              _this.hadConfig = true;
+              _this.configJsApiList = jsApiList;
+            })["catch"](function (error) {
+              // 后台鉴权失败
+              _this.cacheP.reject(error);
+            });
+          });
+        }
+      },
+      ready: function ready(fn) {
+        _this.bridgeInitFn().then(function () {
+          fn();
+        });
+      },
+      error: function error(fn) {
+        _this.config$["catch"](function (error) {
+          fn(error);
+        });
+      },
+      on: function on(o, n) {
+        _this.bridgeInitFn().then(function () {
+          _this.platformConfigMap[env.platform].event.on(o, n);
+        });
+      },
+      off: function off(o, n) {
+        _this.bridgeInitFn().then(function () {
+          _this.platformConfigMap[env.platform].event.off(o, n);
+        });
+      }
+    };
+  }
+  return _createClass(Sdk, [{
+    key: "setAPI",
+    value: function setAPI(method, config) {
+      this.invokeAPIConfigMapByMethod[method] = config;
+    }
+    // 确定端的同事初始化bridge
+  }, {
+    key: "setPlatform",
+    value: function setPlatform(value) {
+      var platform = value.platform,
+        bridgeInit = value.bridgeInit;
+      this.platformConfigMap[platform] = value;
+      // if (this.env.platform === platform) bridgeInit();
+    }
+  }, {
+    key: "bridgeInitFn",
+    value: function bridgeInitFn() {
+      // 平台环境不对再调用api就肯定失败
+      if (this.bridgeInitFnPromise) {
+        return this.bridgeInitFnPromise;
+      }
+      var o = this.platformConfigMap[this.env.platform];
+      if (o) {
+        this.bridgeInitFnPromise = o.bridgeInit();
+      } else {
+        var n = 'Do not support the current environment�' + this.env.platform;
+        this.bridgeInitFnPromise = _Promise.reject(new Error(n));
+      }
+      return this.bridgeInitFnPromise;
+    }
+  }, {
+    key: "_onFail",
+    value: function _onFail(method, errorcode, message, onFail) {
+      bpitLog({
+        method: method,
+        errorcode: errorcode,
+        message: message
+      });
+      onFail && typeof onFail == 'function' && onFail({
+        code: errorcode,
+        message: message
+      });
+    }
+  }, {
+    key: "invokeAPI",
+    value: function invokeAPI(method, params) {
+      var _context2;
+      if (!params) params = {};
+      if (!method) return;
+      // 验证方法是否可用
+      var apiConfigs = this.invokeAPIConfigMapByMethod[method];
+      if (!apiConfigs) {
+        return this._onFail(method, '-1', "[".concat(method, "] method is not exist"), params.onFail);
+      }
+      var apiConfig = apiConfigs[this.env.platform];
+      if (apiConfig) {
+        var supportVersion = apiConfig.vs || '0.0.0';
+        if (compareVersions(this.env.version, supportVersion) < 0) {
+          var _context;
+          return this._onFail(method, '-1', _concatInstanceProperty(_context = "The current application version is ".concat(this.env.version, ". This method does not support versions less than ")).call(_context, supportVersion), params.onFail);
+        }
+        // 确定参数
+        var p = apiConfig.paramsDeal ? apiConfig.paramsDeal(params) : params;
+        // 确定回调
+        if ('function' == typeof p.onSuccess) {
+          var v = p.onSuccess;
+          p.onSuccess = function (e) {
+            v(e);
+          };
+        }
+        // 主方法
+        this.bridgeInitFn().then(function (fn) {
+          fn(method, p).then(function (res) {
+            // 调用成功
+            log("SDK \u8FD4\u56DE\u7ED3\u679C\u6210\u529F ", {
+              method: method,
+              params: p,
+              result: res
+            });
+          })["catch"](function (error) {
+            // 调用失败
+            log("SDK \u8FD4\u56DE\u7ED3\u679C\u5931\u8D25", {
+              method: method,
+              params: p,
+              error: error
+            });
+          });
+        })["catch"](function (err) {
+          console.log('wenai err', err);
+        });
+        return;
+      }
+      this._onFail(method, '-1', _concatInstanceProperty(_context2 = "[".concat(method, "] method do not support the current platform (")).call(_context2, this.env.platform, ")"), params.onFail);
+    }
+  }]);
+}();
+export default Sdk;

package/es/lib/sdk/sdk.typings.d.ts

@@ -0,0 +1,85 @@
+export declare enum ENV_ENUM {
+    pc = "pc",
+    android = "android",
+    ios = "ios",
+    notInYach = "notInYach"
+}
+export declare enum ERROR_CODE {
+    cancel = "-1",
+    not_exist = "1",
+    no_permission = "7",
+    jsapi_internal_error = "22"
+}
+export interface PlatformV2Props {
+    inYach: boolean;
+    inIOS: boolean;
+    inAndroid: boolean;
+    inPC: boolean;
+    inIpad: boolean;
+    inIPhone: boolean;
+}
+export interface IENV {
+    /** current platform (ios or android or pc or notInYach) */
+    platform: ENV_ENUM;
+    /** current client version */
+    version?: string;
+    /** @deprecated recommend use navigator.language to get current language */
+    language?: string;
+    platformV2: PlatformV2Props;
+    env: 'test' | 'online';
+}
+export interface IInvokeAPIConfigMap {
+    [platform: string]: IAPIConfig | undefined;
+}
+export interface IAPIConfig {
+    /** version */
+    vs: string;
+    paramsDeal?: (params: object) => object;
+}
+export interface IInvokeAPIConfigMapByMethod {
+    [method: string]: IInvokeAPIConfigMap | undefined;
+}
+/** config参数 */
+export interface IConfigParams {
+    jsApiList?: string[];
+    [key: string]: any;
+}
+export interface IPlatformConfig {
+    platform: string;
+    authMethod: string;
+    authParamsDeal?: (params: object) => object;
+    bridgeInit: () => Promise<IJSBridge>;
+    event: {
+        on: (type: string, handler: (e: any) => void) => void;
+        off: (type: string, handler: (e: any) => void) => void;
+    };
+}
+/** jsbridgehui回调函数 */
+export declare type mobileCallback = (e: {
+    code: string;
+    message: string;
+    data?: Record<string, any>;
+}) => void;
+/** 定义主方法 */
+export interface IUNCore {
+    config: (configParams: IConfigParams) => void;
+    env: IENV;
+    ready: (readyCallback: () => void) => void;
+    error: (callback: (err: any) => void) => void;
+    version: string;
+    sdkVersion: string;
+    platform: ENV_ENUM;
+    platformV2: PlatformV2Props;
+    on: (methodName: string, listener: (e: any) => void) => void;
+    off: (methodName: string, listener: (e: any) => void) => void;
+}
+/** all platform map */
+export interface IConfigCoreMap {
+    [platform: string]: IPlatformConfig | undefined;
+}
+/** bridge主方法 */
+export declare type IJSBridge = (method: string, params: any) => Promise<any>;
+export interface IcacheP {
+    resolve?: (value: any) => void;
+    reject?: (error: any) => void;
+}

package/es/lib/sdk/sdk.typings.js

@@ -0,0 +1,7 @@
+export var ENV_ENUM;
+(function (ENV_ENUM) {
+  ENV_ENUM["pc"] = "pc";
+  ENV_ENUM["android"] = "android";
+  ENV_ENUM["ios"] = "ios";
+  ENV_ENUM["notInYach"] = "notInYach";
+})(ENV_ENUM || (ENV_ENUM = {}));

package/es/utils/bpitLog.d.ts

@@ -0,0 +1,16 @@
+interface Options {
+    group: string;
+    project: string;
+    env: string;
+    version: string;
+    method?: string;
+    yachid?: string;
+    workcode?: string;
+    timestamp?: number;
+    api?: string;
+    time?: number;
+    errorcode?: string;
+    message?: string;
+}
+export default function bpitLog(options: Options): void;
+export {};

package/es/utils/bpitLog.js

@@ -0,0 +1,62 @@
+function loadScript(url) {
+  var script = document.createElement('script');
+  script.type = 'text/javascript';
+  if (script.readyState) {
+    // ie 浏览器
+    script.onreadystatechange = function () {
+      if (script.readyState == 'loaded' || script.readyState == 'complete') {
+        script.onreadystatechange = null;
+        document.getElementsByTagName('head')[0].removeChild(script);
+      }
+    };
+  } else {
+    //其他
+    script.onload = function () {
+      document.getElementsByTagName('head')[0].removeChild(script);
+    };
+  }
+  script.src = url;
+  document.getElementsByTagName('head')[0].appendChild(script);
+}
+export default function bpitLog(options) {
+  if (!options) {
+    console.log('bpit error: need options');
+    return;
+  }
+  if (!options.group) {
+    console.log('bpit error: need options.group');
+    return;
+  }
+  if (!options.project) {
+    console.log('bpit error: need options.project');
+    return;
+  }
+  if (!options.hasOwnProperty('env')) {
+    console.log('bpit error: need options.env');
+    return;
+  }
+  if (!options.hasOwnProperty('version')) {
+    console.log('bpit error: need options.version');
+    return;
+  }
+  // upload data
+  var uploadData = ['https://es.zhiyinlou.com/log.js?'];
+  uploadData.push('group=' + options.group);
+  uploadData.push('&project=' + options.project);
+  uploadData.push('&env=' + options.env);
+  uploadData.push('&version=' + options.version);
+  uploadData.push('&method=' + options.method);
+  if (options.yachid) uploadData.push('&yachid=' + options.yachid);
+  if (options.workcode) uploadData.push('&workcode=' + options.workcode);
+  if (options.timestamp) uploadData.push('&timestamp=' + options.timestamp);
+  if (options.errorcode) uploadData.push('&errorcode=' + options.errorcode);
+  if (options.message) uploadData.push('&message=' + options.message);
+  // api load time
+  if (options.api && options.time) {
+    uploadData.push('&api=' + options.api);
+    uploadData.push('&load_time=' + options.time);
+  }
+  var uploadDataUrl = uploadData.join('');
+  loadScript(uploadDataUrl);
+  if (options.env != 'online') console.log(uploadDataUrl);
+}