@fangzhongya/page 0.0.31 → 0.0.32

package/dist/node_modules/.pnpm/element-resize-detector@1.2.4/node_modules/element-resize-detector/src/detection-strategy/scroll.js

@@ -0,0 +1,493 @@
+import "../../../../../../../_virtual/_commonjsHelpers.js";
+import { __require as requireCollectionUtils } from "../collection-utils.js";
+var scroll;
+var hasRequiredScroll;
+function requireScroll() {
+  if (hasRequiredScroll) return scroll;
+  hasRequiredScroll = 1;
+  "use strict";
+  var forEach = requireCollectionUtils().forEach;
+  scroll = function(options) {
+    options = options || {};
+    var reporter = options.reporter;
+    var batchProcessor = options.batchProcessor;
+    var getState = options.stateHandler.getState;
+    var hasState = options.stateHandler.hasState;
+    var idHandler = options.idHandler;
+    if (!batchProcessor) {
+      throw new Error("Missing required dependency: batchProcessor");
+    }
+    if (!reporter) {
+      throw new Error("Missing required dependency: reporter.");
+    }
+    var scrollbarSizes = getScrollbarSizes();
+    var styleId = "erd_scroll_detection_scrollbar_style";
+    var detectionContainerClass = "erd_scroll_detection_container";
+    function initDocument(targetDocument) {
+      injectScrollStyle(targetDocument, styleId, detectionContainerClass);
+    }
+    initDocument(window.document);
+    function buildCssTextString(rules) {
+      var seperator = options.important ? " !important; " : "; ";
+      return (rules.join(seperator) + seperator).trim();
+    }
+    function getScrollbarSizes() {
+      var width = 500;
+      var height = 500;
+      var child = document.createElement("div");
+      child.style.cssText = buildCssTextString(["position: absolute", "width: " + width * 2 + "px", "height: " + height * 2 + "px", "visibility: hidden", "margin: 0", "padding: 0"]);
+      var container = document.createElement("div");
+      container.style.cssText = buildCssTextString(["position: absolute", "width: " + width + "px", "height: " + height + "px", "overflow: scroll", "visibility: none", "top: " + -width * 3 + "px", "left: " + -height * 3 + "px", "visibility: hidden", "margin: 0", "padding: 0"]);
+      container.appendChild(child);
+      document.body.insertBefore(container, document.body.firstChild);
+      var widthSize = width - container.clientWidth;
+      var heightSize = height - container.clientHeight;
+      document.body.removeChild(container);
+      return {
+        width: widthSize,
+        height: heightSize
+      };
+    }
+    function injectScrollStyle(targetDocument, styleId2, containerClass) {
+      function injectStyle(style2, method) {
+        method = method || function(element) {
+          targetDocument.head.appendChild(element);
+        };
+        var styleElement = targetDocument.createElement("style");
+        styleElement.innerHTML = style2;
+        styleElement.id = styleId2;
+        method(styleElement);
+        return styleElement;
+      }
+      if (!targetDocument.getElementById(styleId2)) {
+        var containerAnimationClass = containerClass + "_animation";
+        var containerAnimationActiveClass = containerClass + "_animation_active";
+        var style = "/* Created by the element-resize-detector library. */\n";
+        style += "." + containerClass + " > div::-webkit-scrollbar { " + buildCssTextString(["display: none"]) + " }\n\n";
+        style += "." + containerAnimationActiveClass + " { " + buildCssTextString(["-webkit-animation-duration: 0.1s", "animation-duration: 0.1s", "-webkit-animation-name: " + containerAnimationClass, "animation-name: " + containerAnimationClass]) + " }\n";
+        style += "@-webkit-keyframes " + containerAnimationClass + " { 0% { opacity: 1; } 50% { opacity: 0; } 100% { opacity: 1; } }\n";
+        style += "@keyframes " + containerAnimationClass + " { 0% { opacity: 1; } 50% { opacity: 0; } 100% { opacity: 1; } }";
+        injectStyle(style);
+      }
+    }
+    function addAnimationClass(element) {
+      element.className += " " + detectionContainerClass + "_animation_active";
+    }
+    function addEvent(el, name, cb) {
+      if (el.addEventListener) {
+        el.addEventListener(name, cb);
+      } else if (el.attachEvent) {
+        el.attachEvent("on" + name, cb);
+      } else {
+        return reporter.error("[scroll] Don't know how to add event listeners.");
+      }
+    }
+    function removeEvent(el, name, cb) {
+      if (el.removeEventListener) {
+        el.removeEventListener(name, cb);
+      } else if (el.detachEvent) {
+        el.detachEvent("on" + name, cb);
+      } else {
+        return reporter.error("[scroll] Don't know how to remove event listeners.");
+      }
+    }
+    function getExpandElement(element) {
+      return getState(element).container.childNodes[0].childNodes[0].childNodes[0];
+    }
+    function getShrinkElement(element) {
+      return getState(element).container.childNodes[0].childNodes[0].childNodes[1];
+    }
+    function addListener(element, listener) {
+      var listeners = getState(element).listeners;
+      if (!listeners.push) {
+        throw new Error("Cannot add listener to an element that is not detectable.");
+      }
+      getState(element).listeners.push(listener);
+    }
+    function makeDetectable(options2, element, callback) {
+      if (!callback) {
+        callback = element;
+        element = options2;
+        options2 = null;
+      }
+      options2 = options2 || {};
+      function debug() {
+        if (options2.debug) {
+          var args = Array.prototype.slice.call(arguments);
+          args.unshift(idHandler.get(element), "Scroll: ");
+          if (reporter.log.apply) {
+            reporter.log.apply(null, args);
+          } else {
+            for (var i = 0; i < args.length; i++) {
+              reporter.log(args[i]);
+            }
+          }
+        }
+      }
+      function isDetached(element2) {
+        function isInDocument(element3) {
+          var isInShadowRoot = element3.getRootNode && element3.getRootNode().contains(element3);
+          return element3 === element3.ownerDocument.body || element3.ownerDocument.body.contains(element3) || isInShadowRoot;
+        }
+        if (!isInDocument(element2)) {
+          return true;
+        }
+        if (window.getComputedStyle(element2) === null) {
+          return true;
+        }
+        return false;
+      }
+      function isUnrendered(element2) {
+        var container = getState(element2).container.childNodes[0];
+        var style = window.getComputedStyle(container);
+        return !style.width || style.width.indexOf("px") === -1;
+      }
+      function getStyle() {
+        var elementStyle = window.getComputedStyle(element);
+        var style = {};
+        style.position = elementStyle.position;
+        style.width = element.offsetWidth;
+        style.height = element.offsetHeight;
+        style.top = elementStyle.top;
+        style.right = elementStyle.right;
+        style.bottom = elementStyle.bottom;
+        style.left = elementStyle.left;
+        style.widthCSS = elementStyle.width;
+        style.heightCSS = elementStyle.height;
+        return style;
+      }
+      function storeStartSize() {
+        var style = getStyle();
+        getState(element).startSize = {
+          width: style.width,
+          height: style.height
+        };
+        debug("Element start size", getState(element).startSize);
+      }
+      function initListeners() {
+        getState(element).listeners = [];
+      }
+      function storeStyle() {
+        debug("storeStyle invoked.");
+        if (!getState(element)) {
+          debug("Aborting because element has been uninstalled");
+          return;
+        }
+        var style = getStyle();
+        getState(element).style = style;
+      }
+      function storeCurrentSize(element2, width, height) {
+        getState(element2).lastWidth = width;
+        getState(element2).lastHeight = height;
+      }
+      function getExpandChildElement(element2) {
+        return getExpandElement(element2).childNodes[0];
+      }
+      function getWidthOffset() {
+        return 2 * scrollbarSizes.width + 1;
+      }
+      function getHeightOffset() {
+        return 2 * scrollbarSizes.height + 1;
+      }
+      function getExpandWidth(width) {
+        return width + 10 + getWidthOffset();
+      }
+      function getExpandHeight(height) {
+        return height + 10 + getHeightOffset();
+      }
+      function getShrinkWidth(width) {
+        return width * 2 + getWidthOffset();
+      }
+      function getShrinkHeight(height) {
+        return height * 2 + getHeightOffset();
+      }
+      function positionScrollbars(element2, width, height) {
+        var expand = getExpandElement(element2);
+        var shrink = getShrinkElement(element2);
+        var expandWidth = getExpandWidth(width);
+        var expandHeight = getExpandHeight(height);
+        var shrinkWidth = getShrinkWidth(width);
+        var shrinkHeight = getShrinkHeight(height);
+        expand.scrollLeft = expandWidth;
+        expand.scrollTop = expandHeight;
+        shrink.scrollLeft = shrinkWidth;
+        shrink.scrollTop = shrinkHeight;
+      }
+      function injectContainerElement() {
+        var container = getState(element).container;
+        if (!container) {
+          container = document.createElement("div");
+          container.className = detectionContainerClass;
+          container.style.cssText = buildCssTextString(["visibility: hidden", "display: inline", "width: 0px", "height: 0px", "z-index: -1", "overflow: hidden", "margin: 0", "padding: 0"]);
+          getState(element).container = container;
+          addAnimationClass(container);
+          element.appendChild(container);
+          var onAnimationStart = function() {
+            getState(element).onRendered && getState(element).onRendered();
+          };
+          addEvent(container, "animationstart", onAnimationStart);
+          getState(element).onAnimationStart = onAnimationStart;
+        }
+        return container;
+      }
+      function injectScrollElements() {
+        function alterPositionStyles() {
+          var style = getState(element).style;
+          if (style.position === "static") {
+            element.style.setProperty("position", "relative", options2.important ? "important" : "");
+            var removeRelativeStyles = function(reporter2, element2, style2, property) {
+              function getNumericalValue(value2) {
+                return value2.replace(/[^-\d\.]/g, "");
+              }
+              var value = style2[property];
+              if (value !== "auto" && getNumericalValue(value) !== "0") {
+                reporter2.warn("An element that is positioned static has style." + property + "=" + value + " which is ignored due to the static positioning. The element will need to be positioned relative, so the style." + property + " will be set to 0. Element: ", element2);
+                element2.style[property] = 0;
+              }
+            };
+            removeRelativeStyles(reporter, element, style, "top");
+            removeRelativeStyles(reporter, element, style, "right");
+            removeRelativeStyles(reporter, element, style, "bottom");
+            removeRelativeStyles(reporter, element, style, "left");
+          }
+        }
+        function getLeftTopBottomRightCssText(left, top, bottom, right) {
+          left = !left ? "0" : left + "px";
+          top = !top ? "0" : top + "px";
+          bottom = !bottom ? "0" : bottom + "px";
+          right = !right ? "0" : right + "px";
+          return ["left: " + left, "top: " + top, "right: " + right, "bottom: " + bottom];
+        }
+        debug("Injecting elements");
+        if (!getState(element)) {
+          debug("Aborting because element has been uninstalled");
+          return;
+        }
+        alterPositionStyles();
+        var rootContainer = getState(element).container;
+        if (!rootContainer) {
+          rootContainer = injectContainerElement();
+        }
+        var scrollbarWidth = scrollbarSizes.width;
+        var scrollbarHeight = scrollbarSizes.height;
+        var containerContainerStyle = buildCssTextString(["position: absolute", "flex: none", "overflow: hidden", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%", "left: 0px", "top: 0px"]);
+        var containerStyle = buildCssTextString(["position: absolute", "flex: none", "overflow: hidden", "z-index: -1", "visibility: hidden"].concat(getLeftTopBottomRightCssText(-(1 + scrollbarWidth), -(1 + scrollbarHeight), -scrollbarHeight, -scrollbarWidth)));
+        var expandStyle = buildCssTextString(["position: absolute", "flex: none", "overflow: scroll", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%"]);
+        var shrinkStyle = buildCssTextString(["position: absolute", "flex: none", "overflow: scroll", "z-index: -1", "visibility: hidden", "width: 100%", "height: 100%"]);
+        var expandChildStyle = buildCssTextString(["position: absolute", "left: 0", "top: 0"]);
+        var shrinkChildStyle = buildCssTextString(["position: absolute", "width: 200%", "height: 200%"]);
+        var containerContainer = document.createElement("div");
+        var container = document.createElement("div");
+        var expand = document.createElement("div");
+        var expandChild = document.createElement("div");
+        var shrink = document.createElement("div");
+        var shrinkChild = document.createElement("div");
+        containerContainer.dir = "ltr";
+        containerContainer.style.cssText = containerContainerStyle;
+        containerContainer.className = detectionContainerClass;
+        container.className = detectionContainerClass;
+        container.style.cssText = containerStyle;
+        expand.style.cssText = expandStyle;
+        expandChild.style.cssText = expandChildStyle;
+        shrink.style.cssText = shrinkStyle;
+        shrinkChild.style.cssText = shrinkChildStyle;
+        expand.appendChild(expandChild);
+        shrink.appendChild(shrinkChild);
+        container.appendChild(expand);
+        container.appendChild(shrink);
+        containerContainer.appendChild(container);
+        rootContainer.appendChild(containerContainer);
+        function onExpandScroll() {
+          var state = getState(element);
+          if (state && state.onExpand) {
+            state.onExpand();
+          } else {
+            debug("Aborting expand scroll handler: element has been uninstalled");
+          }
+        }
+        function onShrinkScroll() {
+          var state = getState(element);
+          if (state && state.onShrink) {
+            state.onShrink();
+          } else {
+            debug("Aborting shrink scroll handler: element has been uninstalled");
+          }
+        }
+        addEvent(expand, "scroll", onExpandScroll);
+        addEvent(shrink, "scroll", onShrinkScroll);
+        getState(element).onExpandScroll = onExpandScroll;
+        getState(element).onShrinkScroll = onShrinkScroll;
+      }
+      function registerListenersAndPositionElements() {
+        function updateChildSizes(element2, width, height) {
+          var expandChild = getExpandChildElement(element2);
+          var expandWidth = getExpandWidth(width);
+          var expandHeight = getExpandHeight(height);
+          expandChild.style.setProperty("width", expandWidth + "px", options2.important ? "important" : "");
+          expandChild.style.setProperty("height", expandHeight + "px", options2.important ? "important" : "");
+        }
+        function updateDetectorElements(done) {
+          var width = element.offsetWidth;
+          var height = element.offsetHeight;
+          var sizeChanged = width !== getState(element).lastWidth || height !== getState(element).lastHeight;
+          debug("Storing current size", width, height);
+          storeCurrentSize(element, width, height);
+          batchProcessor.add(0, function performUpdateChildSizes() {
+            if (!sizeChanged) {
+              return;
+            }
+            if (!getState(element)) {
+              debug("Aborting because element has been uninstalled");
+              return;
+            }
+            if (!areElementsInjected()) {
+              debug("Aborting because element container has not been initialized");
+              return;
+            }
+            if (options2.debug) {
+              var w = element.offsetWidth;
+              var h = element.offsetHeight;
+              if (w !== width || h !== height) {
+                reporter.warn(idHandler.get(element), "Scroll: Size changed before updating detector elements.");
+              }
+            }
+            updateChildSizes(element, width, height);
+          });
+          batchProcessor.add(1, function updateScrollbars() {
+            if (!getState(element)) {
+              debug("Aborting because element has been uninstalled");
+              return;
+            }
+            if (!areElementsInjected()) {
+              debug("Aborting because element container has not been initialized");
+              return;
+            }
+            positionScrollbars(element, width, height);
+          });
+          if (sizeChanged && done) {
+            batchProcessor.add(2, function() {
+              if (!getState(element)) {
+                debug("Aborting because element has been uninstalled");
+                return;
+              }
+              if (!areElementsInjected()) {
+                debug("Aborting because element container has not been initialized");
+                return;
+              }
+              done();
+            });
+          }
+        }
+        function areElementsInjected() {
+          return !!getState(element).container;
+        }
+        function notifyListenersIfNeeded() {
+          function isFirstNotify() {
+            return getState(element).lastNotifiedWidth === void 0;
+          }
+          debug("notifyListenersIfNeeded invoked");
+          var state = getState(element);
+          if (isFirstNotify() && state.lastWidth === state.startSize.width && state.lastHeight === state.startSize.height) {
+            return debug("Not notifying: Size is the same as the start size, and there has been no notification yet.");
+          }
+          if (state.lastWidth === state.lastNotifiedWidth && state.lastHeight === state.lastNotifiedHeight) {
+            return debug("Not notifying: Size already notified");
+          }
+          debug("Current size not notified, notifying...");
+          state.lastNotifiedWidth = state.lastWidth;
+          state.lastNotifiedHeight = state.lastHeight;
+          forEach(getState(element).listeners, function(listener) {
+            listener(element);
+          });
+        }
+        function handleRender() {
+          debug("startanimation triggered.");
+          if (isUnrendered(element)) {
+            debug("Ignoring since element is still unrendered...");
+            return;
+          }
+          debug("Element rendered.");
+          var expand = getExpandElement(element);
+          var shrink = getShrinkElement(element);
+          if (expand.scrollLeft === 0 || expand.scrollTop === 0 || shrink.scrollLeft === 0 || shrink.scrollTop === 0) {
+            debug("Scrollbars out of sync. Updating detector elements...");
+            updateDetectorElements(notifyListenersIfNeeded);
+          }
+        }
+        function handleScroll() {
+          debug("Scroll detected.");
+          if (isUnrendered(element)) {
+            debug("Scroll event fired while unrendered. Ignoring...");
+            return;
+          }
+          updateDetectorElements(notifyListenersIfNeeded);
+        }
+        debug("registerListenersAndPositionElements invoked.");
+        if (!getState(element)) {
+          debug("Aborting because element has been uninstalled");
+          return;
+        }
+        getState(element).onRendered = handleRender;
+        getState(element).onExpand = handleScroll;
+        getState(element).onShrink = handleScroll;
+        var style = getState(element).style;
+        updateChildSizes(element, style.width, style.height);
+      }
+      function finalizeDomMutation() {
+        debug("finalizeDomMutation invoked.");
+        if (!getState(element)) {
+          debug("Aborting because element has been uninstalled");
+          return;
+        }
+        var style = getState(element).style;
+        storeCurrentSize(element, style.width, style.height);
+        positionScrollbars(element, style.width, style.height);
+      }
+      function ready() {
+        callback(element);
+      }
+      function install() {
+        debug("Installing...");
+        initListeners();
+        storeStartSize();
+        batchProcessor.add(0, storeStyle);
+        batchProcessor.add(1, injectScrollElements);
+        batchProcessor.add(2, registerListenersAndPositionElements);
+        batchProcessor.add(3, finalizeDomMutation);
+        batchProcessor.add(4, ready);
+      }
+      debug("Making detectable...");
+      if (isDetached(element)) {
+        debug("Element is detached");
+        injectContainerElement();
+        debug("Waiting until element is attached...");
+        getState(element).onRendered = function() {
+          debug("Element is now attached");
+          install();
+        };
+      } else {
+        install();
+      }
+    }
+    function uninstall(element) {
+      var state = getState(element);
+      if (!state) {
+        return;
+      }
+      state.onExpandScroll && removeEvent(getExpandElement(element), "scroll", state.onExpandScroll);
+      state.onShrinkScroll && removeEvent(getShrinkElement(element), "scroll", state.onShrinkScroll);
+      state.onAnimationStart && removeEvent(state.container, "animationstart", state.onAnimationStart);
+      state.container && element.removeChild(state.container);
+    }
+    return {
+      makeDetectable,
+      addListener,
+      uninstall,
+      initDocument
+    };
+  };
+  return scroll;
+}
+export {
+  requireScroll as __require
+};