yach.open.jssdk 4.3.2 → 4.3.3-beta1

package/es/lib/sdk/index.js

@@ -0,0 +1,170 @@
+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);
+        });
+      }
+    };
+  }
+  _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);
+    }
+  }]);
+  return Sdk;
+}();
+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);
+}

package/es/utils/compareVersions.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.
+ * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.
+ * @param v1 - First version to compare
+ * @param v2 - Second version to compare
+ * @returns Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+ */
+export declare const compareVersions: (v1: string, v2: string) => 0 | 1 | -1;
+/**
+ * Validate [semver](https://semver.org/) version strings.
+ *
+ * @param version Version number to validate
+ * @returns `true` if the version number is a valid semver version number, `false` otherwise.
+ *
+ * @example
+ * ```
+ * validate('1.0.0-rc.1'); // return true
+ * validate('1.0-rc.1'); // return false
+ * validate('foo'); // return false
+ * ```
+ */
+export declare const validate: (version: string) => boolean;
+/**
+ * Allowed arithmetic operators
+ */
+export declare type CompareOperator = '>' | '>=' | '=' | '<' | '<=';
+/**
+ * Compare [semver](https://semver.org/) version strings using the specified operator.
+ *
+ * @param v1 First version to compare
+ * @param v2 Second version to compare
+ * @param operator Allowed arithmetic operator to use
+ * @returns `true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise.
+ *
+ * @example
+ * ```
+ * compare('10.1.8', '10.0.4', '>'); // return true
+ * compare('10.0.1', '10.0.1', '='); // return true
+ * compare('10.1.1', '10.2.2', '<'); // return true
+ * compare('10.1.1', '10.2.2', '<='); // return true
+ * compare('10.1.1', '10.2.2', '>='); // return false
+ * ```
+ */
+export declare const compare: (v1: string, v2: string, operator: CompareOperator) => boolean;
+/**
+ * Match [npm semver](https://docs.npmjs.com/cli/v6/using-npm/semver) version range.
+ *
+ * @param version Version number to match
+ * @param range Range pattern for version
+ * @returns `true` if the version number is within the range, `false` otherwise.
+ *
+ * @example
+ * ```
+ * satisfies('1.1.0', '^1.0.0'); // return true
+ * satisfies('1.1.0', '~1.0.0'); // return false
+ * ```
+ */
+export declare const satisfies: (version: string, range: string) => boolean;

package/es/utils/compareVersions.js

@@ -0,0 +1,165 @@
+import _typeof from "@babel/runtime-corejs3/helpers/typeof";
+import _slicedToArray from "@babel/runtime-corejs3/helpers/slicedToArray";
+import _includesInstanceProperty from "@babel/runtime-corejs3/core-js/instance/includes";
+import _parseInt from "@babel/runtime-corejs3/core-js/parse-int";
+import _Object$keys from "@babel/runtime-corejs3/core-js/object/keys";
+import _indexOfInstanceProperty from "@babel/runtime-corejs3/core-js/instance/index-of";
+/**
+ * Compare [semver](https://semver.org/) version strings to find greater, equal or lesser.
+ * This library supports the full semver specification, including comparing versions with different number of digits like `1.0.0`, `1.0`, `1`, and pre-release versions like `1.0.0-alpha`.
+ * @param v1 - First version to compare
+ * @param v2 - Second version to compare
+ * @returns Numeric value compatible with the [Array.sort(fn) interface](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Parameters).
+ */
+export var compareVersions = function compareVersions(v1, v2) {
+  // validate input and split into segments
+  var n1 = validateAndParse(v1);
+  var n2 = validateAndParse(v2);
+  // pop off the patch
+  var p1 = n1.pop();
+  var p2 = n2.pop();
+  // validate numbers
+  var r = compareSegments(n1, n2);
+  if (r !== 0) return r;
+  // validate pre-release
+  if (p1 && p2) {
+    return compareSegments(p1.split('.'), p2.split('.'));
+  } else if (p1 || p2) {
+    return p1 ? -1 : 1;
+  }
+  return 0;
+};
+/**
+ * Validate [semver](https://semver.org/) version strings.
+ *
+ * @param version Version number to validate
+ * @returns `true` if the version number is a valid semver version number, `false` otherwise.
+ *
+ * @example
+ * ```
+ * validate('1.0.0-rc.1'); // return true
+ * validate('1.0-rc.1'); // return false
+ * validate('foo'); // return false
+ * ```
+ */
+export var validate = function validate(version) {
+  return typeof version === 'string' && /^[v\d]/.test(version) && semver.test(version);
+};
+/**
+ * Compare [semver](https://semver.org/) version strings using the specified operator.
+ *
+ * @param v1 First version to compare
+ * @param v2 Second version to compare
+ * @param operator Allowed arithmetic operator to use
+ * @returns `true` if the comparison between the firstVersion and the secondVersion satisfies the operator, `false` otherwise.
+ *
+ * @example
+ * ```
+ * compare('10.1.8', '10.0.4', '>'); // return true
+ * compare('10.0.1', '10.0.1', '='); // return true
+ * compare('10.1.1', '10.2.2', '<'); // return true
+ * compare('10.1.1', '10.2.2', '<='); // return true
+ * compare('10.1.1', '10.2.2', '>='); // return false
+ * ```
+ */
+export var compare = function compare(v1, v2, operator) {
+  var _context;
+  // validate input operator
+  assertValidOperator(operator);
+  // since result of compareVersions can only be -1 or 0 or 1
+  // a simple map can be used to replace switch
+  var res = compareVersions(v1, v2);
+  return _includesInstanceProperty(_context = operatorResMap[operator]).call(_context, res);
+};
+/**
+ * Match [npm semver](https://docs.npmjs.com/cli/v6/using-npm/semver) version range.
+ *
+ * @param version Version number to match
+ * @param range Range pattern for version
+ * @returns `true` if the version number is within the range, `false` otherwise.
+ *
+ * @example
+ * ```
+ * satisfies('1.1.0', '^1.0.0'); // return true
+ * satisfies('1.1.0', '~1.0.0'); // return false
+ * ```
+ */
+export var satisfies = function satisfies(version, range) {
+  // if no range operator then "="
+  var m = range.match(/^([<>=~^]+)/);
+  var op = m ? m[1] : '=';
+  // if gt/lt/eq then operator compare
+  if (op !== '^' && op !== '~') return compare(version, range, op);
+  // else range of either "~" or "^" is assumed
+  var _validateAndParse = validateAndParse(version),
+    _validateAndParse2 = _slicedToArray(_validateAndParse, 3),
+    v1 = _validateAndParse2[0],
+    v2 = _validateAndParse2[1],
+    v3 = _validateAndParse2[2];
+  var _validateAndParse3 = validateAndParse(range),
+    _validateAndParse4 = _slicedToArray(_validateAndParse3, 3),
+    r1 = _validateAndParse4[0],
+    r2 = _validateAndParse4[1],
+    r3 = _validateAndParse4[2];
+  if (compareStrings(v1, r1) !== 0) return false;
+  if (op === '^') {
+    return compareSegments([v2, v3], [r2, r3]) >= 0;
+  }
+  if (compareStrings(v2, r2) !== 0) return false;
+  return compareStrings(v3, r3) >= 0;
+};
+var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+var validateAndParse = function validateAndParse(version) {
+  if (typeof version !== 'string') {
+    throw new TypeError('Invalid argument expected string');
+  }
+  var match = version.match(semver);
+  if (!match) {
+    throw new Error("Invalid argument not valid semver ('".concat(version, "' received)"));
+  }
+  match.shift();
+  return match;
+};
+var isWildcard = function isWildcard(s) {
+  return s === '*' || s === 'x' || s === 'X';
+};
+var tryParse = function tryParse(v) {
+  var n = _parseInt(v, 10);
+  return isNaN(n) ? v : n;
+};
+var forceType = function forceType(a, b) {
+  return _typeof(a) !== _typeof(b) ? [String(a), String(b)] : [a, b];
+};
+var compareStrings = function compareStrings(a, b) {
+  if (isWildcard(a) || isWildcard(b)) return 0;
+  var _forceType = forceType(tryParse(a), tryParse(b)),
+    _forceType2 = _slicedToArray(_forceType, 2),
+    ap = _forceType2[0],
+    bp = _forceType2[1];
+  if (ap > bp) return 1;
+  if (ap < bp) return -1;
+  return 0;
+};
+var compareSegments = function compareSegments(a, b) {
+  for (var i = 0; i < Math.max(a.length, b.length); i++) {
+    var r = compareStrings(a[i] || '0', b[i] || '0');
+    if (r !== 0) return r;
+  }
+  return 0;
+};
+var operatorResMap = {
+  '>': [1],
+  '>=': [0, 1],
+  '=': [0],
+  '<=': [-1, 0],
+  '<': [-1]
+};
+var allowedOperators = _Object$keys(operatorResMap);
+var assertValidOperator = function assertValidOperator(op) {
+  if (typeof op !== 'string') {
+    throw new TypeError("Invalid operator type, expected string but got ".concat(_typeof(op)));
+  }
+  if (_indexOfInstanceProperty(allowedOperators).call(allowedOperators, op) === -1) {
+    throw new Error("Invalid operator, expected one of ".concat(allowedOperators.join('|')));
+  }
+};

package/es/utils/console.d.ts

@@ -0,0 +1,4 @@
+declare function log(...args: any): any;
+declare function error(...args: any): any;
+declare function warn(...args: any): any;
+export { log, error, warn, };

package/es/utils/console.js

@@ -0,0 +1,44 @@
+var _context, _context2, _context3;
+import _bindInstanceProperty from "@babel/runtime-corejs3/core-js/instance/bind";
+// 防止被应用复写console
+var myconsole = {
+  log: function log() {},
+  warn: function warn() {},
+  error: function error() {}
+};
+if (window && window.console) {
+  myconsole = window.console;
+}
+if (document && document.body) {
+  var iframe = document.createElement('iframe');
+  if (iframe && iframe.contentWindow && iframe.contentWindow.console) {
+    iframe.style.display = 'none';
+    document.body.appendChild(iframe);
+    myconsole = iframe.contentWindow.console;
+  }
+}
+var myLog = _bindInstanceProperty(_context = myconsole.log).call(_context, myconsole);
+var myWarn = _bindInstanceProperty(_context2 = myconsole.warn).call(_context2, myconsole);
+var myError = _bindInstanceProperty(_context3 = myconsole.error).call(_context3, myconsole);
+var style = 'color:#fff;font-weight:bold;border-radius:5px;background:#67c23a;';
+var styleError = "".concat(style, "background-color:red;");
+var styleWarn = "".concat(style, "background-color:orange;");
+function log() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return myLog("%c Yach-jssdk log: ", style, args);
+}
+function error() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+  return myWarn("%c Yach-jssdk log: ", styleError, args);
+}
+function warn() {
+  for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+    args[_key3] = arguments[_key3];
+  }
+  return myError("%c Yach-jssdk log: ", styleWarn, args);
+}
+export { log, error, warn };

package/es/utils/env.d.ts

@@ -0,0 +1,3 @@
+import { IENV } from '../lib/sdk/sdk.typings';
+declare function getENV(): IENV;
+export { getENV };

package/es/utils/env.js

@@ -0,0 +1,45 @@
+import { ENV_ENUM } from '../lib/sdk/sdk.typings';
+function getUA() {
+  return typeof navigator !== 'undefined' ? navigator.userAgent : '';
+}
+function getENV() {
+  var ua = getUA(),
+    inYach = /Yach/i.test(ua),
+    inIOS = /iPhone|iPad|iPod|iOS/i.test(ua) && inYach,
+    inAndroid = /Android/i.test(ua) && inYach,
+    inPC = /YachPc/i.test(ua),
+    inIpad = /iPad/i.test(ua) && inYach,
+    inIPhone = /iPhone/i.test(ua) && inYach,
+    isTest = /Yachtest/.test(ua) && inYach;
+  // platform
+  var platform = ENV_ENUM.notInYach;
+  if (inIOS) {
+    platform = ENV_ENUM.ios;
+  }
+  if (inAndroid) {
+    platform = ENV_ENUM.android;
+  }
+  if (inPC) {
+    platform = ENV_ENUM.pc;
+  }
+  // version
+  var versionArr = ua.match(/Yach\/[a-zA-Z0-9.-]+/) || [];
+  var version = (versionArr[0] || '').split('/')[1] || '';
+  // language
+  var language = typeof navigator !== 'undefined' ? navigator.language : '*';
+  return {
+    platform: platform,
+    platformV2: {
+      inYach: inYach,
+      inIOS: inIOS,
+      inAndroid: inAndroid,
+      inPC: inPC,
+      inIpad: inIpad,
+      inIPhone: inIPhone
+    },
+    version: version,
+    language: language,
+    env: isTest ? 'test' : 'online'
+  };
+}
+export { getENV };

package/es/utils/index.d.ts

@@ -0,0 +1,4 @@
+import { getENV } from './env';
+import { log, error, warn } from './console';
+declare function staticsLog(config: object): void;
+export { log, error, warn, staticsLog as bpitLog, getENV, };