@atlaskit/editor-plugin-interactivity 0.1.0 → 0.3.0

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,179 @@
+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 { interactionEventKind } from './interaction-events';
+
+/**
+ * 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. Both carry the editor group of the interaction, if it is one of the editor's.
+ */
+
+/**
+ * How many interactions are remembered, so their growth can still be applied, and how many of
+ * the editor's events. Entries of one interaction arrive within the interaction itself, so
+ * anything older than the last few hundred 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;
+
+/**
+ * Identifies the event an entry measured: an entry's `startTime` is that event's timestamp and its
+ * `name` is its type. The type is in the key because browsers coarsen the timestamp, so two events
+ * of one task can share it — and events of one type are always of one group, so a collision cannot
+ * move an interaction into another group.
+ */
+function eventKey(type, timeStamp) {
+  return "".concat(type, "|").concat(timeStamp);
+}
+
+/**
+ * Makes interactions out of what the two observers report, for one session.
+ *
+ * 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.
+ *
+ * The editor's events answer what an entry cannot: which interactions were with the editor, and
+ * how many there were, including the ones below the Event Timing reporting threshold.
+ */
+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, "interactions", new Map());
+    _defineProperty(this, "groupByEvent", 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 tracked = this.interactions.get(interactionId);
+      if (tracked === undefined) {
+        // Taken once: an entry that only makes the interaction slower has to move its count
+        // within the group it was counted in, not into another one.
+        var group = this.groupByEvent.get(eventKey(entry.name, entry.startTime));
+        this.interactions.set(interactionId, {
+          latencyMs: entry.duration,
+          group: group
+        });
+        this.prune(this.interactions);
+        return {
+          type: 'new',
+          latencyMs: entry.duration,
+          group: group
+        };
+      }
+      if (entry.duration <= tracked.latencyMs) {
+        return undefined;
+      }
+      var fromMs = tracked.latencyMs;
+      tracked.latencyMs = entry.duration;
+      return {
+        type: 'remeasured',
+        fromMs: fromMs,
+        toMs: entry.duration,
+        group: tracked.group
+      };
+    }
+
+    /** @returns the group of an interaction to count, when this is the event its group counts on. */
+  }, {
+    key: "recordEditorEvent",
+    value: function recordEditorEvent(event) {
+      var kind = interactionEventKind(event.type);
+      if (!kind) {
+        return undefined;
+      }
+
+      // Every event of the interaction, because any of them can be the one Event Timing reports
+      // as the slowest: for a pointer press that is usually the click.
+      this.groupByEvent.set(eventKey(event.type, event.timeStamp), kind.group);
+      this.prune(this.groupByEvent);
+      return kind.counts ? kind.group : undefined;
+    }
+  }, {
+    key: "prune",
+    value: function prune(entries) {
+      if (entries.size <= MAX_TRACKED) {
+        return;
+      }
+
+      // `Map` preserves insertion order, so the entries inserted first are the least likely to
+      // see another entry or another event.
+      var remaining = PRUNE_BATCH;
+      var _iterator = _createForOfIteratorHelper(entries.keys()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var key = _step.value;
+          entries.delete(key);
+          remaining -= 1;
+          if (remaining === 0) {
+            return;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }]);
+}();

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

@@ -0,0 +1,334 @@
+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 { EditorEventObserver } from './editor-event-observer';
+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.
+ *
+ * Every interaction is counted in `page`, and the ones with the editor again in one of the editor
+ * groups, which is what tells a slow editor apart from a slow page around it.
+ *
+ * `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.editorEvents = new EditorEventObserver(function (event) {
+      return _this.recordEditorEvent(event);
+    });
+    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.editorEvents.observe(this.editorRoot);
+      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.editorEvents.stop();
+      this.snapshotScheduler.stop();
+      this.lifecycleObserver.stop();
+    }
+
+    /**
+     * The element the editor renders itself into is what makes an interaction one of the editor's.
+     * The session is not tied to it: interactions from before it arrives are counted in `page`.
+     */
+  }, {
+    key: "setEditorRoot",
+    value: function setEditorRoot(root) {
+      this.editorRoot = root !== null && root !== void 0 ? root : undefined;
+      if (this.started && !this.stopped) {
+        this.editorEvents.observe(this.editorRoot);
+      }
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Counts an interaction with the editor, including the ones Event Timing never reports because
+     * they were faster than its threshold — which is why a count alone moves the session on.
+     */
+  }, {
+    key: "recordEditorEvent",
+    value: function recordEditorEvent(event) {
+      if (this.stopped) {
+        return;
+      }
+      var group = this.session.tracker.recordEditorEvent(event);
+      if (!group) {
+        return;
+      }
+
+      // The session names its editor groups after the fields they are reported in.
+      this.session[group].countTotal();
+      this.session.revision += 1;
+    }
+  }, {
+    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);
+            if (update.group) {
+              this.session[update.group].add(update.latencyMs);
+            }
+          } else {
+            page.remeasure(update.fromMs, update.toMs);
+            if (update.group) {
+              this.session[update.group].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 pageTotalCount = 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(),
+        // Only `page` is told its total; each editor group has counted its own.
+        page: session.page.snapshot(pageTotalCount),
+        editorTyping: session.editorTyping.snapshot(),
+        editorPointer: session.editorPointer.snapshot(),
+        editorOther: session.editorOther.snapshot()
+      });
+    }
+  }]);
+}();

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

@@ -0,0 +1,48 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { InteractionObserver } from './interaction-observer';
+import { InteractionTracker } from './interaction-tracker';
+import { InteractionGroup } from './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.
+ */
+export var InteractivitySession = /*#__PURE__*/_createClass(function InteractivitySession(start) {
+  _classCallCheck(this, InteractivitySession);
+  _defineProperty(this, "id", createSessionId());
+  _defineProperty(this, "startedAt", performance.now());
+  /** Page interaction count when the session opened, subtracted to get its own total. */
+  _defineProperty(this, "interactionCountAtStart", InteractionObserver.readPageInteractionCount());
+  _defineProperty(this, "page", new InteractionGroup());
+  _defineProperty(this, "editorTyping", new InteractionGroup());
+  _defineProperty(this, "editorPointer", new InteractionGroup());
+  _defineProperty(this, "editorOther", new InteractionGroup());
+  /** Increments per snapshot; a query takes the highest one per session. */
+  _defineProperty(this, "seq", 0);
+  _defineProperty(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.
+   */
+  _defineProperty(this, "revision", 0);
+  _defineProperty(this, "emittedRevision", 0);
+  /** One lifecycle snapshot per hidden episode; cleared when the page comes back. */
+  _defineProperty(this, "lifecycleSnapshotEmitted", false);
+  this.objectId = start.objectId;
+  this.mode = start.mode;
+  this.hiddenSince = start.hidden ? this.startedAt : undefined;
+  this.tracker = new InteractionTracker(start.startsAfterInteractionId);
+});