@smartimpact-it/scroll-utils 1.1.0

package/dist/cjs/utils/utils.js

@@ -0,0 +1,77 @@
+"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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isFunction = exports.debounce = exports.throttle = exports.deepEquals = void 0;
+// deep compare objects
+var deepEquals = function deepEquals(x, y) {
+  if (x === y) return true;
+  // if both x and y are null or undefined and exactly the same
+  if (!(x instanceof Object) || !(y instanceof Object)) return false;
+  // if they are not strictly equal, they both need to be Objects
+  if (x.constructor !== y.constructor) return false;
+  // they must have the exact same prototype chain, the closest we can do is
+  // test there constructor.
+  for (var p in x) {
+    if (!x.hasOwnProperty(p)) continue;
+    // other properties were tested using x.constructor === y.constructor
+    if (!y.hasOwnProperty(p)) return false;
+    // allows to compare x[ p ] and y[ p ] when set to undefined
+    if (x[p] === y[p]) continue;
+    // if they have the same strict value or identity then they are equal
+    if (_typeof(x[p]) !== 'object') return false;
+    // Numbers, Strings, Functions, Booleans must be strictly equal
+    if (!(0, exports.deepEquals)(x[p], y[p])) return false;
+    // Objects and Arrays must be tested recursively
+  }
+  for (var _p in y) {
+    if (y.hasOwnProperty(_p) && !x.hasOwnProperty(_p)) return false;
+    // allows x[ p ] to be set to undefined
+  }
+  return true;
+};
+exports.deepEquals = deepEquals;
+var throttle = function throttle(func) {
+  var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
+  var inThrottle;
+  return function () {
+    var args = arguments,
+      context = this;
+    if (!inThrottle) {
+      func.apply(context, args);
+      inThrottle = true;
+      setTimeout(function () {
+        return inThrottle = false;
+      }, limit);
+    }
+  };
+};
+exports.throttle = throttle;
+// Returns a function, that, as long as it continues to be invoked, will not
+// be triggered. The function will be called after it stops being called for
+// N milliseconds. If `immediate` is passed, trigger the function on the
+// leading edge, instead of the trailing.
+var debounce = function debounce(func, wait) {
+  var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var timeout;
+  return function () {
+    var context = this,
+      args = arguments;
+    var later = function later() {
+      timeout = null;
+      if (!immediate) func.apply(context, args);
+    };
+    var callNow = immediate && !timeout;
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+    if (callNow) func.apply(context, args);
+  };
+};
+exports.debounce = debounce;
+var isFunction = function isFunction(value) {
+  // from https://stackoverflow.com/a/55785839
+  return Boolean(value) && (Object.prototype.toString.call(value) === '[object Function]' || 'function' === typeof value || value instanceof Function);
+};
+exports.isFunction = isFunction;

package/dist/esm/Bootstrap4AccordionScrollIntoView.js

@@ -0,0 +1,57 @@
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+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 _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+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"); }
+import { scrollWithMarginTop } from './scrollWithMarginTop';
+import { onComplete } from './utils/onReady';
+/**
+ * Scroll to the opened accordion tab
+ */
+var _Bootstrap4AccordionScrollIntoView_brand = /*#__PURE__*/new WeakSet();
+var _handle = /*#__PURE__*/new WeakMap();
+export class Bootstrap4AccordionScrollIntoView {
+  constructor({
+    extraOffset = 0
+  } = {}) {
+    _classPrivateMethodInitSpec(this, _Bootstrap4AccordionScrollIntoView_brand);
+    _defineProperty(this, "extraOffset", void 0);
+    _classPrivateFieldInitSpec(this, _handle, e => {
+      var _target$closest;
+      let header = null;
+      const target = e.target;
+      // Skip scrolling if the clicked element or any of its parents has the class 'skip-scroll-into-view'.
+      if ((_target$closest = target.closest) !== null && _target$closest !== void 0 && _target$closest.call(target, '.skip-scroll-into-view, [data-skip-scroll-into-view]')) {
+        return;
+      }
+      const tabId = target.id;
+      const headerId = target.getAttribute('aria-labelledby');
+      if (headerId) {
+        header = document.querySelector(`#${headerId}`);
+      }
+      if (!header && tabId) {
+        header = document.querySelector(`[data-target="#${tabId}"]`);
+      }
+      if (header) {
+        scrollWithMarginTop(header, this.extraOffset, true);
+      }
+    });
+    this.extraOffset = extraOffset;
+    onComplete(() => setTimeout(() => _assertClassBrand(_Bootstrap4AccordionScrollIntoView_brand, this, _addEventListeners).call(this), 1000));
+  }
+}
+function _addEventListeners() {
+  if ('$' in window) {
+    window.$(document).on('shown.collapse', e => {
+      _classPrivateFieldGet(_handle, this).call(this, e);
+    });
+  } else {
+    document.addEventListener('shown.collapse', e => {
+      _classPrivateFieldGet(_handle, this).call(this, e);
+    });
+  }
+}
+export default Bootstrap4AccordionScrollIntoView;

package/dist/esm/BootstrapAccordionScrollIntoView.js

@@ -0,0 +1,51 @@
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+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 _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+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"); }
+import { scrollWithMarginTop } from './scrollWithMarginTop';
+import { onComplete } from './utils/onReady';
+/**
+ * Scroll to the opened accordion tab
+ */
+var _BootstrapAccordionScrollIntoView_brand = /*#__PURE__*/new WeakSet();
+var _handle = /*#__PURE__*/new WeakMap();
+export class BootstrapAccordionScrollIntoView {
+  constructor({
+    extraOffset = 0
+  } = {}) {
+    _classPrivateMethodInitSpec(this, _BootstrapAccordionScrollIntoView_brand);
+    _defineProperty(this, "extraOffset", void 0);
+    _classPrivateFieldInitSpec(this, _handle, e => {
+      var _target$closest;
+      let header = null;
+      const target = e.target;
+      // Skip scrolling if the clicked element or any of its parents has the class 'skip-scroll-into-view'.
+      if ((_target$closest = target.closest) !== null && _target$closest !== void 0 && _target$closest.call(target, '.skip-scroll-into-view, [data-skip-scroll-into-view]')) {
+        return;
+      }
+      const tabId = target.id;
+      const headerId = target.getAttribute('aria-labelledby');
+      if (headerId) {
+        header = document.querySelector(`#${headerId}`);
+      }
+      if (!header && tabId) {
+        header = document.querySelector(`[data-bs-target="#${tabId}"]`);
+      }
+      if (header) {
+        scrollWithMarginTop(header, this.extraOffset, true);
+      }
+    });
+    this.extraOffset = extraOffset;
+    onComplete(() => setTimeout(() => _assertClassBrand(_BootstrapAccordionScrollIntoView_brand, this, _addEventListeners).call(this), 1000));
+  }
+}
+function _addEventListeners() {
+  document.addEventListener('shown.bs.collapse', e => {
+    _classPrivateFieldGet(_handle, this).call(this, e);
+  });
+}
+export default BootstrapAccordionScrollIntoView;

package/dist/esm/FixHashScrollPosition.js

@@ -0,0 +1,24 @@
+import { scrollWithMarginTop } from './scrollWithMarginTop';
+/**
+ * Fix the scroll offset when loading a page with a #hash (anchor)
+ */
+export class FixHashScrollPosition {
+  constructor() {
+    // fix for scroll-margin-top
+    window.addEventListener('hashchange', () => {
+      const hash = window.location.hash;
+      if (!hash || hash === '#') {
+        return;
+      }
+      try {
+        const element = document.querySelector(hash);
+        if (element) {
+          setTimeout(() => scrollWithMarginTop(element));
+        }
+      } catch (e) {
+        console.warn(e);
+      }
+    }, false);
+  }
+}
+export default FixHashScrollPosition;

package/dist/esm/FoundationAccordionScrollIntoView.js

@@ -0,0 +1,35 @@
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+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 _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"); }
+import { scrollWithMarginTop } from './scrollWithMarginTop';
+import { onComplete } from './utils/onReady';
+/**
+ * Scroll to the opened accordion tab
+ */
+var _FoundationAccordionScrollIntoView_brand = /*#__PURE__*/new WeakSet();
+export class FoundationAccordionScrollIntoView {
+  constructor({
+    extraOffset = 0
+  } = {}) {
+    _classPrivateMethodInitSpec(this, _FoundationAccordionScrollIntoView_brand);
+    _defineProperty(this, "extraOffset", void 0);
+    this.extraOffset = extraOffset;
+    onComplete(() => setTimeout(() => _assertClassBrand(_FoundationAccordionScrollIntoView_brand, this, _addEventListeners).call(this), 1000));
+  }
+}
+function _addEventListeners() {
+  if (!('$' in window)) return;
+  window.$(document).on('down.zf.accordion', (e, $content) => {
+    var _target$closest;
+    const target = $content.get(0).parentNode;
+    // Skip scrolling if the clicked element or any of its parents has the class 'skip-scroll-into-view'.
+    if ((_target$closest = target.closest) !== null && _target$closest !== void 0 && _target$closest.call(target, '.skip-scroll-into-view, [data-skip-scroll-into-view]')) {
+      return;
+    }
+    scrollWithMarginTop(target, this.extraOffset, true);
+  });
+}
+export default FoundationAccordionScrollIntoView;

package/dist/esm/ScrollDirection.js

@@ -0,0 +1,98 @@
+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 _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 _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"); }
+import isFunction from 'lodash/isFunction';
+import throttle from 'lodash/throttle';
+var _lastScrollTop = /*#__PURE__*/new WeakMap();
+var _throttle = /*#__PURE__*/new WeakMap();
+var _throttleOptions = /*#__PURE__*/new WeakMap();
+var _ScrollDirection_brand = /*#__PURE__*/new WeakSet();
+export class ScrollDirection {
+  /**
+   * start an instance
+   * @param {{onlyFor: a callback to determine where to modify classes; threshold: amount in px to take into account }} param0
+   */
+  constructor({
+    onlyFor = null,
+    threshold = 0,
+    thresholdCallback = null,
+    throttle: _throttle2 = 16,
+    throttleOptions = {
+      trailing: false
+    }
+  } = {}) {
+    /**
+     * setup the scroll event listener
+     */
+    _classPrivateMethodInitSpec(this, _ScrollDirection_brand);
+    _defineProperty(this, "onlyForCallback", null);
+    _classPrivateFieldInitSpec(this, _lastScrollTop, 0);
+    _defineProperty(this, "threshold", 0);
+    _defineProperty(this, "thresholdCallback", null);
+    _classPrivateFieldInitSpec(this, _throttle, void 0);
+    _classPrivateFieldInitSpec(this, _throttleOptions, void 0);
+    this.onlyForCallback = onlyFor;
+    this.threshold = threshold;
+    this.thresholdCallback = thresholdCallback;
+    _classPrivateFieldSet(_throttle, this, _throttle2);
+    _classPrivateFieldSet(_throttleOptions, this, throttleOptions);
+    _classPrivateFieldSet(_lastScrollTop, this, window.pageYOffset || document.documentElement.scrollTop);
+    _assertClassBrand(_ScrollDirection_brand, this, _setupListeners).call(this);
+  }
+}
+function _setupListeners() {
+  const update = () => {
+    const isValid = !this.onlyForCallback || this.onlyForCallback();
+    if (!isValid) return;
+    _assertClassBrand(_ScrollDirection_brand, this, _determineDirection).call(this);
+  };
+  if (_classPrivateFieldGet(_throttle, this)) {
+    const throttledUpdate = throttle(update, _classPrivateFieldGet(_throttle, this), _classPrivateFieldGet(_throttleOptions, this) || {});
+    window.addEventListener('scroll', throttledUpdate, {
+      passive: true
+    });
+  } else {
+    window.addEventListener('scroll', update, {
+      passive: true
+    });
+  }
+}
+/**
+ * dispatch an event on the window
+ */
+function _dispatchEvent(name) {
+  requestAnimationFrame(() => {
+    window.dispatchEvent(new CustomEvent(name));
+  });
+}
+/**
+ * determine the scroll direction
+ */
+function _determineDirection() {
+  const body = document.body,
+    classList = body.classList;
+  const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+  const localThreshold = this.thresholdCallback && isFunction(this.thresholdCallback) ? this.thresholdCallback({
+    scrollTop,
+    threshold: this.threshold,
+    lastScrollTop: _classPrivateFieldGet(_lastScrollTop, this)
+  }) : this.threshold;
+  if (Math.abs(scrollTop - _classPrivateFieldGet(_lastScrollTop, this)) < localThreshold) return;
+  if (scrollTop > _classPrivateFieldGet(_lastScrollTop, this) + localThreshold && !classList.contains('scrolling-down')) {
+    classList.add('scrolling-down');
+    classList.remove('scrolling-up');
+    _assertClassBrand(_ScrollDirection_brand, this, _dispatchEvent).call(this, 'scrollDirectionChange');
+  } else if (scrollTop < _classPrivateFieldGet(_lastScrollTop, this) - localThreshold && !classList.contains('scrolling-up')) {
+    classList.add('scrolling-up');
+    classList.remove('scrolling-down');
+    _assertClassBrand(_ScrollDirection_brand, this, _dispatchEvent).call(this, 'scrollDirectionChange');
+  }
+  _classPrivateFieldSet(_lastScrollTop, this, Math.max(scrollTop, 0));
+}
+export default ScrollDirection;

package/dist/esm/ScrollOffset.js

@@ -0,0 +1,283 @@
+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 _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"); }
+import debounce from 'lodash/debounce';
+import isFunction from '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();
+export class ScrollOffsetPart {
+  constructor({
+    name = '',
+    selectors = [],
+    elements = [],
+    fixedHeight = false,
+    condition = false,
+    resizeCondition = false
+  }) {
+    _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", (element, height) => {
+      if (!element || !Number.isFinite(height) || height < 0) return;
+      _classPrivateFieldGet(_heightCache, this).set(element, Math.round(height));
+    });
+    _classPrivateFieldInitSpec(this, _getElementHeight, element => {
+      if (!element) return 0;
+      const cachedHeight = _classPrivateFieldGet(_heightCache, this).get(element);
+      if (cachedHeight !== undefined) return cachedHeight;
+      const measuredHeight = element.clientHeight || 0;
+      _classPrivateFieldGet(_heightCache, this).set(element, measuredHeight);
+      return measuredHeight;
+    });
+    _defineProperty(this, "calculate", () => {
+      var _classPrivateFieldGet2;
+      _classPrivateFieldSet(_isValid, this, !!((_classPrivateFieldGet2 = _classPrivateFieldGet(_elements, this)) !== null && _classPrivateFieldGet2 !== void 0 && _classPrivateFieldGet2.length));
+      if (_classPrivateFieldGet(_isValid, this) && _classPrivateFieldGet(_condition, this) && isFunction(_classPrivateFieldGet(_condition, this))) {
+        _classPrivateFieldSet(_isValid, this, _classPrivateFieldGet(_isValid, this) && _classPrivateFieldGet(_condition, this).call(this));
+      }
+      if (_classPrivateFieldGet(_isValid, this) && _classPrivateFieldGet(_resizeCondition, this) && isFunction(_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 {
+        let totalHeight = 0;
+        _classPrivateFieldGet(_elements, this).forEach(element => {
+          totalHeight += _classPrivateFieldGet(_getElementHeight, this).call(this, element);
+        });
+        _classPrivateFieldSet(_totalHeight, this, totalHeight);
+      }
+      return this;
+    });
+    _defineProperty(this, "calculateResizeConditions", () => {
+      if (_classPrivateFieldGet(_resizeCondition, this) && isFunction(_classPrivateFieldGet(_resizeCondition, this))) {
+        const 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(selector => {
+      const newElements = [...document.querySelectorAll(selector)];
+      if (newElements.length) {
+        _classPrivateFieldSet(_elements, this, [..._classPrivateFieldGet(_elements, this), ...newElements]);
+      }
+    });
+    this.calculate();
+  }
+  get name() {
+    return _classPrivateFieldGet(_name, this);
+  }
+  get totalHeight() {
+    return _classPrivateFieldGet(_totalHeight, this);
+  }
+  get isValid() {
+    return _classPrivateFieldGet(_isValid, this);
+  }
+  get elements() {
+    return _classPrivateFieldGet(_elements, this);
+  }
+}
+/**!
+ * 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();
+export class ScrollOffset {
+  /**
+   * setup the conditions
+   */
+  constructor({
+    offsetParts = [],
+    variables = [],
+    registerForHoudini = true,
+    useResizeObserver = true,
+    extraEvents = []
+  } = {}) {
+    _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, () => {
+      _classPrivateFieldGet(_variables, this).forEach(({
+        name
+      }) => {
+        window.CSS.registerProperty({
+          name: `--${name}`,
+          syntax: '<length>',
+          inherits: true,
+          initialValue: '0px'
+        });
+      });
+    });
+    /**
+     * calculate the offsets and set the css variables
+     */
+    _classPrivateFieldInitSpec(this, _calculateOffset, () => {
+      // calculate the conditions
+      _classPrivateFieldGet(_offsetParts, this).forEach(part => part.calculate());
+      // determine the css variables
+      const cssVariables = _classPrivateFieldGet(_variables, this).map(variable => {
+        const value = variable.offsetParts.reduce((acc, part) => {
+          if (typeof part == 'string') {
+            part = _classPrivateFieldGet(_offsetParts, this).find(partInfo => partInfo.name.localeCompare(part) == 0);
+          }
+          if (part && part.isValid) {
+            acc += part.totalHeight;
+          }
+          return acc;
+        }, 0);
+        return _objectSpread(_objectSpread({}, variable), {}, {
+          value
+        });
+      });
+      // output the variables
+      cssVariables.forEach(({
+        name,
+        value
+      }) => {
+        document.documentElement.style.setProperty(`--${name}`, `${value}px`);
+      });
+      document.body.dispatchEvent(new CustomEvent('ScrollOffsetChange', {
+        bubbles: true
+      }));
+    });
+    /**
+     * recalculate values for conditions that only depend on resize
+     */
+    _classPrivateFieldInitSpec(this, _calculateResizeConditions, () => {
+      _classPrivateFieldGet(_offsetParts, this).forEach(part => part.calculateResizeConditions());
+    });
+    _classPrivateFieldInitSpec(this, _debouncedCalculateOffset, debounce(_classPrivateFieldGet(_calculateOffset, this), 32));
+    _classPrivateFieldInitSpec(this, _debouncedCalculateResizeConditions, debounce(_classPrivateFieldGet(_calculateResizeConditions, this), 32));
+    _classPrivateFieldInitSpec(this, _scheduleCalculateOffset, () => {
+      if (_classPrivateFieldGet(_measureScheduled, this)) return;
+      _classPrivateFieldSet(_measureScheduled, this, true);
+      requestAnimationFrame(() => {
+        _classPrivateFieldSet(_measureScheduled, this, false);
+        _classPrivateFieldGet(_debouncedCalculateOffset, this).call(this);
+      });
+    });
+    /**
+     * setup event listeners
+     */
+    _classPrivateFieldInitSpec(this, _setupListeners, () => {
+      ['resize', 'orientationchange'].forEach(type => {
+        window.addEventListener(type, _classPrivateFieldGet(_debouncedCalculateResizeConditions, this));
+      });
+      ['resize', 'orientationchange', 'scrollDirectionChange', 'stickyIsPinned', 'stickyIsUnpinned', ..._classPrivateFieldGet(_extraEvents, this)].forEach(type => window.addEventListener(type, _classPrivateFieldGet(_scheduleCalculateOffset, this)));
+      // setup resizeObservers for the elements
+      if (_classPrivateFieldGet(_useResizeObserver, this)) {
+        const resizeObserver = new ResizeObserver(entries => {
+          entries.forEach(entry => {
+            var _entry$contentRect;
+            const target = entry.target;
+            const 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, this).forEach(part => {
+              if (part.elements.includes(target)) {
+                part.setElementHeight(target, height);
+              }
+            });
+          });
+          _classPrivateFieldGet(_scheduleCalculateOffset, this).call(this);
+        });
+        _classPrivateFieldGet(_offsetParts, this).forEach(part => part.elements.forEach(element => resizeObserver.observe(element)));
+      }
+    });
+    // parse the variables
+    if (Array.isArray(variables)) {
+      _classPrivateFieldSet(_variables, this, variables);
+    } else {
+      _classPrivateFieldSet(_variables, this, Object.entries(variables).map(([key, value]) => {
+        return {
+          name: key,
+          offsetParts: value
+        };
+      }));
+    }
+    // take the offset parts from the variables
+    const variableOffsetParts = _classPrivateFieldGet(_variables, this).map(({
+      offsetParts
+    }) => {
+      return offsetParts.filter(part => part instanceof ScrollOffsetPart);
+    }).flat(1);
+    // merge with the settings and keep only distinct elements
+    offsetParts = [...new Set([...offsetParts, ...variableOffsetParts])];
+    // parse the offset parts
+    _classPrivateFieldSet(_offsetParts, this, offsetParts.map(part => {
+      let 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);
+  }
+}
+export default ScrollOffset;