@depup/react-virtualized 9.22.6-depup.0

package/dist/commonjs/vendor/detectElementResize.js

@@ -0,0 +1,192 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = createDetectElementResize;
+/**
+ * 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
+ **/
+
+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
+  };
+}

package/dist/commonjs/vendor/intervalTree.js

@@ -0,0 +1,361 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = createWrapper;
+var _binarySearchBounds = _interopRequireDefault(require("./binarySearchBounds"));
+/**
+ * Binary Search Bounds
+ * https://github.com/mikolalysenko/interval-tree-1d
+ * Mikola Lysenko
+ *
+ * Inlined because of Content Security Policy issue caused by the use of `new Function(...)` syntax in an upstream dependency.
+ * Issue reported here: https://github.com/mikolalysenko/binary-search-bounds/issues/5
+ **/
+
+var NOT_FOUND = 0;
+var SUCCESS = 1;
+var EMPTY = 2;
+function IntervalTreeNode(mid, left, right, leftPoints, rightPoints) {
+  this.mid = mid;
+  this.left = left;
+  this.right = right;
+  this.leftPoints = leftPoints;
+  this.rightPoints = rightPoints;
+  this.count = (left ? left.count : 0) + (right ? right.count : 0) + leftPoints.length;
+}
+var proto = IntervalTreeNode.prototype;
+function copy(a, b) {
+  a.mid = b.mid;
+  a.left = b.left;
+  a.right = b.right;
+  a.leftPoints = b.leftPoints;
+  a.rightPoints = b.rightPoints;
+  a.count = b.count;
+}
+function rebuild(node, intervals) {
+  var ntree = createIntervalTree(intervals);
+  node.mid = ntree.mid;
+  node.left = ntree.left;
+  node.right = ntree.right;
+  node.leftPoints = ntree.leftPoints;
+  node.rightPoints = ntree.rightPoints;
+  node.count = ntree.count;
+}
+function rebuildWithInterval(node, interval) {
+  var intervals = node.intervals([]);
+  intervals.push(interval);
+  rebuild(node, intervals);
+}
+function rebuildWithoutInterval(node, interval) {
+  var intervals = node.intervals([]);
+  var idx = intervals.indexOf(interval);
+  if (idx < 0) {
+    return NOT_FOUND;
+  }
+  intervals.splice(idx, 1);
+  rebuild(node, intervals);
+  return SUCCESS;
+}
+proto.intervals = function (result) {
+  result.push.apply(result, this.leftPoints);
+  if (this.left) {
+    this.left.intervals(result);
+  }
+  if (this.right) {
+    this.right.intervals(result);
+  }
+  return result;
+};
+proto.insert = function (interval) {
+  var weight = this.count - this.leftPoints.length;
+  this.count += 1;
+  if (interval[1] < this.mid) {
+    if (this.left) {
+      if (4 * (this.left.count + 1) > 3 * (weight + 1)) {
+        rebuildWithInterval(this, interval);
+      } else {
+        this.left.insert(interval);
+      }
+    } else {
+      this.left = createIntervalTree([interval]);
+    }
+  } else if (interval[0] > this.mid) {
+    if (this.right) {
+      if (4 * (this.right.count + 1) > 3 * (weight + 1)) {
+        rebuildWithInterval(this, interval);
+      } else {
+        this.right.insert(interval);
+      }
+    } else {
+      this.right = createIntervalTree([interval]);
+    }
+  } else {
+    var l = _binarySearchBounds["default"].ge(this.leftPoints, interval, compareBegin);
+    var r = _binarySearchBounds["default"].ge(this.rightPoints, interval, compareEnd);
+    this.leftPoints.splice(l, 0, interval);
+    this.rightPoints.splice(r, 0, interval);
+  }
+};
+proto.remove = function (interval) {
+  var weight = this.count - this.leftPoints;
+  if (interval[1] < this.mid) {
+    if (!this.left) {
+      return NOT_FOUND;
+    }
+    var rw = this.right ? this.right.count : 0;
+    if (4 * rw > 3 * (weight - 1)) {
+      return rebuildWithoutInterval(this, interval);
+    }
+    var r = this.left.remove(interval);
+    if (r === EMPTY) {
+      this.left = null;
+      this.count -= 1;
+      return SUCCESS;
+    } else if (r === SUCCESS) {
+      this.count -= 1;
+    }
+    return r;
+  } else if (interval[0] > this.mid) {
+    if (!this.right) {
+      return NOT_FOUND;
+    }
+    var lw = this.left ? this.left.count : 0;
+    if (4 * lw > 3 * (weight - 1)) {
+      return rebuildWithoutInterval(this, interval);
+    }
+    var r = this.right.remove(interval);
+    if (r === EMPTY) {
+      this.right = null;
+      this.count -= 1;
+      return SUCCESS;
+    } else if (r === SUCCESS) {
+      this.count -= 1;
+    }
+    return r;
+  } else {
+    if (this.count === 1) {
+      if (this.leftPoints[0] === interval) {
+        return EMPTY;
+      } else {
+        return NOT_FOUND;
+      }
+    }
+    if (this.leftPoints.length === 1 && this.leftPoints[0] === interval) {
+      if (this.left && this.right) {
+        var p = this;
+        var n = this.left;
+        while (n.right) {
+          p = n;
+          n = n.right;
+        }
+        if (p === this) {
+          n.right = this.right;
+        } else {
+          var l = this.left;
+          var r = this.right;
+          p.count -= n.count;
+          p.right = n.left;
+          n.left = l;
+          n.right = r;
+        }
+        copy(this, n);
+        this.count = (this.left ? this.left.count : 0) + (this.right ? this.right.count : 0) + this.leftPoints.length;
+      } else if (this.left) {
+        copy(this, this.left);
+      } else {
+        copy(this, this.right);
+      }
+      return SUCCESS;
+    }
+    for (var l = _binarySearchBounds["default"].ge(this.leftPoints, interval, compareBegin); l < this.leftPoints.length; ++l) {
+      if (this.leftPoints[l][0] !== interval[0]) {
+        break;
+      }
+      if (this.leftPoints[l] === interval) {
+        this.count -= 1;
+        this.leftPoints.splice(l, 1);
+        for (var r = _binarySearchBounds["default"].ge(this.rightPoints, interval, compareEnd); r < this.rightPoints.length; ++r) {
+          if (this.rightPoints[r][1] !== interval[1]) {
+            break;
+          } else if (this.rightPoints[r] === interval) {
+            this.rightPoints.splice(r, 1);
+            return SUCCESS;
+          }
+        }
+      }
+    }
+    return NOT_FOUND;
+  }
+};
+function reportLeftRange(arr, hi, cb) {
+  for (var i = 0; i < arr.length && arr[i][0] <= hi; ++i) {
+    var r = cb(arr[i]);
+    if (r) {
+      return r;
+    }
+  }
+}
+function reportRightRange(arr, lo, cb) {
+  for (var i = arr.length - 1; i >= 0 && arr[i][1] >= lo; --i) {
+    var r = cb(arr[i]);
+    if (r) {
+      return r;
+    }
+  }
+}
+function reportRange(arr, cb) {
+  for (var i = 0; i < arr.length; ++i) {
+    var r = cb(arr[i]);
+    if (r) {
+      return r;
+    }
+  }
+}
+proto.queryPoint = function (x, cb) {
+  if (x < this.mid) {
+    if (this.left) {
+      var r = this.left.queryPoint(x, cb);
+      if (r) {
+        return r;
+      }
+    }
+    return reportLeftRange(this.leftPoints, x, cb);
+  } else if (x > this.mid) {
+    if (this.right) {
+      var r = this.right.queryPoint(x, cb);
+      if (r) {
+        return r;
+      }
+    }
+    return reportRightRange(this.rightPoints, x, cb);
+  } else {
+    return reportRange(this.leftPoints, cb);
+  }
+};
+proto.queryInterval = function (lo, hi, cb) {
+  if (lo < this.mid && this.left) {
+    var r = this.left.queryInterval(lo, hi, cb);
+    if (r) {
+      return r;
+    }
+  }
+  if (hi > this.mid && this.right) {
+    var r = this.right.queryInterval(lo, hi, cb);
+    if (r) {
+      return r;
+    }
+  }
+  if (hi < this.mid) {
+    return reportLeftRange(this.leftPoints, hi, cb);
+  } else if (lo > this.mid) {
+    return reportRightRange(this.rightPoints, lo, cb);
+  } else {
+    return reportRange(this.leftPoints, cb);
+  }
+};
+function compareNumbers(a, b) {
+  return a - b;
+}
+function compareBegin(a, b) {
+  var d = a[0] - b[0];
+  if (d) {
+    return d;
+  }
+  return a[1] - b[1];
+}
+function compareEnd(a, b) {
+  var d = a[1] - b[1];
+  if (d) {
+    return d;
+  }
+  return a[0] - b[0];
+}
+function createIntervalTree(intervals) {
+  if (intervals.length === 0) {
+    return null;
+  }
+  var pts = [];
+  for (var i = 0; i < intervals.length; ++i) {
+    pts.push(intervals[i][0], intervals[i][1]);
+  }
+  pts.sort(compareNumbers);
+  var mid = pts[pts.length >> 1];
+  var leftIntervals = [];
+  var rightIntervals = [];
+  var centerIntervals = [];
+  for (var i = 0; i < intervals.length; ++i) {
+    var s = intervals[i];
+    if (s[1] < mid) {
+      leftIntervals.push(s);
+    } else if (mid < s[0]) {
+      rightIntervals.push(s);
+    } else {
+      centerIntervals.push(s);
+    }
+  }
+
+  //Split center intervals
+  var leftPoints = centerIntervals;
+  var rightPoints = centerIntervals.slice();
+  leftPoints.sort(compareBegin);
+  rightPoints.sort(compareEnd);
+  return new IntervalTreeNode(mid, createIntervalTree(leftIntervals), createIntervalTree(rightIntervals), leftPoints, rightPoints);
+}
+
+//User friendly wrapper that makes it possible to support empty trees
+function IntervalTree(root) {
+  this.root = root;
+}
+var tproto = IntervalTree.prototype;
+tproto.insert = function (interval) {
+  if (this.root) {
+    this.root.insert(interval);
+  } else {
+    this.root = new IntervalTreeNode(interval[0], null, null, [interval], [interval]);
+  }
+};
+tproto.remove = function (interval) {
+  if (this.root) {
+    var r = this.root.remove(interval);
+    if (r === EMPTY) {
+      this.root = null;
+    }
+    return r !== NOT_FOUND;
+  }
+  return false;
+};
+tproto.queryPoint = function (p, cb) {
+  if (this.root) {
+    return this.root.queryPoint(p, cb);
+  }
+};
+tproto.queryInterval = function (lo, hi, cb) {
+  if (lo <= hi && this.root) {
+    return this.root.queryInterval(lo, hi, cb);
+  }
+};
+Object.defineProperty(tproto, 'count', {
+  get: function get() {
+    if (this.root) {
+      return this.root.count;
+    }
+    return 0;
+  }
+});
+Object.defineProperty(tproto, 'intervals', {
+  get: function get() {
+    if (this.root) {
+      return this.root.intervals([]);
+    }
+    return [];
+  }
+});
+function createWrapper(intervals) {
+  if (!intervals || intervals.length === 0) {
+    return new IntervalTree(null);
+  }
+  return new IntervalTree(createIntervalTree(intervals));
+}