@tarojs/api 3.6.2 → 3.6.4

package/dist/index.js

@@ -4,20 +4,25 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var _typeof = require('@babel/runtime/helpers/typeof');
 var runtime = require('@tarojs/runtime');
-var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+require('@babel/runtime/helpers/toConsumableArray');
+var _inherits = require('@babel/runtime/helpers/inherits');
+var _createSuper = require('@babel/runtime/helpers/createSuper');
 var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
 var _createClass = require('@babel/runtime/helpers/createClass');
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
-var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
+var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
+var _createSuper__default = /*#__PURE__*/_interopDefaultLegacy(_createSuper);
 var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
 var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
+var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
 var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
 
-function isFunction(x) {
+function isFunction$1(x) {
   return typeof x === 'function';
 }
 function isUndefined(x) {
@@ -35,7 +40,7 @@ function throwTypeError(s) {
   throw new TypeError(s);
 }
 
-if (!isFunction(Object.assign)) {
+if (!isFunction$1(Object.assign)) {
   // Must be writable: true, enumerable: false, configurable: true
   Object.assign = function (target) {
     // .length of function is 2
@@ -64,7 +69,7 @@ if (!isFunction(Object.assign)) {
   };
 }
 
-if (!isFunction(Object.defineProperties)) {
+if (!isFunction$1(Object.defineProperties)) {
   Object.defineProperties = function (obj, properties) {
     function convertToDescriptor(desc) {
       function hasProperty(obj, prop) {
@@ -88,7 +93,7 @@ if (!isFunction(Object.defineProperties)) {
       if (hasProperty(desc, 'get')) {
         var g = desc.get;
 
-        if (!isFunction(g) && !isUndefined(g)) {
+        if (!isFunction$1(g) && !isUndefined(g)) {
           throwTypeError('bad get');
         }
 
@@ -98,7 +103,7 @@ if (!isFunction(Object.defineProperties)) {
       if (hasProperty(desc, 'set')) {
         var s = desc.set;
 
-        if (!isFunction(s) && !isUndefined(s)) {
+        if (!isFunction$1(s) && !isUndefined(s)) {
           throwTypeError('bad set');
         }
 
@@ -129,16 +134,520 @@ if (!isFunction(Object.defineProperties)) {
   };
 }
 
+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__default["default"](this, Events);
+
+    var _a;
+
+    this.callbacks = (_a = opts === null || opts === void 0 ? void 0 : opts.callbacks) !== null && _a !== void 0 ? _a : {};
+  }
+
+  _createClass__default["default"](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__default["default"](TaroHooks, _Events);
+
+  var _super = _createSuper__default["default"](TaroHooks);
+
+  function TaroHooks(hooks, opts) {
+    var _this2;
+
+    _classCallCheck__default["default"](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__default["default"](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',
-  WEB: 'WEB',
-  RN: 'RN',
   SWAN: 'SWAN',
   ALIPAY: 'ALIPAY',
   TT: 'TT',
   QQ: 'QQ',
-  JD: 'JD'
+  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;
@@ -152,10 +661,14 @@ function getEnv() {
     return ENV_TYPE.JD;
   } else if (process.env.TARO_ENV === 'qq') {
     return ENV_TYPE.QQ;
-  } else if (process.env.TARO_ENV === 'h5') {
+  } 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';
   }
@@ -188,7 +701,7 @@ var Chain = /*#__PURE__*/function () {
         return Promise.reject(err);
       });
       Object.keys(p).forEach(function (k) {
-        return isFunction(p[k]) && (res[k] = p[k]);
+        return isFunction$1(p[k]) && (res[k] = p[k]);
       });
       return res;
     }
@@ -258,7 +771,7 @@ function timeoutInterceptor(chain) {
       reject(err);
     });
   });
-  if (!isUndefined(p) && isFunction(p.abort)) res.abort = p.abort;
+  if (!isUndefined(p) && isFunction$1(p.abort)) res.abort = p.abort;
   return res;
 }
 function logInterceptor(chain) {
@@ -281,7 +794,7 @@ function logInterceptor(chain) {
 
     return res;
   });
-  if (isFunction(p.abort)) res.abort = p.abort;
+  if (isFunction$1(p.abort)) res.abort = p.abort;
   return res;
 }
 
@@ -327,7 +840,7 @@ function getPxTransform(taro) {
 
     var designWidth = function () {
       var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-      return isFunction(config.designWidth) ? config.designWidth(input) : config.designWidth || defaultDesignWidth;
+      return isFunction$1(config.designWidth) ? config.designWidth(input) : config.designWidth || defaultDesignWidth;
     }(size);
 
     if (!(designWidth in deviceRatio)) {