@smartimpact-it/scroll-utils 1.1.0

package/dist/cjs/ScrollOffset.js

@@ -0,0 +1,346 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var __importDefault = this && this.__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScrollOffset = exports.ScrollOffsetPart = void 0;
+var debounce_1 = __importDefault(require("lodash/debounce"));
+var isFunction_1 = __importDefault(require("lodash/isFunction"));
+var _name = /*#__PURE__*/new WeakMap();
+var _selectors = /*#__PURE__*/new WeakMap();
+var _elements = /*#__PURE__*/new WeakMap();
+var _fixedHeight = /*#__PURE__*/new WeakMap();
+var _condition = /*#__PURE__*/new WeakMap();
+var _resizeCondition = /*#__PURE__*/new WeakMap();
+var _resizeConditionValue = /*#__PURE__*/new WeakMap();
+var _totalHeight = /*#__PURE__*/new WeakMap();
+var _isValid = /*#__PURE__*/new WeakMap();
+var _heightCache = /*#__PURE__*/new WeakMap();
+var _getElementHeight = /*#__PURE__*/new WeakMap();
+var ScrollOffsetPart = /*#__PURE__*/function () {
+  function ScrollOffsetPart(_ref) {
+    var _this = this;
+    var _ref$name = _ref.name,
+      name = _ref$name === void 0 ? '' : _ref$name,
+      _ref$selectors = _ref.selectors,
+      selectors = _ref$selectors === void 0 ? [] : _ref$selectors,
+      _ref$elements = _ref.elements,
+      elements = _ref$elements === void 0 ? [] : _ref$elements,
+      _ref$fixedHeight = _ref.fixedHeight,
+      fixedHeight = _ref$fixedHeight === void 0 ? false : _ref$fixedHeight,
+      _ref$condition = _ref.condition,
+      condition = _ref$condition === void 0 ? false : _ref$condition,
+      _ref$resizeCondition = _ref.resizeCondition,
+      resizeCondition = _ref$resizeCondition === void 0 ? false : _ref$resizeCondition;
+    _classCallCheck(this, ScrollOffsetPart);
+    _classPrivateFieldInitSpec(this, _name, void 0);
+    _classPrivateFieldInitSpec(this, _selectors, void 0);
+    _classPrivateFieldInitSpec(this, _elements, void 0);
+    _classPrivateFieldInitSpec(this, _fixedHeight, void 0);
+    _classPrivateFieldInitSpec(this, _condition, void 0);
+    _classPrivateFieldInitSpec(this, _resizeCondition, void 0);
+    _classPrivateFieldInitSpec(this, _resizeConditionValue, void 0);
+    _classPrivateFieldInitSpec(this, _totalHeight, 0);
+    _classPrivateFieldInitSpec(this, _isValid, false);
+    _classPrivateFieldInitSpec(this, _heightCache, new WeakMap());
+    _defineProperty(this, "setElementHeight", function (element, height) {
+      if (!element || !Number.isFinite(height) || height < 0) return;
+      _classPrivateFieldGet(_heightCache, _this).set(element, Math.round(height));
+    });
+    _classPrivateFieldInitSpec(this, _getElementHeight, function (element) {
+      if (!element) return 0;
+      var cachedHeight = _classPrivateFieldGet(_heightCache, _this).get(element);
+      if (cachedHeight !== undefined) return cachedHeight;
+      var measuredHeight = element.clientHeight || 0;
+      _classPrivateFieldGet(_heightCache, _this).set(element, measuredHeight);
+      return measuredHeight;
+    });
+    _defineProperty(this, "calculate", function () {
+      var _classPrivateFieldGet2;
+      _classPrivateFieldSet(_isValid, _this, !!((_classPrivateFieldGet2 = _classPrivateFieldGet(_elements, _this)) !== null && _classPrivateFieldGet2 !== void 0 && _classPrivateFieldGet2.length));
+      if (_classPrivateFieldGet(_isValid, _this) && _classPrivateFieldGet(_condition, _this) && (0, isFunction_1["default"])(_classPrivateFieldGet(_condition, _this))) {
+        _classPrivateFieldSet(_isValid, _this, _classPrivateFieldGet(_isValid, _this) && _classPrivateFieldGet(_condition, _this).call(_this));
+      }
+      if (_classPrivateFieldGet(_isValid, _this) && _classPrivateFieldGet(_resizeCondition, _this) && (0, isFunction_1["default"])(_classPrivateFieldGet(_resizeCondition, _this))) {
+        if (!('resizeConditionValue' in _this)) {
+          _classPrivateFieldSet(_resizeConditionValue, _this, _classPrivateFieldGet(_resizeCondition, _this).call(_this));
+        }
+        _classPrivateFieldSet(_isValid, _this, _classPrivateFieldGet(_isValid, _this) && _classPrivateFieldGet(_resizeConditionValue, _this));
+      }
+      if (!_classPrivateFieldGet(_isValid, _this)) {
+        _classPrivateFieldSet(_totalHeight, _this, 0);
+      } else if (_classPrivateFieldGet(_fixedHeight, _this)) {
+        _classPrivateFieldSet(_totalHeight, _this, _classPrivateFieldGet(_fixedHeight, _this));
+      } else {
+        var totalHeight = 0;
+        _classPrivateFieldGet(_elements, _this).forEach(function (element) {
+          totalHeight += _classPrivateFieldGet(_getElementHeight, _this).call(_this, element);
+        });
+        _classPrivateFieldSet(_totalHeight, _this, totalHeight);
+      }
+      return _this;
+    });
+    _defineProperty(this, "calculateResizeConditions", function () {
+      if (_classPrivateFieldGet(_resizeCondition, _this) && (0, isFunction_1["default"])(_classPrivateFieldGet(_resizeCondition, _this))) {
+        var oldValue = _classPrivateFieldGet(_resizeConditionValue, _this) || false;
+        _classPrivateFieldSet(_resizeConditionValue, _this, _classPrivateFieldGet(_resizeCondition, _this).call(_this));
+        return oldValue != _classPrivateFieldGet(_resizeConditionValue, _this);
+      }
+      return false;
+    });
+    _classPrivateFieldSet(_name, this, name);
+    _classPrivateFieldSet(_selectors, this, (selectors || []).filter(Boolean));
+    _classPrivateFieldSet(_elements, this, (elements || []).filter(Boolean));
+    _classPrivateFieldSet(_fixedHeight, this, fixedHeight);
+    _classPrivateFieldSet(_condition, this, condition);
+    _classPrivateFieldSet(_resizeCondition, this, resizeCondition);
+    _classPrivateFieldGet(_selectors, this).forEach(function (selector) {
+      var newElements = _toConsumableArray(document.querySelectorAll(selector));
+      if (newElements.length) {
+        _classPrivateFieldSet(_elements, _this, [].concat(_toConsumableArray(_classPrivateFieldGet(_elements, _this)), _toConsumableArray(newElements)));
+      }
+    });
+    this.calculate();
+  }
+  return _createClass(ScrollOffsetPart, [{
+    key: "name",
+    get: function get() {
+      return _classPrivateFieldGet(_name, this);
+    }
+  }, {
+    key: "totalHeight",
+    get: function get() {
+      return _classPrivateFieldGet(_totalHeight, this);
+    }
+  }, {
+    key: "isValid",
+    get: function get() {
+      return _classPrivateFieldGet(_isValid, this);
+    }
+  }, {
+    key: "elements",
+    get: function get() {
+      return _classPrivateFieldGet(_elements, this);
+    }
+  }]);
+}();
+exports.ScrollOffsetPart = ScrollOffsetPart;
+/**!
+ * ScrollOffset - a class to handle add css variables to the body element,
+ * with the value of the "header" parts that are visible
+ * so that we can adjust scroll positions etc. based on it
+ *
+ * Author: Bogdan Barbu
+ * Team: Codingheads (codingheads.com)
+ */
+var _offsetParts = /*#__PURE__*/new WeakMap();
+var _variables = /*#__PURE__*/new WeakMap();
+var _extraEvents = /*#__PURE__*/new WeakMap();
+var _registerForHoudini = /*#__PURE__*/new WeakMap();
+var _useResizeObserver = /*#__PURE__*/new WeakMap();
+var _measureScheduled = /*#__PURE__*/new WeakMap();
+var _registerCssVariables = /*#__PURE__*/new WeakMap();
+var _calculateOffset = /*#__PURE__*/new WeakMap();
+var _calculateResizeConditions = /*#__PURE__*/new WeakMap();
+var _debouncedCalculateOffset = /*#__PURE__*/new WeakMap();
+var _debouncedCalculateResizeConditions = /*#__PURE__*/new WeakMap();
+var _scheduleCalculateOffset = /*#__PURE__*/new WeakMap();
+var _setupListeners = /*#__PURE__*/new WeakMap();
+var ScrollOffset = /*#__PURE__*/_createClass(
+/**
+ * setup the conditions
+ */
+function ScrollOffset() {
+  var _this2 = this;
+  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref2$offsetParts = _ref2.offsetParts,
+    offsetParts = _ref2$offsetParts === void 0 ? [] : _ref2$offsetParts,
+    _ref2$variables = _ref2.variables,
+    variables = _ref2$variables === void 0 ? [] : _ref2$variables,
+    _ref2$registerForHoud = _ref2.registerForHoudini,
+    registerForHoudini = _ref2$registerForHoud === void 0 ? true : _ref2$registerForHoud,
+    _ref2$useResizeObserv = _ref2.useResizeObserver,
+    useResizeObserver = _ref2$useResizeObserv === void 0 ? true : _ref2$useResizeObserv,
+    _ref2$extraEvents = _ref2.extraEvents,
+    extraEvents = _ref2$extraEvents === void 0 ? [] : _ref2$extraEvents;
+  _classCallCheck(this, ScrollOffset);
+  _classPrivateFieldInitSpec(this, _offsetParts, void 0);
+  _classPrivateFieldInitSpec(this, _variables, void 0);
+  _classPrivateFieldInitSpec(this, _extraEvents, void 0);
+  _classPrivateFieldInitSpec(this, _registerForHoudini, void 0);
+  _classPrivateFieldInitSpec(this, _useResizeObserver, void 0);
+  _classPrivateFieldInitSpec(this, _measureScheduled, false);
+  /**
+   * register the css variables as length in the Houdini CSS API
+   */
+  _classPrivateFieldInitSpec(this, _registerCssVariables, function () {
+    _classPrivateFieldGet(_variables, _this2).forEach(function (_ref3) {
+      var name = _ref3.name;
+      window.CSS.registerProperty({
+        name: "--".concat(name),
+        syntax: '<length>',
+        inherits: true,
+        initialValue: '0px'
+      });
+    });
+  });
+  /**
+   * calculate the offsets and set the css variables
+   */
+  _classPrivateFieldInitSpec(this, _calculateOffset, function () {
+    // calculate the conditions
+    _classPrivateFieldGet(_offsetParts, _this2).forEach(function (part) {
+      return part.calculate();
+    });
+    // determine the css variables
+    var cssVariables = _classPrivateFieldGet(_variables, _this2).map(function (variable) {
+      var value = variable.offsetParts.reduce(function (acc, part) {
+        if (typeof part == 'string') {
+          part = _classPrivateFieldGet(_offsetParts, _this2).find(function (partInfo) {
+            return partInfo.name.localeCompare(part) == 0;
+          });
+        }
+        if (part && part.isValid) {
+          acc += part.totalHeight;
+        }
+        return acc;
+      }, 0);
+      return _objectSpread(_objectSpread({}, variable), {}, {
+        value: value
+      });
+    });
+    // output the variables
+    cssVariables.forEach(function (_ref4) {
+      var name = _ref4.name,
+        value = _ref4.value;
+      document.documentElement.style.setProperty("--".concat(name), "".concat(value, "px"));
+    });
+    document.body.dispatchEvent(new CustomEvent('ScrollOffsetChange', {
+      bubbles: true
+    }));
+  });
+  /**
+   * recalculate values for conditions that only depend on resize
+   */
+  _classPrivateFieldInitSpec(this, _calculateResizeConditions, function () {
+    _classPrivateFieldGet(_offsetParts, _this2).forEach(function (part) {
+      return part.calculateResizeConditions();
+    });
+  });
+  _classPrivateFieldInitSpec(this, _debouncedCalculateOffset, (0, debounce_1["default"])(_classPrivateFieldGet(_calculateOffset, this), 32));
+  _classPrivateFieldInitSpec(this, _debouncedCalculateResizeConditions, (0, debounce_1["default"])(_classPrivateFieldGet(_calculateResizeConditions, this), 32));
+  _classPrivateFieldInitSpec(this, _scheduleCalculateOffset, function () {
+    if (_classPrivateFieldGet(_measureScheduled, _this2)) return;
+    _classPrivateFieldSet(_measureScheduled, _this2, true);
+    requestAnimationFrame(function () {
+      _classPrivateFieldSet(_measureScheduled, _this2, false);
+      _classPrivateFieldGet(_debouncedCalculateOffset, _this2).call(_this2);
+    });
+  });
+  /**
+   * setup event listeners
+   */
+  _classPrivateFieldInitSpec(this, _setupListeners, function () {
+    ['resize', 'orientationchange'].forEach(function (type) {
+      window.addEventListener(type, _classPrivateFieldGet(_debouncedCalculateResizeConditions, _this2));
+    });
+    ['resize', 'orientationchange', 'scrollDirectionChange', 'stickyIsPinned', 'stickyIsUnpinned'].concat(_toConsumableArray(_classPrivateFieldGet(_extraEvents, _this2))).forEach(function (type) {
+      return window.addEventListener(type, _classPrivateFieldGet(_scheduleCalculateOffset, _this2));
+    });
+    // setup resizeObservers for the elements
+    if (_classPrivateFieldGet(_useResizeObserver, _this2)) {
+      var resizeObserver = new ResizeObserver(function (entries) {
+        entries.forEach(function (entry) {
+          var _entry$contentRect;
+          var target = entry.target;
+          var height = Math.round(((_entry$contentRect = entry.contentRect) === null || _entry$contentRect === void 0 ? void 0 : _entry$contentRect.height) || (target === null || target === void 0 ? void 0 : target.clientHeight) || 0);
+          if (!target || !height) return;
+          _classPrivateFieldGet(_offsetParts, _this2).forEach(function (part) {
+            if (part.elements.includes(target)) {
+              part.setElementHeight(target, height);
+            }
+          });
+        });
+        _classPrivateFieldGet(_scheduleCalculateOffset, _this2).call(_this2);
+      });
+      _classPrivateFieldGet(_offsetParts, _this2).forEach(function (part) {
+        return part.elements.forEach(function (element) {
+          return resizeObserver.observe(element);
+        });
+      });
+    }
+  });
+  // parse the variables
+  if (Array.isArray(variables)) {
+    _classPrivateFieldSet(_variables, this, variables);
+  } else {
+    _classPrivateFieldSet(_variables, this, Object.entries(variables).map(function (_ref5) {
+      var _ref6 = _slicedToArray(_ref5, 2),
+        key = _ref6[0],
+        value = _ref6[1];
+      return {
+        name: key,
+        offsetParts: value
+      };
+    }));
+  }
+  // take the offset parts from the variables
+  var variableOffsetParts = _classPrivateFieldGet(_variables, this).map(function (_ref7) {
+    var offsetParts = _ref7.offsetParts;
+    return offsetParts.filter(function (part) {
+      return part instanceof ScrollOffsetPart;
+    });
+  }).flat(1);
+  // merge with the settings and keep only distinct elements
+  offsetParts = _toConsumableArray(new Set([].concat(_toConsumableArray(offsetParts), _toConsumableArray(variableOffsetParts))));
+  // parse the offset parts
+  _classPrivateFieldSet(_offsetParts, this, offsetParts.map(function (part) {
+    var partObject = null;
+    if (!(part instanceof ScrollOffsetPart)) {
+      partObject = new ScrollOffsetPart(part);
+    } else {
+      partObject = part;
+    }
+    partObject.calculate();
+    return partObject;
+  }));
+  _classPrivateFieldSet(_extraEvents, this, extraEvents || []);
+  _classPrivateFieldSet(_registerForHoudini, this, registerForHoudini && 'CSS' in window && 'registerProperty' in window.CSS);
+  _classPrivateFieldSet(_useResizeObserver, this, 'ResizeObserver' in window && useResizeObserver);
+  if (_classPrivateFieldGet(_registerForHoudini, this)) {
+    _classPrivateFieldGet(_registerCssVariables, this).call(this);
+  }
+  _classPrivateFieldGet(_setupListeners, this).call(this);
+  _classPrivateFieldGet(_calculateOffset, this).call(this);
+});
+exports.ScrollOffset = ScrollOffset;
+exports["default"] = ScrollOffset;

package/dist/cjs/ScrollPages.js

@@ -0,0 +1,97 @@
+"use strict";
+
+/**
+ * ScrollPages - a class to add classes to the body,
+ * detecting whether we are above the fold or below
+ * (the above-the-fold are can also be set as an existing element)
+ *
+ * Author: Bogdan Barbu
+ * Team: Codingheads (codingheads.com)
+ */
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ScrollPages = void 0;
+var _intersectionElement = /*#__PURE__*/new WeakMap();
+var _observer = /*#__PURE__*/new WeakMap();
+var _isBelowTheFold = /*#__PURE__*/new WeakMap();
+var _belowTheFoldClass = /*#__PURE__*/new WeakMap();
+var _aboveTheFoldClass = /*#__PURE__*/new WeakMap();
+var _ScrollPages_brand = /*#__PURE__*/new WeakSet();
+var ScrollPages = /*#__PURE__*/_createClass(
+/**
+ * start an instance
+ */
+function ScrollPages() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$intersectionElem = _ref.intersectionElement,
+    intersectionElement = _ref$intersectionElem === void 0 ? null : _ref$intersectionElem,
+    _ref$belowTheFoldClas = _ref.belowTheFoldClass,
+    belowTheFoldClass = _ref$belowTheFoldClas === void 0 ? 'below-the-fold' : _ref$belowTheFoldClas,
+    _ref$aboveTheFoldClas = _ref.aboveTheFoldClass,
+    aboveTheFoldClass = _ref$aboveTheFoldClas === void 0 ? 'above-the-fold' : _ref$aboveTheFoldClas;
+  _classCallCheck(this, ScrollPages);
+  /**
+   * dispatch an event on the window
+   */
+  _classPrivateMethodInitSpec(this, _ScrollPages_brand);
+  _classPrivateFieldInitSpec(this, _intersectionElement, void 0);
+  _classPrivateFieldInitSpec(this, _observer, null);
+  _classPrivateFieldInitSpec(this, _isBelowTheFold, false);
+  _classPrivateFieldInitSpec(this, _belowTheFoldClass, void 0);
+  _classPrivateFieldInitSpec(this, _aboveTheFoldClass, void 0);
+  _classPrivateFieldSet(_intersectionElement, this, intersectionElement);
+  _classPrivateFieldSet(_belowTheFoldClass, this, belowTheFoldClass);
+  _classPrivateFieldSet(_aboveTheFoldClass, this, aboveTheFoldClass);
+  _assertClassBrand(_ScrollPages_brand, this, _setupObserver).call(this);
+});
+function _dispatchEvent(name) {
+  requestAnimationFrame(function () {
+    window.dispatchEvent(new CustomEvent(name));
+  });
+}
+function _setupObserver() {
+  var _this = this;
+  var body = document.body;
+  // create the intersection element, if it doesn't exist
+  if (!_classPrivateFieldGet(_intersectionElement, this)) {
+    var containerPosition = window.getComputedStyle(body).getPropertyValue('position');
+    if (!containerPosition || containerPosition == 'static') {
+      body.style.position = 'relative';
+    }
+    _classPrivateFieldSet(_intersectionElement, this, document.createElement('div'));
+    _classPrivateFieldGet(_intersectionElement, this).classList.add('second-page-observer');
+    _classPrivateFieldGet(_intersectionElement, this).style.cssText = 'pointerEvents: none; visibility: hidden; position: absolute; top: 0; left: 0; right: 0; height: 100vh;';
+    body.appendChild(_classPrivateFieldGet(_intersectionElement, this));
+  }
+  body.classList.add(_classPrivateFieldGet(_aboveTheFoldClass, this));
+  _classPrivateFieldSet(_observer, this, new IntersectionObserver(function (entries) {
+    var isFirstPage = true;
+    entries.forEach(function (entry) {
+      if (!entry.isIntersecting) {
+        isFirstPage = false;
+      }
+    });
+    if (_classPrivateFieldGet(_isBelowTheFold, _this) != !isFirstPage) {
+      _classPrivateFieldSet(_isBelowTheFold, _this, !isFirstPage);
+      body.classList[_classPrivateFieldGet(_isBelowTheFold, _this) ? 'add' : 'remove'](_classPrivateFieldGet(_belowTheFoldClass, _this));
+      body.classList[!_classPrivateFieldGet(_isBelowTheFold, _this) ? 'add' : 'remove'](_classPrivateFieldGet(_aboveTheFoldClass, _this));
+      _assertClassBrand(_ScrollPages_brand, _this, _dispatchEvent).call(_this, 'ScrollPageChange');
+    }
+  }));
+  _classPrivateFieldGet(_observer, this).observe(_classPrivateFieldGet(_intersectionElement, this));
+}
+exports.ScrollPages = ScrollPages;
+exports["default"] = ScrollPages;

package/dist/cjs/index.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onReady = exports.onInteractive = exports.onComplete = exports.onReadyState = exports.FoundationAccordionScrollIntoView = exports.Bootstrap4AccordionScrollIntoView = exports.BootstrapAccordionScrollIntoView = exports.FixHashScrollPosition = exports.scrollWithMarginTop = exports.ScrollPages = exports.ScrollOffsetPart = exports.ScrollOffset = exports.ScrollDirection = void 0;
+var ScrollDirection_1 = require("./ScrollDirection");
+Object.defineProperty(exports, "ScrollDirection", {
+  enumerable: true,
+  get: function get() {
+    return ScrollDirection_1.ScrollDirection;
+  }
+});
+var ScrollOffset_1 = require("./ScrollOffset");
+Object.defineProperty(exports, "ScrollOffset", {
+  enumerable: true,
+  get: function get() {
+    return ScrollOffset_1.ScrollOffset;
+  }
+});
+Object.defineProperty(exports, "ScrollOffsetPart", {
+  enumerable: true,
+  get: function get() {
+    return ScrollOffset_1.ScrollOffsetPart;
+  }
+});
+var ScrollPages_1 = require("./ScrollPages");
+Object.defineProperty(exports, "ScrollPages", {
+  enumerable: true,
+  get: function get() {
+    return ScrollPages_1.ScrollPages;
+  }
+});
+var scrollWithMarginTop_1 = require("./scrollWithMarginTop");
+Object.defineProperty(exports, "scrollWithMarginTop", {
+  enumerable: true,
+  get: function get() {
+    return scrollWithMarginTop_1.scrollWithMarginTop;
+  }
+});
+var FixHashScrollPosition_1 = require("./FixHashScrollPosition");
+Object.defineProperty(exports, "FixHashScrollPosition", {
+  enumerable: true,
+  get: function get() {
+    return FixHashScrollPosition_1.FixHashScrollPosition;
+  }
+});
+var BootstrapAccordionScrollIntoView_1 = require("./BootstrapAccordionScrollIntoView");
+Object.defineProperty(exports, "BootstrapAccordionScrollIntoView", {
+  enumerable: true,
+  get: function get() {
+    return BootstrapAccordionScrollIntoView_1.BootstrapAccordionScrollIntoView;
+  }
+});
+var Bootstrap4AccordionScrollIntoView_1 = require("./Bootstrap4AccordionScrollIntoView");
+Object.defineProperty(exports, "Bootstrap4AccordionScrollIntoView", {
+  enumerable: true,
+  get: function get() {
+    return Bootstrap4AccordionScrollIntoView_1.Bootstrap4AccordionScrollIntoView;
+  }
+});
+var FoundationAccordionScrollIntoView_1 = require("./FoundationAccordionScrollIntoView");
+Object.defineProperty(exports, "FoundationAccordionScrollIntoView", {
+  enumerable: true,
+  get: function get() {
+    return FoundationAccordionScrollIntoView_1.FoundationAccordionScrollIntoView;
+  }
+});
+var onReady_1 = require("./utils/onReady");
+Object.defineProperty(exports, "onReadyState", {
+  enumerable: true,
+  get: function get() {
+    return onReady_1.onReadyState;
+  }
+});
+Object.defineProperty(exports, "onComplete", {
+  enumerable: true,
+  get: function get() {
+    return onReady_1.onComplete;
+  }
+});
+Object.defineProperty(exports, "onInteractive", {
+  enumerable: true,
+  get: function get() {
+    return onReady_1.onInteractive;
+  }
+});
+Object.defineProperty(exports, "onReady", {
+  enumerable: true,
+  get: function get() {
+    return onReady_1.onReady;
+  }
+});

package/dist/cjs/scrollWithMarginTop.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scrollWithMarginTop = void 0;
+/**
+ * Scroll to an element taking into account its "scroll-margin-top"/"scroll-snap-margin-top".
+ * This will help with Safari < 14.1 / Safari iOS <= 1.4, which doesn't support "scroll-margin-top".
+ */
+var scrollWithMarginTop = function scrollWithMarginTop(element) {
+  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var onlyWhenNeeded = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (!element) return;
+  var rect = element.getBoundingClientRect();
+  var pageYOffset = window.pageYOffset;
+  var top = rect.top + pageYOffset;
+  var style = window.getComputedStyle(element);
+  var scrollMarginTop = parseInt(style.getPropertyValue('scroll-margin-top')) || parseInt(style.getPropertyValue('scroll-snap-margin-top')) || 0;
+  var newPosition = top - scrollMarginTop + offset;
+  // don't scroll if the element is already visible in the first half of the screen
+  if (onlyWhenNeeded) {
+    var isVisible = newPosition >= pageYOffset && newPosition + rect.height < pageYOffset + window.innerHeight / 2;
+    if (isVisible) {
+      return;
+    }
+  }
+  window.scrollTo({
+    top: newPosition,
+    left: 0,
+    behavior: 'smooth'
+  });
+};
+exports.scrollWithMarginTop = scrollWithMarginTop;

package/dist/cjs/utils/onReady.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.onReady = exports.onInteractive = exports.onComplete = exports.onReadyState = void 0;
+/**
+ * Run a callback when the document.readyState has a certain value
+ * @param {string|string[]} state - the state(s) when to run the callback
+ * @param {Function} callback - the callback to run
+ */
+var onReadyState = function onReadyState(state, callback) {
+  var validStates = Array.isArray(state) ? state : [state];
+  var _checkAndRun = function checkAndRun() {
+    if (validStates.includes(document.readyState)) {
+      document.removeEventListener('readystatechange', _checkAndRun);
+      callback();
+      return true;
+    }
+    return false;
+  };
+  if (!_checkAndRun()) {
+    document.addEventListener('readystatechange', _checkAndRun);
+  }
+};
+exports.onReadyState = onReadyState;
+/**
+ * Run a callback when the document.readyState is 'complete'
+ * (DOM + assets are loaded)
+ * @param {Function} callback - the callback to run
+ */
+var onComplete = function onComplete(callback) {
+  return (0, exports.onReadyState)('complete', callback);
+};
+exports.onComplete = onComplete;
+/**
+ * Run a callback when the document.readyState is 'interactive'
+ * (DOM is loaded - equivalent to DOMContentLoaded)
+ * @param {Function} callback - the callback to run
+ */
+var onInteractive = function onInteractive(callback) {
+  return (0, exports.onReadyState)(['interactive', 'complete'], callback);
+};
+exports.onInteractive = onInteractive;
+exports.onReady = exports.onInteractive;
+exports["default"] = exports.onReady;