miniapp-web-jsapi/lib/web/jsapi/selector-query/index.js

JSAPI/View adapter for miniprogram running on the web

import _inherits from "@babel/runtime/helpers/inherits";
import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
function _createSuper(t) { var r = _isNativeReflectConstruct(); return function () { var e, o = _getPrototypeOf(t); if (r) { var s = _getPrototypeOf(this).constructor; e = Reflect.construct(o, arguments, s); } else e = o.apply(this, arguments); return _possibleConstructorReturn(this, e); }; }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
var AbsExecutor = /*#__PURE__*/function () {
  function AbsExecutor(elements) {
    _classCallCheck(this, AbsExecutor);
    _defineProperty(this, "elements", void 0);
    this.elements = elements;
  }
  _createClass(AbsExecutor, [{
    key: "map",
    value: function map(mapper) {
      if (this.elements == null) {
        return null;
      }
      if (Array.isArray(this.elements)) {
        if (this.elements.length === 0) {
          return null;
        }
        return this.elements.map(mapper);
      }
      return [this.elements].map(mapper)[0];
    }
  }]);
  return AbsExecutor;
}();
var BoundingClientRectExecutor = /*#__PURE__*/function (_AbsExecutor2) {
  _inherits(BoundingClientRectExecutor, _AbsExecutor2);
  var _super = _createSuper(BoundingClientRectExecutor);
  function BoundingClientRectExecutor() {
    _classCallCheck(this, BoundingClientRectExecutor);
    return _super.apply(this, arguments);
  }
  _createClass(BoundingClientRectExecutor, [{
    key: "execute",
    value: function execute() {
      return this.map(function (element) {
        var rect = element.getBoundingClientRect();
        var result = {
          width: rect.width,
          height: rect.height,
          top: rect.top,
          bottom: rect.bottom,
          left: rect.left,
          right: rect.right
        };
        return result;
      });
    }
  }]);
  return BoundingClientRectExecutor;
}(AbsExecutor);
var ScrollOffsetExecutor = /*#__PURE__*/function (_AbsExecutor3) {
  _inherits(ScrollOffsetExecutor, _AbsExecutor3);
  var _super2 = _createSuper(ScrollOffsetExecutor);
  function ScrollOffsetExecutor() {
    _classCallCheck(this, ScrollOffsetExecutor);
    return _super2.apply(this, arguments);
  }
  _createClass(ScrollOffsetExecutor, [{
    key: "execute",
    value: function execute() {
      return this.map(function (element) {
        var result = {
          scrollLeft: element.scrollLeft,
          scrollTop: element.scrollTop
        };
        return result;
      });
    }
  }]);
  return ScrollOffsetExecutor;
}(AbsExecutor);
var ViewPortExecutor = /*#__PURE__*/function (_AbsExecutor4) {
  _inherits(ViewPortExecutor, _AbsExecutor4);
  var _super3 = _createSuper(ViewPortExecutor);
  function ViewPortExecutor() {
    _classCallCheck(this, ViewPortExecutor);
    return _super3.apply(this, arguments);
  }
  _createClass(ViewPortExecutor, [{
    key: "execute",
    value: function execute() {
      var doc = document.documentElement;
      return {
        scrollLeft: (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0),
        scrollTop: (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0),
        width: Math.max(document.documentElement.clientWidth || 0, window.innerWidth || 0),
        height: Math.max(document.documentElement.clientHeight || 0, window.innerHeight || 0)
      };
    }
  }]);
  return ViewPortExecutor;
}(AbsExecutor);
export function createSelectorQuery(options) {
  var executors = [];
  var isViewPort = false;
  var prevElement;
  var addExecutor = function addExecutor(constructor) {
    if (isViewPort) {
      executors.push(new ViewPortExecutor());
    } else {
      executors.push(new constructor(prevElement));
    }
    isViewPort = false;
    prevElement = null;
  };
  var measureMethod = {
    boundingClientRect: function boundingClientRect() {
      addExecutor(BoundingClientRectExecutor);
      return method;
    },
    scrollOffset: function scrollOffset() {
      addExecutor(ScrollOffsetExecutor);
      return method;
    }
  };
  var method = {
    select: function select(selector) {
      prevElement = document.querySelector(selector);
      return measureMethod;
    },
    selectAll: function selectAll(selector) {
      var list = document.querySelectorAll(selector);
      if (list) {
        var elements = [];
        list === null || list === void 0 ? void 0 : list.forEach(function (element) {
          return elements.push(element);
        });
        prevElement = elements;
      } else {
        prevElement = null;
      }
      return measureMethod;
    },
    selectViewport: function selectViewport() {
      isViewPort = true;
      return measureMethod;
    },
    exec: function exec(callback) {
      callback(executors.map(function (executor) {
        return executor.execute();
      }));
    }
  };
  return method;
}