@antv/l7-map 2.18.2 → 2.18.3

package/es/util.js

@@ -0,0 +1,88 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+// @ts-ignore
+import UnitBezier from '@mapbox/unitbezier';
+var reducedMotionQuery;
+export function wrap(n, min, max) {
+  var d = max - min;
+  var w = ((n - min) % d + d) % d + min;
+  return w === min ? max : w;
+}
+export function clamp(n, min, max) {
+  return Math.min(max, Math.max(min, n));
+}
+export function interpolate(a, b, t) {
+  return a * (1 - t) + b * t;
+}
+export function bezier(p1x, p1y, p2x, p2y) {
+  var bez = new UnitBezier(p1x, p1y, p2x, p2y);
+  return function (t) {
+    return bez.solve(t);
+  };
+}
+export var ease = bezier(0.25, 0.1, 0.25, 1);
+export function prefersReducedMotion() {
+  // Lazily initialize media query
+  if (reducedMotionQuery == null) {
+    // @ts-ignore
+    reducedMotionQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
+  }
+  return reducedMotionQuery.matches;
+}
+export function pick(src, properties) {
+  var result = {};
+  var _iterator = _createForOfIteratorHelper(properties),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var name = _step.value;
+      if (name in src) {
+        result[name] = src[name];
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+export var now = window.performance && window.performance.now ? window.performance.now.bind(window.performance) : Date.now.bind(Date);
+export var raf = window.requestAnimationFrame ||
+// @ts-ignore
+window.mozRequestAnimationFrame ||
+// @ts-ignore
+window.webkitRequestAnimationFrame ||
+// @ts-ignore
+window.msRequestAnimationFrame;
+var _cancel = window.cancelAnimationFrame ||
+// @ts-ignore
+window.mozCancelAnimationFrame ||
+// @ts-ignore
+window.webkitCancelAnimationFrame ||
+// @ts-ignore
+window.msCancelAnimationFrame;
+export { _cancel as cancel };
+export function renderframe(fn) {
+  var frame = raf(fn);
+  return {
+    cancel: function cancel() {
+      return _cancel(frame);
+    }
+  };
+}
+export function extend(dest) {
+  for (var _len = arguments.length, sources = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    sources[_key - 1] = arguments[_key];
+  }
+  for (var _i = 0, _sources = sources; _i < _sources.length; _i++) {
+    var src = _sources[_i];
+    for (var k in src) {
+      if (src[k] !== undefined) {
+        dest[k] = src[k];
+      }
+    }
+  }
+  return dest;
+}

package/es/utils/Aabb.d.ts

@@ -0,0 +1,12 @@
+import { vec3 } from 'gl-matrix';
+import Frustum from './primitives';
+export default class Aabb {
+    min: vec3;
+    max: vec3;
+    center: vec3;
+    constructor(min: vec3, max: vec3);
+    quadrant(index: number): Aabb;
+    distanceX(point: number[]): number;
+    distanceY(point: number[]): number;
+    intersects(frustum: Frustum): number;
+}

package/es/utils/Aabb.js

@@ -0,0 +1,112 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { vec3, vec4 } from 'gl-matrix';
+var Aabb = /*#__PURE__*/function () {
+  function Aabb(min, max) {
+    _classCallCheck(this, Aabb);
+    this.min = min;
+    this.max = max;
+    this.center = vec3.scale(new Float32Array(3), vec3.add(new Float32Array(3), this.min, this.max), 0.5);
+  }
+  _createClass(Aabb, [{
+    key: "quadrant",
+    value: function quadrant(index) {
+      var split = [index % 2 === 0, index < 2];
+      var qMin = vec3.clone(this.min);
+      var qMax = vec3.clone(this.max);
+      for (var axis = 0; axis < split.length; axis++) {
+        qMin[axis] = split[axis] ? this.min[axis] : this.center[axis];
+        qMax[axis] = split[axis] ? this.center[axis] : this.max[axis];
+      }
+      // Elevation is always constant, hence quadrant.max.z = this.max.z
+      qMax[2] = this.max[2];
+      return new Aabb(qMin, qMax);
+    }
+  }, {
+    key: "distanceX",
+    value: function distanceX(point) {
+      var pointOnAabb = Math.max(Math.min(this.max[0], point[0]), this.min[0]);
+      return pointOnAabb - point[0];
+    }
+  }, {
+    key: "distanceY",
+    value: function distanceY(point) {
+      var pointOnAabb = Math.max(Math.min(this.max[1], point[1]), this.min[1]);
+      return pointOnAabb - point[1];
+    }
+
+    // Performs a frustum-aabb intersection test. Returns 0 if there's no intersection,
+    // 1 if shapes are intersecting and 2 if the aabb if fully inside the frustum.
+  }, {
+    key: "intersects",
+    value: function intersects(frustum) {
+      // Execute separating axis test between two convex objects to find intersections
+      // Each frustum plane together with 3 major axes define the separating axes
+      // Note: test only 4 points as both min and max points have equal elevation
+
+      var aabbPoints = [[this.min[0], this.min[1], 0.0, 1], [this.max[0], this.min[1], 0.0, 1], [this.max[0], this.max[1], 0.0, 1], [this.min[0], this.max[1], 0.0, 1]];
+      var fullyInside = true;
+      var _iterator = _createForOfIteratorHelper(frustum.planes),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var plane = _step.value;
+          var pointsInside = 0;
+          var _iterator3 = _createForOfIteratorHelper(aabbPoints),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var i = _step3.value;
+              // @ts-ignore
+              pointsInside += vec4.dot(plane, i) >= 0;
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+          if (pointsInside === 0) {
+            return 0;
+          }
+          if (pointsInside !== aabbPoints.length) {
+            fullyInside = false;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (fullyInside) {
+        return 2;
+      }
+      for (var axis = 0; axis < 3; axis++) {
+        var projMin = Number.MAX_VALUE;
+        var projMax = -Number.MAX_VALUE;
+        var _iterator2 = _createForOfIteratorHelper(frustum.points),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var p = _step2.value;
+            var projectedPoint = p[axis] - this.min[axis];
+            projMin = Math.min(projMin, projectedPoint);
+            projMax = Math.max(projMax, projectedPoint);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        if (projMax < 0 || projMin > this.max[axis] - this.min[axis]) {
+          return 0;
+        }
+      }
+      return 1;
+    }
+  }]);
+  return Aabb;
+}();
+export { Aabb as default };

package/es/utils/dom.d.ts

@@ -0,0 +1,4 @@
+declare const DOM: {
+    [key: string]: (...arg: any[]) => any;
+};
+export default DOM;

package/es/utils/dom.js

@@ -0,0 +1,140 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+// @ts-ignore
+import Point from "../geo/point";
+var DOM = {};
+export default DOM;
+DOM.create = function (tagName, className, container) {
+  var el = window.document.createElement(tagName);
+  if (className !== undefined) {
+    el.className = className;
+  }
+  if (container) {
+    container.appendChild(el);
+  }
+  return el;
+};
+DOM.createNS = function (namespaceURI, tagName) {
+  var el = window.document.createElementNS(namespaceURI, tagName);
+  return el;
+};
+var docStyle = window.document && window.document.documentElement.style;
+function testProp(props) {
+  if (!docStyle) {
+    return props[0];
+  }
+  var _iterator = _createForOfIteratorHelper(props),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var i = _step.value;
+      if (i in docStyle) {
+        return i;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return props[0];
+}
+var selectProp = testProp(['userSelect', 'MozUserSelect', 'WebkitUserSelect', 'msUserSelect']);
+var userSelect;
+DOM.disableDrag = function () {
+  if (docStyle && selectProp) {
+    userSelect = docStyle[selectProp];
+    docStyle[selectProp] = 'none';
+  }
+};
+DOM.enableDrag = function () {
+  if (docStyle && selectProp) {
+    docStyle[selectProp] = userSelect;
+  }
+};
+var transformProp = testProp(['transform', 'WebkitTransform']);
+DOM.setTransform = function (el, value) {
+  // https://github.com/facebook/flow/issues/7754
+  // $FlowFixMe
+  el.style[transformProp] = value;
+};
+
+// Feature detection for {passive: false} support in add/removeEventListener.
+var passiveSupported = false;
+try {
+  // https://github.com/facebook/flow/issues/285
+  // $FlowFixMe
+  var options = Object.defineProperty({}, 'passive', {
+    get: function get() {
+      // eslint-disable-line
+      passiveSupported = true;
+    }
+  });
+  // @ts-ignore
+  window.addEventListener('test', options, options);
+  // @ts-ignore
+  window.removeEventListener('test', options, options);
+} catch (err) {
+  passiveSupported = false;
+}
+DOM.addEventListener = function (target, type, callback) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  if ('passive' in options && passiveSupported) {
+    target.addEventListener(type, callback, options);
+  } else {
+    target.addEventListener(type, callback, options.capture);
+  }
+};
+DOM.removeEventListener = function (target, type, callback) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  if ('passive' in options && passiveSupported) {
+    target.removeEventListener(type, callback, options);
+  } else {
+    target.removeEventListener(type, callback, options.capture);
+  }
+};
+
+// Suppress the next click, but only if it's immediate.
+var suppressClick = function suppressClick(e) {
+  e.preventDefault();
+  e.stopPropagation();
+  window.removeEventListener('click', suppressClick, true);
+};
+DOM.suppressClick = function () {
+  window.addEventListener('click', suppressClick, true);
+  setTimeout(function () {
+    window.removeEventListener('click', suppressClick, true);
+  }, 0);
+};
+DOM.mousePos = function (el, e) {
+  // 暂时从 el 上获取 top/left， 后面需要动态获取
+  var rect = el.getBoundingClientRect();
+  return new Point(e.clientX - rect.left - el.clientLeft, e.clientY - rect.top - el.clientTop);
+};
+DOM.touchPos = function (el, touches) {
+  // 暂时从 el 上获取 top/left， 后面需要动态获取
+  var rect = el.getBoundingClientRect();
+  var points = [];
+  var _iterator2 = _createForOfIteratorHelper(touches),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var touche = _step2.value;
+      points.push(new Point(touche.clientX - rect.left - el.clientLeft, touche.clientY - rect.top - el.clientTop));
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return points;
+};
+DOM.mouseButton = function (e) {
+  return e.button;
+};
+DOM.remove = function (node) {
+  if (node.parentNode) {
+    node.parentNode.removeChild(node);
+  }
+};

package/es/utils/performance.d.ts

@@ -0,0 +1,17 @@
+export interface IPerformanceMetrics {
+    loadTime: number;
+    fullLoadTime: number;
+    fps: number;
+    percentDroppedFrames: number;
+}
+export declare const PerformanceMarkers: {
+    create: string;
+    load: string;
+    fullLoad: string;
+};
+export declare const PerformanceUtils: {
+    mark(marker: string): void;
+    frame(timestamp: number): void;
+    clearMetrics(): void;
+    getPerformanceMetrics(): IPerformanceMetrics;
+};

package/es/utils/performance.js

@@ -0,0 +1,62 @@
+var lastFrameTime = null;
+var frameTimes = [];
+var minFramerateTarget = 30;
+var frameTimeTarget = 1000 / minFramerateTarget;
+var performance = window.performance;
+export var PerformanceMarkers = {
+  create: 'create',
+  load: 'load',
+  fullLoad: 'fullLoad'
+};
+export var PerformanceUtils = {
+  mark: function mark(marker) {
+    performance.mark(marker);
+  },
+  frame: function frame(timestamp) {
+    var currTimestamp = timestamp;
+    if (lastFrameTime != null) {
+      var frameTime = currTimestamp - lastFrameTime;
+      frameTimes.push(frameTime);
+    }
+    lastFrameTime = currTimestamp;
+  },
+  clearMetrics: function clearMetrics() {
+    lastFrameTime = null;
+    frameTimes = [];
+    performance.clearMeasures('loadTime');
+    performance.clearMeasures('fullLoadTime');
+    // @ts-ignore
+    // tslint:disable-next-line:forin
+    for (var marker in PerformanceMarkers) {
+      // @ts-ignore
+      performance.clearMarks(PerformanceMarkers[marker]);
+    }
+  },
+  getPerformanceMetrics: function getPerformanceMetrics() {
+    var loadTime = performance.measure('loadTime', PerformanceMarkers.create, PerformanceMarkers.load
+    // @ts-ignore
+    ).duration;
+    var fullLoadTime = performance.measure('fullLoadTime', PerformanceMarkers.create, PerformanceMarkers.fullLoad
+    // @ts-ignore
+    ).duration;
+    var totalFrames = frameTimes.length;
+    var avgFrameTime = frameTimes.reduce(function (prev, curr) {
+      return prev + curr;
+    }, 0) / totalFrames / 1000;
+    var fps = 1 / avgFrameTime;
+
+    // count frames that missed our framerate target
+    var droppedFrames = frameTimes.filter(function (frameTime) {
+      return frameTime > frameTimeTarget;
+    }).reduce(function (acc, curr) {
+      return acc + (curr - frameTimeTarget) / frameTimeTarget;
+    }, 0);
+    var percentDroppedFrames = droppedFrames / (totalFrames + droppedFrames) * 100;
+    return {
+      loadTime: loadTime,
+      fullLoadTime: fullLoadTime,
+      fps: fps,
+      percentDroppedFrames: percentDroppedFrames
+    };
+  }
+};

package/es/utils/primitives.d.ts

@@ -0,0 +1,6 @@
+export default class Frustum {
+    static fromInvProjectionMatrix(invProj: Float32Array, worldSize: number, zoom: number): Frustum;
+    points: number[][];
+    planes: number[][];
+    constructor(points: number[][], planes: number[][]);
+}

package/es/utils/primitives.js

@@ -0,0 +1,47 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import { vec3, vec4 } from 'gl-matrix';
+var Frustum = /*#__PURE__*/function () {
+  function Frustum(points, planes) {
+    _classCallCheck(this, Frustum);
+    this.points = points;
+    this.planes = planes;
+  }
+  _createClass(Frustum, null, [{
+    key: "fromInvProjectionMatrix",
+    value: function fromInvProjectionMatrix(invProj, worldSize, zoom) {
+      var clipSpaceCorners = [[-1, 1, -1, 1], [1, 1, -1, 1], [1, -1, -1, 1], [-1, -1, -1, 1], [-1, 1, 1, 1], [1, 1, 1, 1], [1, -1, 1, 1], [-1, -1, 1, 1]];
+      var scale = Math.pow(2, zoom);
+
+      // Transform frustum corner points from clip space to tile space
+      var frustumCoords = clipSpaceCorners.map(function (v) {
+        return vec4.transformMat4(new Float32Array([]), v, invProj);
+      }).map(function (v) {
+        return vec4.scale(new Float32Array([]), v, 1.0 / v[3] / worldSize * scale);
+      });
+      var frustumPlanePointIndices = [[0, 1, 2],
+      // near
+      [6, 5, 4],
+      // far
+      [0, 3, 7],
+      // left
+      [2, 1, 5],
+      // right
+      [3, 2, 6],
+      // bottom
+      [0, 4, 5] // top
+      ];
+
+      var frustumPlanes = frustumPlanePointIndices.map(function (p) {
+        var a = vec3.sub(new Float32Array(3), new Float32Array(frustumCoords[p[0]]), new Float32Array(frustumCoords[p[1]]));
+        var b = vec3.sub(new Float32Array(3), new Float32Array(frustumCoords[p[2]]), new Float32Array(frustumCoords[p[1]]));
+        var n = vec3.normalize(new Float32Array(3), vec3.cross(new Float32Array(3), a, b));
+        var d = -vec3.dot(n, new Float32Array(frustumCoords[p[1]]));
+        return n.concat(d);
+      });
+      return new Frustum(frustumCoords, frustumPlanes);
+    }
+  }]);
+  return Frustum;
+}();
+export { Frustum as default };

package/es/utils/task_queue.d.ts

@@ -0,0 +1,13 @@
+export type TaskID = number;
+declare class TaskQueue {
+    private queue;
+    private id;
+    private cleared;
+    private currentlyRunning;
+    constructor();
+    add(callback: (timeStamp: number) => void): TaskID;
+    remove(id: TaskID): void;
+    run(timeStamp?: number): void;
+    clear(): void;
+}
+export default TaskQueue;

package/es/utils/task_queue.js

@@ -0,0 +1,89 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+// can't mark opaque due to https://github.com/flowtype/flow-remove-types/pull/61
+var TaskQueue = /*#__PURE__*/function () {
+  function TaskQueue() {
+    _classCallCheck(this, TaskQueue);
+    this.queue = [];
+    this.id = 0;
+    this.cleared = false;
+    this.currentlyRunning = false;
+  }
+  _createClass(TaskQueue, [{
+    key: "add",
+    value: function add(callback) {
+      var id = ++this.id;
+      var queue = this.queue;
+      queue.push({
+        callback: callback,
+        id: id,
+        cancelled: false
+      });
+      return id;
+    }
+  }, {
+    key: "remove",
+    value: function remove(id) {
+      var running = this.currentlyRunning;
+      var queue = running ? this.queue.concat(running) : this.queue;
+      var _iterator = _createForOfIteratorHelper(queue),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var task = _step.value;
+          if (task.id === id) {
+            task.cancelled = true;
+            return;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "run",
+    value: function run() {
+      var timeStamp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+      var queue = this.currentlyRunning = this.queue;
+
+      // Tasks queued by callbacks in the current queue should be executed
+      // on the next run, not the current run.
+      this.queue = [];
+      var _iterator2 = _createForOfIteratorHelper(queue),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var task = _step2.value;
+          if (task.cancelled) {
+            continue;
+          }
+          task.callback(timeStamp);
+          if (this.cleared) {
+            break;
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      this.cleared = false;
+      this.currentlyRunning = false;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      if (this.currentlyRunning) {
+        this.cleared = true;
+      }
+      this.queue = [];
+    }
+  }]);
+  return TaskQueue;
+}();
+export default TaskQueue;