@depup/react-virtualized 9.22.6-depup.0

package/dist/es/utils/requestAnimationTimeout.js

@@ -0,0 +1,32 @@
+import { caf, raf } from './animationFrame';
+/*:: export type AnimationTimeoutId = {
+  id: number,
+};*/
+export var cancelAnimationTimeout = function cancelAnimationTimeout(frame /*: AnimationTimeoutId*/) {
+  return caf(frame.id);
+};
+
+/**
+ * Recursively calls requestAnimationFrame until a specified delay has been met or exceeded.
+ * When the delay time has been reached the function you're timing out will be called.
+ *
+ * Credit: Joe Lambert (https://gist.github.com/joelambert/1002116#file-requesttimeout-js)
+ */
+export var requestAnimationTimeout = function requestAnimationTimeout(callback /*: Function*/, delay /*: number*/) /*: AnimationTimeoutId*/{
+  var start;
+  // wait for end of processing current event handler, because event handler may be long
+  Promise.resolve().then(function () {
+    start = Date.now();
+  });
+  var _timeout = function timeout() {
+    if (Date.now() - start >= delay) {
+      callback.call();
+    } else {
+      frame.id = raf(_timeout);
+    }
+  };
+  var frame /*: AnimationTimeoutId*/ = {
+    id: raf(_timeout)
+  };
+  return frame;
+};

package/dist/es/vendor/binarySearchBounds.js

@@ -0,0 +1,194 @@
+/**
+ * Binary Search Bounds
+ * https://github.com/mikolalysenko/binary-search-bounds
+ * Mikola Lysenko
+ *
+ * Inlined because of Content Security Policy issue caused by the use of `new Function(...)` syntax.
+ * Issue reported here: https://github.com/mikolalysenko/binary-search-bounds/issues/5
+ **/
+
+function _GEA(a, l, h, y) {
+  var i = h + 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (x >= y) {
+      i = m;
+      h = m - 1;
+    } else {
+      l = m + 1;
+    }
+  }
+  return i;
+}
+function _GEP(a, l, h, y, c) {
+  var i = h + 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (c(x, y) >= 0) {
+      i = m;
+      h = m - 1;
+    } else {
+      l = m + 1;
+    }
+  }
+  return i;
+}
+function dispatchBsearchGE(a, y, c, l, h) {
+  if (typeof c === 'function') {
+    return _GEP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);
+  } else {
+    return _GEA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);
+  }
+}
+function _GTA(a, l, h, y) {
+  var i = h + 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (x > y) {
+      i = m;
+      h = m - 1;
+    } else {
+      l = m + 1;
+    }
+  }
+  return i;
+}
+function _GTP(a, l, h, y, c) {
+  var i = h + 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (c(x, y) > 0) {
+      i = m;
+      h = m - 1;
+    } else {
+      l = m + 1;
+    }
+  }
+  return i;
+}
+function dispatchBsearchGT(a, y, c, l, h) {
+  if (typeof c === 'function') {
+    return _GTP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);
+  } else {
+    return _GTA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);
+  }
+}
+function _LTA(a, l, h, y) {
+  var i = l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (x < y) {
+      i = m;
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return i;
+}
+function _LTP(a, l, h, y, c) {
+  var i = l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (c(x, y) < 0) {
+      i = m;
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return i;
+}
+function dispatchBsearchLT(a, y, c, l, h) {
+  if (typeof c === 'function') {
+    return _LTP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);
+  } else {
+    return _LTA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);
+  }
+}
+function _LEA(a, l, h, y) {
+  var i = l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (x <= y) {
+      i = m;
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return i;
+}
+function _LEP(a, l, h, y, c) {
+  var i = l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (c(x, y) <= 0) {
+      i = m;
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return i;
+}
+function dispatchBsearchLE(a, y, c, l, h) {
+  if (typeof c === 'function') {
+    return _LEP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);
+  } else {
+    return _LEA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);
+  }
+}
+function _EQA(a, l, h, y) {
+  l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    if (x === y) {
+      return m;
+    } else if (x <= y) {
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return -1;
+}
+function _EQP(a, l, h, y, c) {
+  l - 1;
+  while (l <= h) {
+    var m = l + h >>> 1,
+      x = a[m];
+    var p = c(x, y);
+    if (p === 0) {
+      return m;
+    } else if (p <= 0) {
+      l = m + 1;
+    } else {
+      h = m - 1;
+    }
+  }
+  return -1;
+}
+function dispatchBsearchEQ(a, y, c, l, h) {
+  if (typeof c === 'function') {
+    return _EQP(a, l === void 0 ? 0 : l | 0, h === void 0 ? a.length - 1 : h | 0, y, c);
+  } else {
+    return _EQA(a, c === void 0 ? 0 : c | 0, l === void 0 ? a.length - 1 : l | 0, y);
+  }
+}
+export default {
+  ge: dispatchBsearchGE,
+  gt: dispatchBsearchGT,
+  lt: dispatchBsearchLT,
+  le: dispatchBsearchLE,
+  eq: dispatchBsearchEQ
+};

package/dist/es/vendor/detectElementResize.js

@@ -0,0 +1,186 @@
+/**
+ * Detect Element Resize.
+ * https://github.com/sdecima/javascript-detect-element-resize
+ * Sebastian Decima
+ *
+ * Forked from version 0.5.3; includes the following modifications:
+ * 1) Guard against unsafe 'window' and 'document' references (to support SSR).
+ * 2) Defer initialization code via a top-level function wrapper (to support SSR).
+ * 3) Avoid unnecessary reflows by not measuring size for scroll events bubbling from children.
+ * 4) Add nonce for style element.
+ * 5) Added support for injecting custom window object
+ **/
+
+export default function createDetectElementResize(nonce, hostWindow) {
+  // Check `document` and `window` in case of server-side rendering
+  var _window;
+  if (typeof hostWindow !== 'undefined') {
+    _window = hostWindow;
+  } else if (typeof window !== 'undefined') {
+    _window = window;
+  } else if (typeof self !== 'undefined') {
+    _window = self;
+  } else {
+    _window = global;
+  }
+  var attachEvent = typeof _window.document !== 'undefined' && _window.document.attachEvent;
+  if (!attachEvent) {
+    var requestFrame = function () {
+      var raf = _window.requestAnimationFrame || _window.mozRequestAnimationFrame || _window.webkitRequestAnimationFrame || function (fn) {
+        return _window.setTimeout(fn, 20);
+      };
+      return function (fn) {
+        return raf(fn);
+      };
+    }();
+    var cancelFrame = function () {
+      var cancel = _window.cancelAnimationFrame || _window.mozCancelAnimationFrame || _window.webkitCancelAnimationFrame || _window.clearTimeout;
+      return function (id) {
+        return cancel(id);
+      };
+    }();
+    var resetTriggers = function resetTriggers(element) {
+      var triggers = element.__resizeTriggers__,
+        expand = triggers.firstElementChild,
+        contract = triggers.lastElementChild,
+        expandChild = expand.firstElementChild;
+      contract.scrollLeft = contract.scrollWidth;
+      contract.scrollTop = contract.scrollHeight;
+      expandChild.style.width = expand.offsetWidth + 1 + 'px';
+      expandChild.style.height = expand.offsetHeight + 1 + 'px';
+      expand.scrollLeft = expand.scrollWidth;
+      expand.scrollTop = expand.scrollHeight;
+    };
+    var checkTriggers = function checkTriggers(element) {
+      return element.offsetWidth != element.__resizeLast__.width || element.offsetHeight != element.__resizeLast__.height;
+    };
+    var scrollListener = function scrollListener(e) {
+      // Don't measure (which forces) reflow for scrolls that happen inside of children!
+      if (e.target.className && typeof e.target.className.indexOf === 'function' && e.target.className.indexOf('contract-trigger') < 0 && e.target.className.indexOf('expand-trigger') < 0) {
+        return;
+      }
+      var element = this;
+      resetTriggers(this);
+      if (this.__resizeRAF__) {
+        cancelFrame(this.__resizeRAF__);
+      }
+      this.__resizeRAF__ = requestFrame(function () {
+        if (checkTriggers(element)) {
+          element.__resizeLast__.width = element.offsetWidth;
+          element.__resizeLast__.height = element.offsetHeight;
+          element.__resizeListeners__.forEach(function (fn) {
+            fn.call(element, e);
+          });
+        }
+      });
+    };
+
+    /* Detect CSS Animations support to detect element display/re-attach */
+    var animation = false,
+      keyframeprefix = '',
+      animationstartevent = 'animationstart',
+      domPrefixes = 'Webkit Moz O ms'.split(' '),
+      startEvents = 'webkitAnimationStart animationstart oAnimationStart MSAnimationStart'.split(' '),
+      pfx = '';
+    {
+      var elm = _window.document.createElement('fakeelement');
+      if (elm.style.animationName !== undefined) {
+        animation = true;
+      }
+      if (animation === false) {
+        for (var i = 0; i < domPrefixes.length; i++) {
+          if (elm.style[domPrefixes[i] + 'AnimationName'] !== undefined) {
+            pfx = domPrefixes[i];
+            keyframeprefix = '-' + pfx.toLowerCase() + '-';
+            animationstartevent = startEvents[i];
+            animation = true;
+            break;
+          }
+        }
+      }
+    }
+    var animationName = 'resizeanim';
+    var animationKeyframes = '@' + keyframeprefix + 'keyframes ' + animationName + ' { from { opacity: 0; } to { opacity: 0; } } ';
+    var animationStyle = keyframeprefix + 'animation: 1ms ' + animationName + '; ';
+  }
+  var createStyles = function createStyles(doc) {
+    if (!doc.getElementById('detectElementResize')) {
+      //opacity:0 works around a chrome bug https://code.google.com/p/chromium/issues/detail?id=286360
+      var css = (animationKeyframes ? animationKeyframes : '') + '.resize-triggers { ' + (animationStyle ? animationStyle : '') + 'visibility: hidden; opacity: 0; } ' + '.resize-triggers, .resize-triggers > div, .contract-trigger:before { content: " "; display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; z-index: -1; } .resize-triggers > div { background: #eee; overflow: auto; } .contract-trigger:before { width: 200%; height: 200%; }',
+        head = doc.head || doc.getElementsByTagName('head')[0],
+        style = doc.createElement('style');
+      style.id = 'detectElementResize';
+      style.type = 'text/css';
+      if (nonce != null) {
+        style.setAttribute('nonce', nonce);
+      }
+      if (style.styleSheet) {
+        style.styleSheet.cssText = css;
+      } else {
+        style.appendChild(doc.createTextNode(css));
+      }
+      head.appendChild(style);
+    }
+  };
+  var addResizeListener = function addResizeListener(element, fn) {
+    if (attachEvent) {
+      element.attachEvent('onresize', fn);
+    } else {
+      if (!element.__resizeTriggers__) {
+        var doc = element.ownerDocument;
+        var elementStyle = _window.getComputedStyle(element);
+        if (elementStyle && elementStyle.position == 'static') {
+          element.style.position = 'relative';
+        }
+        createStyles(doc);
+        element.__resizeLast__ = {};
+        element.__resizeListeners__ = [];
+        (element.__resizeTriggers__ = doc.createElement('div')).className = 'resize-triggers';
+        var expandTrigger = doc.createElement('div');
+        expandTrigger.className = 'expand-trigger';
+        expandTrigger.appendChild(doc.createElement('div'));
+        var contractTrigger = doc.createElement('div');
+        contractTrigger.className = 'contract-trigger';
+        element.__resizeTriggers__.appendChild(expandTrigger);
+        element.__resizeTriggers__.appendChild(contractTrigger);
+        element.appendChild(element.__resizeTriggers__);
+        resetTriggers(element);
+        element.addEventListener('scroll', scrollListener, true);
+
+        /* Listen for a css animation to detect element display/re-attach */
+        if (animationstartevent) {
+          element.__resizeTriggers__.__animationListener__ = function animationListener(e) {
+            if (e.animationName == animationName) {
+              resetTriggers(element);
+            }
+          };
+          element.__resizeTriggers__.addEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);
+        }
+      }
+      element.__resizeListeners__.push(fn);
+    }
+  };
+  var removeResizeListener = function removeResizeListener(element, fn) {
+    if (attachEvent) {
+      element.detachEvent('onresize', fn);
+    } else {
+      element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);
+      if (!element.__resizeListeners__.length) {
+        element.removeEventListener('scroll', scrollListener, true);
+        if (element.__resizeTriggers__.__animationListener__) {
+          element.__resizeTriggers__.removeEventListener(animationstartevent, element.__resizeTriggers__.__animationListener__);
+          element.__resizeTriggers__.__animationListener__ = null;
+        }
+        try {
+          element.__resizeTriggers__ = !element.removeChild(element.__resizeTriggers__);
+        } catch (e) {
+          // Preact compat; see developit/preact-compat/issues/228
+        }
+      }
+    }
+  };
+  return {
+    addResizeListener: addResizeListener,
+    removeResizeListener: removeResizeListener
+  };
+}