@tarojs/components-advanced 3.6.2 → 3.6.4

package/dist/packages/taro-api/dist/index.esm.js

@@ -0,0 +1,861 @@
+import _typeof from '../../../node_modules/.pnpm/registry.npmjs.org_@babel_runtime@7.18.3/node_modules/@babel/runtime/helpers/typeof.js';
+import { Current, getCurrentInstance, options, nextTick, eventCenter } from '../../taro-runtime/dist/runtime.esm.js';
+import '../../../node_modules/.pnpm/registry.npmjs.org_@babel_runtime@7.18.3/node_modules/@babel/runtime/helpers/toConsumableArray.js';
+import _inherits from '../../../node_modules/.pnpm/registry.npmjs.org_@babel_runtime@7.18.3/node_modules/@babel/runtime/helpers/inherits.js';
+import _createSuper from '../../../node_modules/.pnpm/registry.npmjs.org_@babel_runtime@7.18.3/node_modules/@babel/runtime/helpers/createSuper.js';
+import _classCallCheck from '../../../node_modules/.pnpm/registry.npmjs.org_@babel_runtime@7.18.3/node_modules/@babel/runtime/helpers/classCallCheck.js';
+import _createClass from '../../../node_modules/.pnpm/registry.npmjs.org_@babel_runtime@7.18.3/node_modules/@babel/runtime/helpers/createClass.js';
+import _objectSpread from '../../../node_modules/.pnpm/registry.npmjs.org_@babel_runtime@7.18.3/node_modules/@babel/runtime/helpers/objectSpread2.js';
+import _defineProperty from '../../../node_modules/.pnpm/registry.npmjs.org_@babel_runtime@7.18.3/node_modules/@babel/runtime/helpers/defineProperty.js';
+import { Events as Events$1 } from '@tarojs/shared';
+
+function isFunction$1(x) {
+  return typeof x === 'function';
+}
+function isUndefined(x) {
+  return typeof x === 'undefined';
+}
+function isObject(x) {
+  return x && _typeof(x) === 'object';
+}
+
+var isBadObj = function isBadObj(x) {
+  return !isObject(x);
+};
+
+function throwTypeError(s) {
+  throw new TypeError(s);
+}
+
+if (!isFunction$1(Object.assign)) {
+  // Must be writable: true, enumerable: false, configurable: true
+  Object.assign = function (target) {
+    // .length of function is 2
+    if (target == null) {
+      // TypeError if undefined or null
+      throwTypeError('Cannot convert undefined or null to object');
+    }
+
+    var to = Object(target);
+
+    for (var index = 1; index < arguments.length; index++) {
+      var nextSource = arguments[index];
+
+      if (nextSource != null) {
+        // Skip over if undefined or null
+        for (var nextKey in nextSource) {
+          // Avoid bugs when hasOwnProperty is shadowed
+          if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+            to[nextKey] = nextSource[nextKey];
+          }
+        }
+      }
+    }
+
+    return to;
+  };
+}
+
+if (!isFunction$1(Object.defineProperties)) {
+  Object.defineProperties = function (obj, properties) {
+    function convertToDescriptor(desc) {
+      function hasProperty(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+      }
+
+      if (isBadObj(desc)) {
+        throwTypeError('bad desc');
+      }
+
+      var d = {};
+      if (hasProperty(desc, 'enumerable')) d.enumerable = !!desc.enumerable;
+
+      if (hasProperty(desc, 'configurable')) {
+        d.configurable = !!desc.configurable;
+      }
+
+      if (hasProperty(desc, 'value')) d.value = desc.value;
+      if (hasProperty(desc, 'writable')) d.writable = !!desc.writable;
+
+      if (hasProperty(desc, 'get')) {
+        var g = desc.get;
+
+        if (!isFunction$1(g) && !isUndefined(g)) {
+          throwTypeError('bad get');
+        }
+
+        d.get = g;
+      }
+
+      if (hasProperty(desc, 'set')) {
+        var s = desc.set;
+
+        if (!isFunction$1(s) && !isUndefined(s)) {
+          throwTypeError('bad set');
+        }
+
+        d.set = s;
+      }
+
+      if (('get' in d || 'set' in d) && ('value' in d || 'writable' in d)) {
+        throwTypeError('identity-confused descriptor');
+      }
+
+      return d;
+    }
+
+    if (isBadObj(obj)) throwTypeError('bad obj');
+    properties = Object(properties);
+    var keys = Object.keys(properties);
+    var descs = [];
+
+    for (var i = 0; i < keys.length; i++) {
+      descs.push([keys[i], convertToDescriptor(properties[keys[i]])]);
+    }
+
+    for (var _i = 0; _i < descs.length; _i++) {
+      Object.defineProperty(obj, descs[_i][0], descs[_i][1]);
+    }
+
+    return obj;
+  };
+}
+
+var DEFAULT_EMPTY_ARRAY = '[]';
+var NO_DEFAULT_VALUE = '';
+var DEFAULT_TRUE = '!0';
+var DEFAULT_FALSE = '!1';
+var touchEvents = {
+  bindTouchStart: NO_DEFAULT_VALUE,
+  bindTouchMove: NO_DEFAULT_VALUE,
+  bindTouchEnd: NO_DEFAULT_VALUE,
+  bindTouchCancel: NO_DEFAULT_VALUE,
+  bindLongTap: NO_DEFAULT_VALUE
+};
+var animation = {
+  animation: NO_DEFAULT_VALUE,
+  bindAnimationStart: NO_DEFAULT_VALUE,
+  bindAnimationIteration: NO_DEFAULT_VALUE,
+  bindAnimationEnd: NO_DEFAULT_VALUE,
+  bindTransitionEnd: NO_DEFAULT_VALUE
+};
+
+function singleQuote(s) {
+  return "'".concat(s, "'");
+}
+
+Object.assign(Object.assign({
+  'hover-class': singleQuote('none'),
+  'hover-stop-propagation': DEFAULT_FALSE,
+  'hover-start-time': '50',
+  'hover-stay-time': '400'
+}, touchEvents), animation);
+Object.assign({
+  longitude: NO_DEFAULT_VALUE,
+  latitude: NO_DEFAULT_VALUE,
+  scale: '16',
+  markers: DEFAULT_EMPTY_ARRAY,
+  covers: NO_DEFAULT_VALUE,
+  polyline: DEFAULT_EMPTY_ARRAY,
+  circles: DEFAULT_EMPTY_ARRAY,
+  controls: DEFAULT_EMPTY_ARRAY,
+  'include-points': DEFAULT_EMPTY_ARRAY,
+  'show-location': NO_DEFAULT_VALUE,
+  'layer-style': '1',
+  bindMarkerTap: NO_DEFAULT_VALUE,
+  bindControlTap: NO_DEFAULT_VALUE,
+  bindCalloutTap: NO_DEFAULT_VALUE,
+  bindUpdated: NO_DEFAULT_VALUE
+}, touchEvents);
+Object.assign({
+  size: singleQuote('default'),
+  type: NO_DEFAULT_VALUE,
+  plain: DEFAULT_FALSE,
+  disabled: NO_DEFAULT_VALUE,
+  loading: DEFAULT_FALSE,
+  'form-type': NO_DEFAULT_VALUE,
+  'open-type': NO_DEFAULT_VALUE,
+  'hover-class': singleQuote('button-hover'),
+  'hover-stop-propagation': DEFAULT_FALSE,
+  'hover-start-time': '20',
+  'hover-stay-time': '70',
+  name: NO_DEFAULT_VALUE
+}, touchEvents);
+Object.assign({
+  'scroll-top': DEFAULT_FALSE
+}, touchEvents);
+Object.assign(Object.assign({
+  direction: 'none',
+  inertia: DEFAULT_FALSE,
+  'out-of-bounds': DEFAULT_FALSE,
+  x: NO_DEFAULT_VALUE,
+  y: NO_DEFAULT_VALUE,
+  damping: '20',
+  friction: '2',
+  disabled: NO_DEFAULT_VALUE,
+  scale: DEFAULT_FALSE,
+  'scale-min': '0.5',
+  'scale-max': '10',
+  'scale-value': '1',
+  bindChange: NO_DEFAULT_VALUE,
+  bindScale: NO_DEFAULT_VALUE,
+  bindHTouchMove: NO_DEFAULT_VALUE,
+  bindVTouchMove: NO_DEFAULT_VALUE,
+  width: singleQuote('10px'),
+  height: singleQuote('10px')
+}, touchEvents), animation);
+Object.assign(Object.assign({
+  'scroll-x': DEFAULT_FALSE,
+  'scroll-y': DEFAULT_FALSE,
+  'upper-threshold': '50',
+  'lower-threshold': '50',
+  'scroll-top': NO_DEFAULT_VALUE,
+  'scroll-left': NO_DEFAULT_VALUE,
+  'scroll-into-view': NO_DEFAULT_VALUE,
+  'scroll-with-animation': DEFAULT_FALSE,
+  'enable-back-to-top': DEFAULT_FALSE,
+  bindScrollToUpper: NO_DEFAULT_VALUE,
+  bindScrollToLower: NO_DEFAULT_VALUE,
+  bindScroll: NO_DEFAULT_VALUE
+}, touchEvents), animation);
+Object.assign({
+  'indicator-dots': DEFAULT_FALSE,
+  'indicator-color': singleQuote('rgba(0, 0, 0, .3)'),
+  'indicator-active-color': singleQuote('#000000'),
+  autoplay: DEFAULT_FALSE,
+  current: '0',
+  interval: '5000',
+  duration: '500',
+  circular: DEFAULT_FALSE,
+  vertical: DEFAULT_FALSE,
+  'previous-margin': singleQuote('0px'),
+  'next-margin': singleQuote('0px'),
+  'display-multiple-items': '1',
+  bindChange: NO_DEFAULT_VALUE,
+  bindTransition: NO_DEFAULT_VALUE,
+  bindAnimationFinish: NO_DEFAULT_VALUE
+}, touchEvents);
+Object.assign({
+  src: NO_DEFAULT_VALUE,
+  mode: singleQuote('scaleToFill'),
+  'lazy-load': DEFAULT_FALSE,
+  bindError: NO_DEFAULT_VALUE,
+  bindLoad: NO_DEFAULT_VALUE
+}, touchEvents);
+Object.assign({
+  src: NO_DEFAULT_VALUE,
+  autoplay: DEFAULT_FALSE,
+  muted: DEFAULT_FALSE,
+  orientation: singleQuote('vertical'),
+  'object-fit': singleQuote('contain'),
+  'background-mute': DEFAULT_FALSE,
+  'min-cache': '1',
+  'max-cache': '3',
+  bindStateChange: NO_DEFAULT_VALUE,
+  bindFullScreenChange: NO_DEFAULT_VALUE,
+  bindNetStatus: NO_DEFAULT_VALUE
+}, animation);
+Object.assign({
+  src: NO_DEFAULT_VALUE,
+  duration: NO_DEFAULT_VALUE,
+  controls: DEFAULT_TRUE,
+  'danmu-list': NO_DEFAULT_VALUE,
+  'danmu-btn': NO_DEFAULT_VALUE,
+  'enable-danmu': NO_DEFAULT_VALUE,
+  autoplay: DEFAULT_FALSE,
+  loop: DEFAULT_FALSE,
+  muted: DEFAULT_FALSE,
+  'initial-time': '0',
+  'page-gesture': DEFAULT_FALSE,
+  direction: NO_DEFAULT_VALUE,
+  'show-progress': DEFAULT_TRUE,
+  'show-fullscreen-btn': DEFAULT_TRUE,
+  'show-play-btn': DEFAULT_TRUE,
+  'show-center-play-btn': DEFAULT_TRUE,
+  'enable-progress-gesture': DEFAULT_TRUE,
+  'object-fit': singleQuote('contain'),
+  poster: NO_DEFAULT_VALUE,
+  'show-mute-btn': DEFAULT_FALSE,
+  bindPlay: NO_DEFAULT_VALUE,
+  bindPause: NO_DEFAULT_VALUE,
+  bindEnded: NO_DEFAULT_VALUE,
+  bindTimeUpdate: NO_DEFAULT_VALUE,
+  bindFullScreenChange: NO_DEFAULT_VALUE,
+  bindWaiting: NO_DEFAULT_VALUE,
+  bindError: NO_DEFAULT_VALUE
+}, animation);
+Object.assign({
+  'canvas-id': NO_DEFAULT_VALUE,
+  'disable-scroll': DEFAULT_FALSE,
+  bindError: NO_DEFAULT_VALUE
+}, touchEvents);
+var PLATFORM_TYPE;
+
+(function (PLATFORM_TYPE) {
+  PLATFORM_TYPE["MINI"] = "mini";
+  PLATFORM_TYPE["WEB"] = "web";
+  PLATFORM_TYPE["RN"] = "rn";
+  PLATFORM_TYPE["HARMONY"] = "harmony";
+  PLATFORM_TYPE["QUICK"] = "quickapp";
+})(PLATFORM_TYPE || (PLATFORM_TYPE = {}));
+
+({
+  h5: {
+    type: PLATFORM_TYPE.WEB
+  },
+  harmony: {
+    type: PLATFORM_TYPE.HARMONY
+  },
+  mini: {
+    type: PLATFORM_TYPE.MINI
+  },
+  rn: {
+    type: PLATFORM_TYPE.RN
+  },
+  quickapp: {
+    type: PLATFORM_TYPE.QUICK
+  }
+});
+
+var Events = /*#__PURE__*/function () {
+  function Events(opts) {
+    _classCallCheck(this, Events);
+
+    var _a;
+
+    this.callbacks = (_a = opts === null || opts === void 0 ? void 0 : opts.callbacks) !== null && _a !== void 0 ? _a : {};
+  }
+
+  _createClass(Events, [{
+    key: "on",
+    value: function on(eventName, callback, context) {
+      var event, node, tail, list;
+
+      if (!callback) {
+        return this;
+      }
+
+      eventName = eventName.split(Events.eventSplitter);
+      this.callbacks || (this.callbacks = {});
+      var calls = this.callbacks;
+
+      while (event = eventName.shift()) {
+        list = calls[event];
+        node = list ? list.tail : {};
+        node.next = tail = {};
+        node.context = context;
+        node.callback = callback;
+        calls[event] = {
+          tail: tail,
+          next: list ? list.next : node
+        };
+      }
+
+      return this;
+    }
+  }, {
+    key: "once",
+    value: function once(events, callback, context) {
+      var _this = this;
+
+      var wrapper = function wrapper() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        callback.apply(_this, args);
+
+        _this.off(events, wrapper, context);
+      };
+
+      this.on(events, wrapper, context);
+      return this;
+    }
+  }, {
+    key: "off",
+    value: function off(events, callback, context) {
+      var event, calls, node, tail, cb, ctx;
+
+      if (!(calls = this.callbacks)) {
+        return this;
+      }
+
+      if (!(events || callback || context)) {
+        delete this.callbacks;
+        return this;
+      }
+
+      events = events ? events.split(Events.eventSplitter) : Object.keys(calls);
+
+      while (event = events.shift()) {
+        node = calls[event];
+        delete calls[event];
+
+        if (!node || !(callback || context)) {
+          continue;
+        }
+
+        tail = node.tail;
+
+        while ((node = node.next) !== tail) {
+          cb = node.callback;
+          ctx = node.context;
+
+          if (callback && cb !== callback || context && ctx !== context) {
+            this.on(event, cb, ctx);
+          }
+        }
+      }
+
+      return this;
+    }
+  }, {
+    key: "trigger",
+    value: function trigger(events) {
+      var event, node, calls, tail;
+
+      if (!(calls = this.callbacks)) {
+        return this;
+      }
+
+      events = events.split(Events.eventSplitter);
+      var rest = [].slice.call(arguments, 1);
+
+      while (event = events.shift()) {
+        if (node = calls[event]) {
+          tail = node.tail;
+
+          while ((node = node.next) !== tail) {
+            node.callback.apply(node.context || this, rest);
+          }
+        }
+      }
+
+      return this;
+    }
+  }]);
+
+  return Events;
+}();
+
+Events.eventSplitter = ','; // Note: Harmony ACE API 8 开发板不支持使用正则 split 字符串 /\s+/
+
+function isFunction(o) {
+  return typeof o === 'function';
+}
+
+var isWebPlatform = function isWebPlatform() {
+  return process.env.TARO_ENV === 'h5' || process.env.TARO_PLATFORM === 'web';
+};
+
+var HOOK_TYPE;
+
+(function (HOOK_TYPE) {
+  HOOK_TYPE[HOOK_TYPE["SINGLE"] = 0] = "SINGLE";
+  HOOK_TYPE[HOOK_TYPE["MULTI"] = 1] = "MULTI";
+  HOOK_TYPE[HOOK_TYPE["WATERFALL"] = 2] = "WATERFALL";
+})(HOOK_TYPE || (HOOK_TYPE = {}));
+
+var defaultMiniLifecycle = {
+  app: ['onLaunch', 'onShow', 'onHide'],
+  page: ['onLoad', 'onUnload', 'onReady', 'onShow', 'onHide', ['onPullDownRefresh', 'onReachBottom', 'onPageScroll', 'onResize', 'onTabItemTap', 'onTitleClick', 'onOptionMenuClick', 'onPopMenuClick', 'onPullIntercept', 'onAddToFavorites'], ['onShareAppMessage', 'onShareTimeline']],
+  component: ['attached', 'detached']
+};
+
+function TaroHook(type, initial) {
+  return {
+    type: type,
+    initial: initial || null
+  };
+}
+
+var TaroHooks = /*#__PURE__*/function (_Events) {
+  _inherits(TaroHooks, _Events);
+
+  var _super = _createSuper(TaroHooks);
+
+  function TaroHooks(hooks, opts) {
+    var _this2;
+
+    _classCallCheck(this, TaroHooks);
+
+    _this2 = _super.call(this, opts);
+    _this2.hooks = hooks;
+
+    for (var hookName in hooks) {
+      var initial = hooks[hookName].initial;
+
+      if (isFunction(initial)) {
+        _this2.on(hookName, initial);
+      }
+    }
+
+    return _this2;
+  }
+
+  _createClass(TaroHooks, [{
+    key: "tapOneOrMany",
+    value: function tapOneOrMany(hookName, callback) {
+      var _this3 = this;
+
+      var list = isFunction(callback) ? [callback] : callback;
+      list.forEach(function (cb) {
+        return _this3.on(hookName, cb);
+      });
+    }
+  }, {
+    key: "tap",
+    value: function tap(hookName, callback) {
+      var hooks = this.hooks;
+      var _hooks$hookName = hooks[hookName],
+          type = _hooks$hookName.type,
+          initial = _hooks$hookName.initial;
+
+      if (type === HOOK_TYPE.SINGLE) {
+        this.off(hookName);
+        this.on(hookName, isFunction(callback) ? callback : callback[callback.length - 1]);
+      } else {
+        initial && this.off(hookName, initial);
+        this.tapOneOrMany(hookName, callback);
+      }
+    }
+  }, {
+    key: "call",
+    value: function call(hookName) {
+      var _a;
+
+      var hook = this.hooks[hookName];
+      if (!hook) return;
+      var type = hook.type;
+      var calls = this.callbacks;
+      if (!calls) return;
+      var list = calls[hookName];
+
+      if (list) {
+        var tail = list.tail;
+        var node = list.next;
+
+        for (var _len2 = arguments.length, rest = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+          rest[_key2 - 1] = arguments[_key2];
+        }
+
+        var args = rest;
+        var res;
+
+        while (node !== tail) {
+          res = (_a = node.callback) === null || _a === void 0 ? void 0 : _a.apply(node.context || this, args);
+
+          if (type === HOOK_TYPE.WATERFALL) {
+            var params = [res];
+            args = params;
+          }
+
+          node = node.next;
+        }
+
+        return res;
+      }
+    }
+  }, {
+    key: "isExist",
+    value: function isExist(hookName) {
+      var _a;
+
+      return Boolean((_a = this.callbacks) === null || _a === void 0 ? void 0 : _a[hookName]);
+    }
+  }]);
+
+  return TaroHooks;
+}(Events);
+
+new TaroHooks({
+  getMiniLifecycle: TaroHook(HOOK_TYPE.SINGLE, function (defaultConfig) {
+    return defaultConfig;
+  }),
+  getMiniLifecycleImpl: TaroHook(HOOK_TYPE.SINGLE, function () {
+    return this.call('getMiniLifecycle', defaultMiniLifecycle);
+  }),
+  getLifecycle: TaroHook(HOOK_TYPE.SINGLE, function (instance, lifecycle) {
+    return instance[lifecycle];
+  }),
+  getPathIndex: TaroHook(HOOK_TYPE.SINGLE, function (indexOfNode) {
+    return "[".concat(indexOfNode, "]");
+  }),
+  getEventCenter: TaroHook(HOOK_TYPE.SINGLE, function (Events) {
+    return new Events();
+  }),
+  isBubbleEvents: TaroHook(HOOK_TYPE.SINGLE, function (eventName) {
+    /**
+     * 支持冒泡的事件, 除 支付宝小程序外，其余的可冒泡事件都和微信保持一致
+     * 详见 见 https://developers.weixin.qq.com/miniprogram/dev/framework/view/wxml/event.html
+     */
+    var BUBBLE_EVENTS = new Set(['touchstart', 'touchmove', 'touchcancel', 'touchend', 'touchforcechange', 'tap', 'longpress', 'longtap', 'transitionend', 'animationstart', 'animationiteration', 'animationend']);
+    return BUBBLE_EVENTS.has(eventName);
+  }),
+  getSpecialNodes: TaroHook(HOOK_TYPE.SINGLE, function () {
+    return ['view', 'text', 'image'];
+  }),
+  onRemoveAttribute: TaroHook(HOOK_TYPE.SINGLE),
+  batchedEventUpdates: TaroHook(HOOK_TYPE.SINGLE),
+  mergePageInstance: TaroHook(HOOK_TYPE.SINGLE),
+  modifyPageObject: TaroHook(HOOK_TYPE.SINGLE),
+  createPullDownComponent: TaroHook(HOOK_TYPE.SINGLE),
+  getDOMNode: TaroHook(HOOK_TYPE.SINGLE),
+  modifyHydrateData: TaroHook(HOOK_TYPE.SINGLE),
+  modifySetAttrPayload: TaroHook(HOOK_TYPE.SINGLE),
+  modifyRmAttrPayload: TaroHook(HOOK_TYPE.SINGLE),
+  onAddEvent: TaroHook(HOOK_TYPE.SINGLE),
+  modifyMpEvent: TaroHook(HOOK_TYPE.MULTI),
+  modifyMpEventImpl: TaroHook(HOOK_TYPE.SINGLE, function (e) {
+    try {
+      // 有些小程序的事件对象的某些属性只读
+      this.call('modifyMpEvent', e);
+    } catch (error) {
+      console.warn('[Taro modifyMpEvent hook Error]: ' + (error === null || error === void 0 ? void 0 : error.message));
+    }
+  }),
+  modifyTaroEvent: TaroHook(HOOK_TYPE.MULTI),
+  modifyDispatchEvent: TaroHook(HOOK_TYPE.MULTI),
+  initNativeApi: TaroHook(HOOK_TYPE.MULTI),
+  patchElement: TaroHook(HOOK_TYPE.MULTI)
+});
+
+new Date().getTime().toString();
+
+var ENV_TYPE = {
+  WEAPP: 'WEAPP',
+  SWAN: 'SWAN',
+  ALIPAY: 'ALIPAY',
+  TT: 'TT',
+  QQ: 'QQ',
+  JD: 'JD',
+  WEB: 'WEB',
+  RN: 'RN',
+  HARMONY: 'HARMONY',
+  QUICKAPP: 'QUICKAPP'
+};
+var isWeb = isWebPlatform();
+function getEnv() {
+  if (process.env.TARO_ENV === 'weapp') {
+    return ENV_TYPE.WEAPP;
+  } else if (process.env.TARO_ENV === 'alipay') {
+    return ENV_TYPE.ALIPAY;
+  } else if (process.env.TARO_ENV === 'swan') {
+    return ENV_TYPE.SWAN;
+  } else if (process.env.TARO_ENV === 'tt') {
+    return ENV_TYPE.TT;
+  } else if (process.env.TARO_ENV === 'jd') {
+    return ENV_TYPE.JD;
+  } else if (process.env.TARO_ENV === 'qq') {
+    return ENV_TYPE.QQ;
+  } else if (isWeb) {
+    return ENV_TYPE.WEB;
+  } else if (process.env.TARO_ENV === 'rn') {
+    return ENV_TYPE.RN;
+  } else if (process.env.TARO_ENV === 'harmony') {
+    return ENV_TYPE.HARMONY;
+  } else if (process.env.TARO_ENV === 'quickapp') {
+    return ENV_TYPE.QUICKAPP;
+  } else {
+    return process.env.TARO_ENV || 'Unknown';
+  }
+}
+
+var Chain = /*#__PURE__*/function () {
+  function Chain(requestParams, interceptors, index) {
+    _classCallCheck(this, Chain);
+
+    this.index = index || 0;
+    this.requestParams = requestParams;
+    this.interceptors = interceptors || [];
+  }
+
+  _createClass(Chain, [{
+    key: "proceed",
+    value: function proceed(requestParams) {
+      this.requestParams = requestParams;
+
+      if (this.index >= this.interceptors.length) {
+        throw new Error('chain 参数错误, 请勿直接修改 request.chain');
+      }
+
+      var nextInterceptor = this._getNextInterceptor();
+
+      var nextChain = this._getNextChain();
+
+      var p = nextInterceptor(nextChain);
+      var res = p.catch(function (err) {
+        return Promise.reject(err);
+      });
+      Object.keys(p).forEach(function (k) {
+        return isFunction$1(p[k]) && (res[k] = p[k]);
+      });
+      return res;
+    }
+  }, {
+    key: "_getNextInterceptor",
+    value: function _getNextInterceptor() {
+      return this.interceptors[this.index];
+    }
+  }, {
+    key: "_getNextChain",
+    value: function _getNextChain() {
+      return new Chain(this.requestParams, this.interceptors, this.index + 1);
+    }
+  }]);
+
+  return Chain;
+}();
+
+var Link = /*#__PURE__*/function () {
+  function Link(interceptor) {
+    _classCallCheck(this, Link);
+
+    this.taroInterceptor = interceptor;
+    this.chain = new Chain();
+  }
+
+  _createClass(Link, [{
+    key: "request",
+    value: function request(requestParams) {
+      var chain = this.chain;
+      var taroInterceptor = this.taroInterceptor;
+      chain.interceptors = chain.interceptors.filter(function (interceptor) {
+        return interceptor !== taroInterceptor;
+      }).concat(taroInterceptor);
+      return chain.proceed(_objectSpread({}, requestParams));
+    }
+  }, {
+    key: "addInterceptor",
+    value: function addInterceptor(interceptor) {
+      this.chain.interceptors.push(interceptor);
+    }
+  }, {
+    key: "cleanInterceptors",
+    value: function cleanInterceptors() {
+      this.chain = new Chain();
+    }
+  }]);
+
+  return Link;
+}();
+
+function timeoutInterceptor(chain) {
+  var requestParams = chain.requestParams;
+  var p;
+  var res = new Promise(function (resolve, reject) {
+    var timeout = setTimeout(function () {
+      timeout = null;
+      reject(new Error('网络链接超时,请稍后再试！'));
+    }, requestParams && requestParams.timeout || 60000);
+    p = chain.proceed(requestParams);
+    p.then(function (res) {
+      if (!timeout) return;
+      clearTimeout(timeout);
+      resolve(res);
+    }).catch(function (err) {
+      timeout && clearTimeout(timeout);
+      reject(err);
+    });
+  });
+  if (!isUndefined(p) && isFunction$1(p.abort)) res.abort = p.abort;
+  return res;
+}
+function logInterceptor(chain) {
+  var requestParams = chain.requestParams;
+  var method = requestParams.method,
+      data = requestParams.data,
+      url = requestParams.url;
+
+  if (process.env.NODE_ENV !== 'production') {
+    // eslint-disable-next-line no-console
+    console.log("http ".concat(method || 'GET', " --> ").concat(url, " data: "), data);
+  }
+
+  var p = chain.proceed(requestParams);
+  var res = p.then(function (res) {
+    if (process.env.NODE_ENV !== 'production') {
+      // eslint-disable-next-line no-console
+      console.log("http <-- ".concat(url, " result:"), res);
+    }
+
+    return res;
+  });
+  if (isFunction$1(p.abort)) res.abort = p.abort;
+  return res;
+}
+
+var interceptors = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  timeoutInterceptor: timeoutInterceptor,
+  logInterceptor: logInterceptor
+});
+
+function Behavior(options) {
+  return options;
+}
+function getPreload(current) {
+  return function (key, val) {
+    current.preloadData = isObject(key) ? key : _defineProperty({}, key, val);
+  };
+}
+var defaultDesignWidth = 750;
+var defaultDesignRatio = {
+  640: 2.34 / 2,
+  750: 1,
+  828: 1.81 / 2
+};
+var defaultBaseFontSize = 20;
+function getInitPxTransform(taro) {
+  return function (config) {
+    var _config$designWidth = config.designWidth,
+        designWidth = _config$designWidth === void 0 ? defaultDesignWidth : _config$designWidth,
+        _config$deviceRatio = config.deviceRatio,
+        deviceRatio = _config$deviceRatio === void 0 ? defaultDesignRatio : _config$deviceRatio,
+        _config$baseFontSize = config.baseFontSize,
+        baseFontSize = _config$baseFontSize === void 0 ? defaultBaseFontSize : _config$baseFontSize;
+    taro.config = taro.config || {};
+    taro.config.designWidth = designWidth;
+    taro.config.deviceRatio = deviceRatio;
+    taro.config.baseFontSize = baseFontSize;
+  };
+}
+function getPxTransform(taro) {
+  return function (size) {
+    var config = taro.config || {};
+    var deviceRatio = config.deviceRatio || defaultDesignRatio;
+
+    var designWidth = function () {
+      var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      return isFunction$1(config.designWidth) ? config.designWidth(input) : config.designWidth || defaultDesignWidth;
+    }(size);
+
+    if (!(designWidth in deviceRatio)) {
+      throw new Error("deviceRatio \u914D\u7F6E\u4E2D\u4E0D\u5B58\u5728 ".concat(designWidth, " \u7684\u8BBE\u7F6E\uFF01"));
+    }
+
+    return parseInt(size, 10) * deviceRatio[designWidth] + 'rpx';
+  };
+}
+
+/* eslint-disable camelcase */
+var Taro = {
+  Behavior: Behavior,
+  getEnv: getEnv,
+  ENV_TYPE: ENV_TYPE,
+  Link: Link,
+  interceptors: interceptors,
+  Current: Current,
+  getCurrentInstance: getCurrentInstance,
+  options: options,
+  nextTick: nextTick,
+  eventCenter: eventCenter,
+  Events: Events$1,
+  getInitPxTransform: getInitPxTransform
+};
+Taro.initPxTransform = getInitPxTransform(Taro);
+Taro.preload = getPreload(Current);
+Taro.pxTransform = getPxTransform(Taro);
+
+export { Taro as default };
+//# sourceMappingURL=index.esm.js.map