@atlaskit/editor-plugin-interactivity 0.1.0 → 0.2.0

package/dist/esm/collector/interaction-group.js

@@ -0,0 +1,161 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@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; }
+import { bucketKeyForMs } from './bucket-boundaries';
+
+/**
+ * Latencies are counted per 8 ms, the resolution Event Timing reports durations at. Every
+ * latency is rounded up to this step on the way in, which caps the number of distinct values
+ * a group can hold whatever the latency was derived from.
+ */
+var RESOLUTION_MS = 8;
+
+/** Which percentiles are reported, as quantiles. */
+var REPORTED_QUANTILES = [0.9, 0.98];
+
+/**
+ * The latencies of one set of interactions — every interaction on the page, or only the ones
+ * inside the editor — reported as one object in the event.
+ *
+ * The whole state is a count per distinct latency, so an interaction only costs a counter
+ * whatever its latency was, and everything the event carries — the reported buckets, the
+ * count, the sum, the maximum and the percentiles — is derived from that map when a snapshot
+ * is taken. Nothing is computed while interactions arrive.
+ */
+export var InteractionGroup = /*#__PURE__*/function () {
+  function InteractionGroup() {
+    _classCallCheck(this, InteractionGroup);
+    _defineProperty(this, "countByLatency", new Map());
+  }
+  return _createClass(InteractionGroup, [{
+    key: "add",
+    value: function add(latencyMs) {
+      this.increment(latencyMs);
+    }
+  }, {
+    key: "remeasure",
+    value: function remeasure(previousLatencyMs, latencyMs) {
+      // Moved rather than counted again: the count belongs to the same interaction.
+      this.decrement(previousLatencyMs);
+      this.increment(latencyMs);
+    }
+
+    /**
+     * @param totalCount every interaction of the group, including those below the Event Timing
+     * reporting threshold, which this group never sees.
+     */
+  }, {
+    key: "snapshot",
+    value: function snapshot(totalCount) {
+      var _latencies;
+      // Ascending, so the reported buckets come out in order and the last latency is the
+      // maximum. Sorted once for everything below.
+      var latencies = Array.from(this.countByLatency.keys()).sort(function (a, b) {
+        return a - b;
+      });
+      var observedCount = this.observedCount();
+      var percentileRanks = REPORTED_QUANTILES.map(function (quantile) {
+        return {
+          key: String(Math.round(quantile * 100)),
+          rank: Math.max(1, Math.ceil(quantile * observedCount))
+        };
+      });
+      var buckets = {};
+      var percentilesMs = {};
+      var sumMs = 0;
+      var counted = 0;
+      var _iterator = _createForOfIteratorHelper(latencies),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _this$countByLatency$, _buckets$bucket;
+          var latencyMs = _step.value;
+          var count = (_this$countByLatency$ = this.countByLatency.get(latencyMs)) !== null && _this$countByLatency$ !== void 0 ? _this$countByLatency$ : 0;
+          sumMs += latencyMs * count;
+          var bucket = String(bucketKeyForMs(latencyMs));
+          buckets[bucket] = ((_buckets$bucket = buckets[bucket]) !== null && _buckets$bucket !== void 0 ? _buckets$bucket : 0) + count;
+
+          // A percentile is the latency the group's interactions reach counting up from the
+          // fastest, so it is answered as soon as this many of them have been passed.
+          counted += count;
+          var _iterator2 = _createForOfIteratorHelper(percentileRanks),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var _step2$value = _step2.value,
+                key = _step2$value.key,
+                rank = _step2$value.rank;
+              if (percentilesMs[key] === undefined && counted >= rank) {
+                percentilesMs[key] = latencyMs;
+              }
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return {
+        // `performance.interactionCount` can lag the entries the observer has delivered.
+        totalCount: Math.max(totalCount, observedCount),
+        observedCount: observedCount,
+        sumMs: sumMs,
+        maxMs: (_latencies = latencies[latencies.length - 1]) !== null && _latencies !== void 0 ? _latencies : 0,
+        buckets: buckets,
+        percentilesMs: percentilesMs
+      };
+    }
+  }, {
+    key: "observedCount",
+    value: function observedCount() {
+      var total = 0;
+      var _iterator3 = _createForOfIteratorHelper(this.countByLatency.values()),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var count = _step3.value;
+          total += count;
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return total;
+    }
+
+    /** Rounding lives here so that every count goes through the same step, in or out. */
+  }, {
+    key: "roundLatencyUp",
+    value: function roundLatencyUp(latencyMs) {
+      return Math.ceil(latencyMs / RESOLUTION_MS) * RESOLUTION_MS;
+    }
+  }, {
+    key: "increment",
+    value: function increment(latencyMs) {
+      var _this$countByLatency$2;
+      var step = this.roundLatencyUp(latencyMs);
+      this.countByLatency.set(step, ((_this$countByLatency$2 = this.countByLatency.get(step)) !== null && _this$countByLatency$2 !== void 0 ? _this$countByLatency$2 : 0) + 1);
+    }
+  }, {
+    key: "decrement",
+    value: function decrement(latencyMs) {
+      var _this$countByLatency$3;
+      var step = this.roundLatencyUp(latencyMs);
+      var next = ((_this$countByLatency$3 = this.countByLatency.get(step)) !== null && _this$countByLatency$3 !== void 0 ? _this$countByLatency$3 : 0) - 1;
+      if (next > 0) {
+        this.countByLatency.set(step, next);
+      } else {
+        this.countByLatency.delete(step);
+      }
+    }
+  }]);
+}();

package/dist/esm/collector/interaction-observer.js

@@ -0,0 +1,108 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { REPORTING_THRESHOLD_MS } from './bucket-boundaries';
+/** `performance.interactionCount` is Chromium-only and absent from the DOM typings. */
+var interactionCount = function interactionCount() {
+  return performance.interactionCount;
+};
+
+/** `durationThreshold` is absent from the DOM typings for `PerformanceObserverInit`. */
+
+/**
+ * Reports the interactions the browser observes to `onEntries`.
+ *
+ * `drain` and `stop` are safe to call before `start` and after each other, so a session
+ * that never started collecting needs no special handling.
+ */
+export var InteractionObserver = /*#__PURE__*/function () {
+  function InteractionObserver(onEntries) {
+    _classCallCheck(this, InteractionObserver);
+    this.onEntries = onEntries;
+  }
+
+  /**
+   * Starts reporting interactions from this point on. Does nothing when already started, so
+   * a second call cannot leave an observer running with nobody to disconnect it.
+   *
+   * `buffered` is `false`: the entries the browser collected earlier are interactions with
+   * the page while the editor was still loading, and they belong to no session of ours.
+   */
+  return _createClass(InteractionObserver, [{
+    key: "start",
+    value: function start() {
+      var _this = this;
+      if (this.observer) {
+        return;
+      }
+      this.observer = new PerformanceObserver(function (list) {
+        // Delay by a microtask to work around a Safari bug where the callback is
+        // invoked synchronously rather than in a separate task.
+        // See: https://github.com/GoogleChrome/web-vitals/issues/277
+        Promise.resolve().then(function () {
+          _this.onEntries(list.getEntries());
+        });
+      });
+      var init = {
+        type: 'event',
+        buffered: false,
+        // 16 ms is also the smallest value the spec honours; lower values are clamped.
+        durationThreshold: REPORTING_THRESHOLD_MS
+      };
+      this.observer.observe(init);
+    }
+
+    /**
+     * Synchronously reports the entries the browser has produced but not yet dispatched to
+     * the callback. A snapshot taken because the page is going away has to include them,
+     * because there is no later chance to.
+     */
+  }, {
+    key: "drain",
+    value: function drain() {
+      var _this$observer;
+      var entries = (_this$observer = this.observer) === null || _this$observer === void 0 ? void 0 : _this$observer.takeRecords();
+      if (entries) {
+        this.onEntries(entries);
+      }
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      var _this$observer2;
+      (_this$observer2 = this.observer) === null || _this$observer2 === void 0 || _this$observer2.disconnect();
+      this.observer = undefined;
+    }
+  }], [{
+    key: "isSupported",
+    value:
+    /**
+     * Whether the browser reports both things a session needs: `interactionId`, which groups
+     * entries into interactions, and `performance.interactionCount`, which counts the ones
+     * below the reporting threshold. Both are Chromium-only, and without the count
+     * `totalCount` would be indistinguishable from `observedCount`.
+     */
+    function isSupported() {
+      if (typeof window === 'undefined' || typeof PerformanceObserver === 'undefined') {
+        return false;
+      }
+      if (!('PerformanceEventTiming' in window) || !('interactionId' in PerformanceEventTiming.prototype)) {
+        return false;
+      }
+      if (!PerformanceObserver.supportedEntryTypes.includes('event')) {
+        return false;
+      }
+      return typeof interactionCount() === 'number';
+    }
+
+    /**
+     * Total interactions on the page since page load, including those below the reporting
+     * threshold that no observer ever sees. A property of the page, not of an observer.
+     */
+  }, {
+    key: "readPageInteractionCount",
+    value: function readPageInteractionCount() {
+      var _interactionCount;
+      return (_interactionCount = interactionCount()) !== null && _interactionCount !== void 0 ? _interactionCount : 0;
+    }
+  }]);
+}();

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

@@ -0,0 +1,137 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@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.
+ */
+export var 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;
+    _classCallCheck(this, InteractionTracker);
+    _defineProperty(this, "latencies", new Map());
+    _defineProperty(this, "highestInteractionId", 0);
+    this.startsAfterInteractionId = startsAfterInteractionId;
+  }
+
+  /** The highest `interactionId` this tracker has seen. */
+  return _createClass(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/esm/collector/interactivity-collector.js

@@ -0,0 +1,282 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@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; }
+import { getDocument } from '@atlaskit/browser-apis';
+import { InteractionObserver } from './interaction-observer';
+import { InteractivitySession } from './interactivity-session';
+import { SCHEMA_VERSION } from './bucket-boundaries';
+import { LifecycleObserver } from './lifecycle-observer';
+import { SnapshotScheduler } from './snapshot-scheduler';
+/**
+ * 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.
+ */
+export var InteractivityCollector = /*#__PURE__*/function () {
+  function InteractivityCollector(options) {
+    var _this = this;
+    _classCallCheck(this, InteractivityCollector);
+    _defineProperty(this, "started", false);
+    _defineProperty(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(function (entries) {
+      return _this.recordEntries(entries);
+    });
+    this.snapshotScheduler = new SnapshotScheduler(function () {
+      return _this.onTimer();
+    });
+    this.lifecycleObserver = new 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 _createClass(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.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({
+        objectId: this.getObjectId(),
+        mode: this.getSessionMode(),
+        hidden: ((_getDocument = 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.readPageInteractionCount() - session.interactionCountAtStart;
+      this.emit({
+        schema: 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)
+      });
+    }
+  }]);
+}();