@atlaskit/editor-plugin-interactivity 0.1.0 → 0.2.0

package/dist/cjs/collector/interaction-tracker.js

@@ -0,0 +1,144 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InteractionTracker = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, 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 o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * The Event Timing fields this package reads. `interactionId` is missing from the DOM
+ * typings' `PerformanceEventTiming`, so it is declared here as optional, which also makes
+ * a `PerformanceEntry` from `getEntries()` assignable without a cast.
+ */
+
+/**
+ * What an entry did to the interaction it belongs to: either it is the first entry of a new
+ * interaction, or it measured an interaction that was already counted as slower than it was
+ * known to be.
+ */
+
+/**
+ * How many interactions are remembered, so their growth can still be applied. Entries of one
+ * interaction arrive within the interaction itself, so anything older is not needed.
+ */
+var MAX_TRACKED = 256;
+/**
+ * How many are dropped per cleanup. Dropping one at a time would run a cleanup on every new
+ * interaction once the limit is reached; a batch makes it one cleanup per 64 of them.
+ */
+var PRUNE_BATCH = 64;
+
+/**
+ * Groups Event Timing entries into interactions.
+ *
+ * Entries sharing a non-zero `interactionId` are one interaction whose latency is the
+ * maximum `duration` among them. Entries arrive incrementally, so an interaction's latency
+ * can grow after it was first reported — callers apply that to what they already counted
+ * rather than counting the interaction twice.
+ *
+ * A non-zero `interactionId` is the browser's own definition of an interaction, which is
+ * also what INP filters on: it is assigned to the pointer and keyboard events that make one
+ * up, and never to scrolling or pointer movement.
+ */
+var InteractionTracker = exports.InteractionTracker = /*#__PURE__*/function () {
+  /**
+   * @param startsAfterInteractionId interactions up to and including this one belong to the
+   * previous tracker and are ignored. `interactionId` counts up over the life of the page, so
+   * a session opening mid-page passes the highest id the one before it saw; without that, an
+   * entry still arriving for an interaction from the previous session would look new here and
+   * be counted in both.
+   */
+  function InteractionTracker() {
+    var startsAfterInteractionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    (0, _classCallCheck2.default)(this, InteractionTracker);
+    (0, _defineProperty2.default)(this, "latencies", new Map());
+    (0, _defineProperty2.default)(this, "highestInteractionId", 0);
+    this.startsAfterInteractionId = startsAfterInteractionId;
+  }
+
+  /** The highest `interactionId` this tracker has seen. */
+  return (0, _createClass2.default)(InteractionTracker, [{
+    key: "lastInteractionId",
+    get: function get() {
+      return Math.max(this.highestInteractionId, this.startsAfterInteractionId);
+    }
+
+    /**
+     * Merges an entry into the interaction it belongs to.
+     *
+     * @returns what that did to the interaction's latency, or nothing when the entry is not
+     * part of an interaction, belongs to a previous tracker, or does not change one.
+     */
+  }, {
+    key: "merge",
+    value: function merge(entry) {
+      var interactionId = entry.interactionId;
+      // `first-input` and non-interaction events report `interactionId` 0.
+      if (!interactionId) {
+        return undefined;
+      }
+      if (interactionId <= this.startsAfterInteractionId) {
+        return undefined;
+      }
+      this.highestInteractionId = Math.max(this.highestInteractionId, interactionId);
+
+      // Every latency is counted through here, so this is where one that cannot be measured
+      // is rejected: a `NaN` getting through becomes a `NaN` bucket key and a `NaN` `sumMs`
+      // for the rest of the session.
+      if (!Number.isFinite(entry.duration) || entry.duration < 0) {
+        return undefined;
+      }
+      var previousLatencyMs = this.latencies.get(interactionId);
+      if (previousLatencyMs === undefined) {
+        this.latencies.set(interactionId, entry.duration);
+        this.prune();
+        return {
+          type: 'new',
+          latencyMs: entry.duration
+        };
+      }
+      if (entry.duration <= previousLatencyMs) {
+        return undefined;
+      }
+      this.latencies.set(interactionId, entry.duration);
+      return {
+        type: 'remeasured',
+        fromMs: previousLatencyMs,
+        toMs: entry.duration
+      };
+    }
+  }, {
+    key: "prune",
+    value: function prune() {
+      if (this.latencies.size <= MAX_TRACKED) {
+        return;
+      }
+
+      // `Map` preserves insertion order and `interactionId` increases monotonically,
+      // so the entries inserted first are the least likely to see another entry.
+      var remaining = PRUNE_BATCH;
+      var _iterator = _createForOfIteratorHelper(this.latencies.keys()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var interactionId = _step.value;
+          this.latencies.delete(interactionId);
+          remaining -= 1;
+          if (remaining === 0) {
+            return;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }]);
+}();

package/dist/cjs/collector/interactivity-collector.js

@@ -0,0 +1,289 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InteractivityCollector = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _browserApis = require("@atlaskit/browser-apis");
+var _interactionObserver = require("./interaction-observer");
+var _interactivitySession = require("./interactivity-session");
+var _bucketBoundaries = require("./bucket-boundaries");
+var _lifecycleObserver = require("./lifecycle-observer");
+var _snapshotScheduler = require("./snapshot-scheduler");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, 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 o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Collects interaction latencies for one editor mount and emits session-to-date snapshots.
+ *
+ * `start` and `stop` bound the collecting, which happens once. Within it there can be several
+ * sessions, because a session covers one document in one mode: a Confluence live page
+ * navigates and switches between reading and editing without ever remounting the editor, and
+ * each of those closes the current session and opens the next.
+ */
+var InteractivityCollector = exports.InteractivityCollector = /*#__PURE__*/function () {
+  function InteractivityCollector(options) {
+    var _this = this;
+    (0, _classCallCheck2.default)(this, InteractivityCollector);
+    (0, _defineProperty2.default)(this, "started", false);
+    (0, _defineProperty2.default)(this, "stopped", false);
+    this.emit = options.emit;
+    this.getEditorDomSize = options.getEditorDomSize;
+    this.getNodeSize = options.getNodeSize;
+    this.getObjectId = options.getObjectId;
+    this.getSessionMode = options.getSessionMode;
+    this.interactionObserver = new _interactionObserver.InteractionObserver(function (entries) {
+      return _this.recordEntries(entries);
+    });
+    this.snapshotScheduler = new _snapshotScheduler.SnapshotScheduler(function () {
+      return _this.onTimer();
+    });
+    this.lifecycleObserver = new _lifecycleObserver.LifecycleObserver({
+      onHidden: function onHidden() {
+        return _this.onHidden();
+      },
+      onVisible: function onVisible() {
+        return _this.onVisible();
+      },
+      onPageHide: function onPageHide() {
+        return _this.onPageHide();
+      },
+      onPageShow: function onPageShow() {
+        return _this.onPageShow();
+      }
+    });
+    this.session = this.createSession(0);
+  }
+
+  /**
+   * Starts collecting. Calling it again while collecting changes nothing.
+   *
+   * @returns whether collecting is running; `false` when the browser cannot support it, or
+   * when it has already been stopped.
+   */
+  return (0, _createClass2.default)(InteractivityCollector, [{
+    key: "start",
+    value: function start() {
+      // Collecting is over for good once stopped: the session it covered has been reported.
+      if (this.stopped) {
+        return false;
+      }
+      if (this.started) {
+        return true;
+      }
+      if (!_interactionObserver.InteractionObserver.isSupported()) {
+        return false;
+      }
+
+      // Opened again so the session's timings start with the collecting, not with whenever
+      // this object was constructed.
+      this.session = this.createSession(0);
+      this.interactionObserver.start();
+      this.snapshotScheduler.start();
+      this.lifecycleObserver.start();
+      this.started = true;
+      return true;
+    }
+
+    /** Reports the session as ended by the editor unmounting, and stops collecting. */
+  }, {
+    key: "stop",
+    value: function stop() {
+      if (this.stopped) {
+        return;
+      }
+      this.takeSnapshot('unmount');
+      this.stopped = true;
+      this.interactionObserver.stop();
+      this.snapshotScheduler.stop();
+      this.lifecycleObserver.stop();
+    }
+
+    /**
+     * Rotates the session when the editor is pointed at different content.
+     *
+     * An unknown object id is no information, never a change. The provider resolves
+     * asynchronously after mount, and `contextIdentifierPlugin` resets its state to the
+     * configured provider on transactions that do not carry a new one, so the id read here goes
+     * missing for a moment on a document that never changed.
+     */
+  }, {
+    key: "onObjectIdChanged",
+    value: function onObjectIdChanged() {
+      if (this.stopped) {
+        return;
+      }
+      var objectId = this.getObjectId();
+      if (objectId === undefined || objectId === this.session.objectId) {
+        return;
+      }
+      if (this.session.objectId === undefined) {
+        this.session.objectId = objectId;
+        return;
+      }
+      this.rotateSession('navigation');
+    }
+
+    /**
+     * Rotates the session when the editor switches between reading and editing. Interactions
+     * with a read-only page are a different population from interactions while editing, so one
+     * session never covers both.
+     */
+  }, {
+    key: "onViewModeChanged",
+    value: function onViewModeChanged() {
+      if (this.stopped) {
+        return;
+      }
+      var mode = this.getSessionMode();
+      if (mode === undefined || mode === this.session.mode) {
+        return;
+      }
+      if (this.session.mode === undefined) {
+        this.session.mode = mode;
+        return;
+      }
+      this.rotateSession('modeChange');
+    }
+
+    /**
+     * @param startsAfterInteractionId the highest interaction the previous session saw, so
+     * entries still arriving for it are not counted here as well.
+     */
+  }, {
+    key: "createSession",
+    value: function createSession(startsAfterInteractionId) {
+      var _getDocument;
+      return new _interactivitySession.InteractivitySession({
+        objectId: this.getObjectId(),
+        mode: this.getSessionMode(),
+        hidden: ((_getDocument = (0, _browserApis.getDocument)()) === null || _getDocument === void 0 ? void 0 : _getDocument.visibilityState) === 'hidden',
+        startsAfterInteractionId: startsAfterInteractionId
+      });
+    }
+
+    /** Reports the current session as ended by `reason` and puts a new one in its place. */
+  }, {
+    key: "rotateSession",
+    value: function rotateSession(reason) {
+      this.takeSnapshot(reason);
+      this.session = this.createSession(this.session.tracker.lastInteractionId);
+      this.snapshotScheduler.restart();
+    }
+  }, {
+    key: "onTimer",
+    value: function onTimer() {
+      this.takeSnapshot('timer');
+    }
+  }, {
+    key: "onHidden",
+    value: function onHidden() {
+      if (this.session.hiddenSince === undefined) {
+        this.session.hiddenSince = performance.now();
+      }
+      this.takeSnapshot('hidden');
+    }
+  }, {
+    key: "onVisible",
+    value: function onVisible() {
+      if (this.session.hiddenSince !== undefined) {
+        this.session.hiddenMs += performance.now() - this.session.hiddenSince;
+        this.session.hiddenSince = undefined;
+      }
+      this.session.lifecycleSnapshotEmitted = false;
+    }
+  }, {
+    key: "onPageHide",
+    value: function onPageHide() {
+      this.takeSnapshot('pagehide');
+    }
+
+    /**
+     * The page came back from the back/forward cache, which never raises a visibility change.
+     * The session continues, and the signal that suspended it has been reported, so the next
+     * one is due.
+     */
+  }, {
+    key: "onPageShow",
+    value: function onPageShow() {
+      this.session.lifecycleSnapshotEmitted = false;
+    }
+  }, {
+    key: "recordEntries",
+    value: function recordEntries(entries) {
+      var _this$session = this.session,
+        tracker = _this$session.tracker,
+        page = _this$session.page;
+      var _iterator = _createForOfIteratorHelper(entries),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var entry = _step.value;
+          var update = tracker.merge(entry);
+          if (!update) {
+            continue;
+          }
+          if (update.type === 'new') {
+            page.add(update.latencyMs);
+          } else {
+            page.remeasure(update.fromMs, update.toMs);
+          }
+          this.session.revision += 1;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }, {
+    key: "takeSnapshot",
+    value: function takeSnapshot(reason) {
+      if (this.stopped) {
+        return;
+      }
+      var session = this.session;
+
+      // Checked before anything is consumed: `visibilitychange` and `pagehide` fire back to
+      // back on the same transition and it is reported once, and draining first would take
+      // entries out of the browser's queue only to suppress the snapshot carrying them.
+      var lifecycleSignal = reason === 'hidden' || reason === 'pagehide';
+      if (lifecycleSignal && session.lifecycleSnapshotEmitted) {
+        return;
+      }
+
+      // Must run before the change check: the browser may be holding entries that have not
+      // reached the observer callback yet, and on `pagehide` there is no later chance to
+      // pick them up.
+      this.interactionObserver.drain();
+      if (session.revision === session.emittedRevision) {
+        return;
+      }
+      if (lifecycleSignal) {
+        session.lifecycleSnapshotEmitted = true;
+      }
+      session.seq += 1;
+      session.emittedRevision = session.revision;
+      var now = performance.now();
+      var hiddenMs = session.hiddenMs + (session.hiddenSince === undefined ? 0 : now - session.hiddenSince);
+      var totalCount = _interactionObserver.InteractionObserver.readPageInteractionCount() - session.interactionCountAtStart;
+      this.emit({
+        schema: _bucketBoundaries.SCHEMA_VERSION,
+        interactivitySessionId: session.id,
+        objectId: session.objectId,
+        seq: session.seq,
+        reason: reason,
+        sessionMode: session.mode,
+        activeMs: Math.round(Math.max(0, now - session.startedAt - hiddenMs)),
+        hiddenMs: Math.round(hiddenMs),
+        nodeSize: this.getNodeSize(),
+        editorDomSize: this.getEditorDomSize(),
+        page: session.page.snapshot(totalCount)
+      });
+    }
+  }]);
+}();

package/dist/cjs/collector/interactivity-session.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InteractivitySession = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _interactionObserver = require("./interaction-observer");
+var _interactionTracker = require("./interaction-tracker");
+var _interactionGroup = require("./interaction-group");
+function createSessionId() {
+  if (typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  var bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, function (byte) {
+    return byte.toString(16).padStart(2, '0');
+  }).join('');
+}
+/**
+ * Everything that belongs to one session.
+ *
+ * Nothing here is reset — the next session is a new instance — so a field added here cannot
+ * be left carrying the previous session's value.
+ */
+var InteractivitySession = exports.InteractivitySession = /*#__PURE__*/(0, _createClass2.default)(function InteractivitySession(start) {
+  (0, _classCallCheck2.default)(this, InteractivitySession);
+  (0, _defineProperty2.default)(this, "id", createSessionId());
+  (0, _defineProperty2.default)(this, "startedAt", performance.now());
+  /** Page interaction count when the session opened, subtracted to get its own total. */
+  (0, _defineProperty2.default)(this, "interactionCountAtStart", _interactionObserver.InteractionObserver.readPageInteractionCount());
+  (0, _defineProperty2.default)(this, "page", new _interactionGroup.InteractionGroup());
+  /** Increments per snapshot; a query takes the highest one per session. */
+  (0, _defineProperty2.default)(this, "seq", 0);
+  (0, _defineProperty2.default)(this, "hiddenMs", 0);
+  /**
+   * Bumped on every change to the accumulated data. A snapshot is emitted only when this
+   * has moved past `emittedRevision`, so identical snapshots are never sent twice.
+   */
+  (0, _defineProperty2.default)(this, "revision", 0);
+  (0, _defineProperty2.default)(this, "emittedRevision", 0);
+  /** One lifecycle snapshot per hidden episode; cleared when the page comes back. */
+  (0, _defineProperty2.default)(this, "lifecycleSnapshotEmitted", false);
+  this.objectId = start.objectId;
+  this.mode = start.mode;
+  this.hiddenSince = start.hidden ? this.startedAt : undefined;
+  this.tracker = new _interactionTracker.InteractionTracker(start.startsAfterInteractionId);
+});

package/dist/cjs/collector/lifecycle-observer.js

@@ -0,0 +1,66 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LifecycleObserver = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _bindEventListener = require("bind-event-listener");
+var _browserApis = require("@atlaskit/browser-apis");
+/**
+ * Reports the page lifecycle signals that force an extra snapshot: the tab being hidden or
+ * shown again, and the page being unloaded or restored from the back/forward cache.
+ *
+ * None of them is guaranteed to arrive — a mobile browser being killed raises nothing at all.
+ * Snapshots carry session-to-date values, so losing the last one costs only the tail of that
+ * session.
+ */
+var LifecycleObserver = exports.LifecycleObserver = /*#__PURE__*/function () {
+  function LifecycleObserver(handlers) {
+    (0, _classCallCheck2.default)(this, LifecycleObserver);
+    this.handlers = handlers;
+  }
+  return (0, _createClass2.default)(LifecycleObserver, [{
+    key: "start",
+    value: function start() {
+      var _this = this;
+      var doc = (0, _browserApis.getDocument)();
+      var unbindVisibilityChange = doc ? (0, _bindEventListener.bind)(doc, {
+        type: 'visibilitychange',
+        listener: function listener() {
+          if (doc.visibilityState === 'hidden') {
+            _this.handlers.onHidden();
+          } else {
+            _this.handlers.onVisible();
+          }
+        }
+      }) : undefined;
+      var unbindPageHide = (0, _bindEventListener.bind)(window, {
+        type: 'pagehide',
+        listener: function listener() {
+          return _this.handlers.onPageHide();
+        }
+      });
+      var unbindPageShow = (0, _bindEventListener.bind)(window, {
+        type: 'pageshow',
+        listener: function listener() {
+          return _this.handlers.onPageShow();
+        }
+      });
+      this.unbind = function () {
+        unbindVisibilityChange === null || unbindVisibilityChange === void 0 || unbindVisibilityChange();
+        unbindPageHide();
+        unbindPageShow();
+      };
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      var _this$unbind;
+      (_this$unbind = this.unbind) === null || _this$unbind === void 0 || _this$unbind.call(this);
+      this.unbind = undefined;
+    }
+  }]);
+}();

package/dist/cjs/collector/snapshot-scheduler.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SnapshotScheduler = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+/**
+ * Snapshots are taken 10 s, 30 s and 60 s after the session starts, then every 60 s. The
+ * first three come close together so that short sessions, which are the common case, are
+ * still reported.
+ */
+var INITIAL_OFFSETS_MS = [10000, 30000, 60000];
+var INTERVAL_MS = 60000;
+
+/**
+ * Fires `onTick` on the snapshot cadence. Timings are offsets from `start()`, so a
+ * restart (a new session in the same editor) restarts the cadence too.
+ */
+var SnapshotScheduler = exports.SnapshotScheduler = /*#__PURE__*/function () {
+  function SnapshotScheduler(onTick) {
+    (0, _classCallCheck2.default)(this, SnapshotScheduler);
+    (0, _defineProperty2.default)(this, "tickIndex", 0);
+    this.onTick = onTick;
+  }
+  return (0, _createClass2.default)(SnapshotScheduler, [{
+    key: "start",
+    value: function start() {
+      this.tickIndex = 0;
+      this.scheduleNext();
+    }
+  }, {
+    key: "restart",
+    value: function restart() {
+      this.stop();
+      this.start();
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      if (this.timeoutId !== undefined) {
+        window.clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+      }
+    }
+  }, {
+    key: "scheduleNext",
+    value: function scheduleNext() {
+      var _this = this;
+      this.timeoutId = window.setTimeout(function () {
+        _this.tickIndex += 1;
+        _this.onTick();
+        _this.scheduleNext();
+      }, this.delayForNextTick());
+    }
+  }, {
+    key: "delayForNextTick",
+    value: function delayForNextTick() {
+      var offset = INITIAL_OFFSETS_MS[this.tickIndex];
+      if (offset === undefined) {
+        return INTERVAL_MS;
+      }
+      var previousOffset = this.tickIndex === 0 ? 0 : INITIAL_OFFSETS_MS[this.tickIndex - 1];
+      return offset - previousOffset;
+    }
+  }]);
+}();