@atlaskit/editor-plugin-interactivity 0.1.0 → 0.3.0

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

@@ -0,0 +1,46 @@
+import { bind } from 'bind-event-listener';
+import { getDocument } from '@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.
+ */
+export class LifecycleObserver {
+  constructor(handlers) {
+    this.handlers = handlers;
+  }
+  start() {
+    const doc = getDocument();
+    const unbindVisibilityChange = doc ? bind(doc, {
+      type: 'visibilitychange',
+      listener: () => {
+        if (doc.visibilityState === 'hidden') {
+          this.handlers.onHidden();
+        } else {
+          this.handlers.onVisible();
+        }
+      }
+    }) : undefined;
+    const unbindPageHide = bind(window, {
+      type: 'pagehide',
+      listener: () => this.handlers.onPageHide()
+    });
+    const unbindPageShow = bind(window, {
+      type: 'pageshow',
+      listener: () => this.handlers.onPageShow()
+    });
+    this.unbind = () => {
+      unbindVisibilityChange === null || unbindVisibilityChange === void 0 ? void 0 : unbindVisibilityChange();
+      unbindPageHide();
+      unbindPageShow();
+    };
+  }
+  stop() {
+    var _this$unbind;
+    (_this$unbind = this.unbind) === null || _this$unbind === void 0 ? void 0 : _this$unbind.call(this);
+    this.unbind = undefined;
+  }
+}

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

@@ -0,0 +1,48 @@
+import _defineProperty from "@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.
+ */
+const INITIAL_OFFSETS_MS = [10_000, 30_000, 60_000];
+const INTERVAL_MS = 60_000;
+
+/**
+ * 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.
+ */
+export class SnapshotScheduler {
+  constructor(onTick) {
+    _defineProperty(this, "tickIndex", 0);
+    this.onTick = onTick;
+  }
+  start() {
+    this.tickIndex = 0;
+    this.scheduleNext();
+  }
+  restart() {
+    this.stop();
+    this.start();
+  }
+  stop() {
+    if (this.timeoutId !== undefined) {
+      window.clearTimeout(this.timeoutId);
+      this.timeoutId = undefined;
+    }
+  }
+  scheduleNext() {
+    this.timeoutId = window.setTimeout(() => {
+      this.tickIndex += 1;
+      this.onTick();
+      this.scheduleNext();
+    }, this.delayForNextTick());
+  }
+  delayForNextTick() {
+    const offset = INITIAL_OFFSETS_MS[this.tickIndex];
+    if (offset === undefined) {
+      return INTERVAL_MS;
+    }
+    const previousOffset = this.tickIndex === 0 ? 0 : INITIAL_OFFSETS_MS[this.tickIndex - 1];
+    return offset - previousOffset;
+  }
+}

package/dist/es2019/interactivityPlugin.js

@@ -1,10 +1,91 @@
+import { useEffect, useRef } from 'react';
+import { logException } from '@atlaskit/editor-common/monitoring';
+import { fireInteractivityEvent } from './analytics/fire-interactivity-event';
+import { InteractivityCollector } from './collector/interactivity-collector';
 /**
- * Reports interaction latency distributions for full page editor sessions as the
- * `editor interactivity` operational event.
+ * Reports session-to-date interaction latency distributions for full page editor sessions
+ * as the `editor interactivity` operational event.
  *
- * A stub for now: the plugin only registers itself. The collector and the event land in
- * EDITOR-8553.
+ * The session runs for as long as the plugin's hook stays mounted, which is one editor
+ * mount: `MountPluginHooks` in editor-core keys hook fibers by plugin name, so a preset
+ * reconfigure — which destroys and recreates ProseMirror plugin views — leaves this hook,
+ * and the session, in place.
  */
-export const interactivityPlugin = () => ({
-  name: 'interactivity'
+export const interactivityPlugin = ({
+  api
+}) => ({
+  name: 'interactivity',
+  usePluginHook({
+    editorView,
+    wrapperElement
+  }) {
+    const collectorRef = useRef(undefined);
+    useEffect(() => {
+      try {
+        var _api$contextIdentifie4, _api$editorViewMode2;
+        const collector = new InteractivityCollector({
+          emit: snapshot => {
+            var _api$analytics;
+            return fireInteractivityEvent(api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions, snapshot);
+          },
+          getObjectId: () => {
+            var _api$contextIdentifie, _api$contextIdentifie2, _api$contextIdentifie3;
+            return api === null || api === void 0 ? void 0 : (_api$contextIdentifie = api.contextIdentifier) === null || _api$contextIdentifie === void 0 ? void 0 : (_api$contextIdentifie2 = _api$contextIdentifie.sharedState.currentState()) === null || _api$contextIdentifie2 === void 0 ? void 0 : (_api$contextIdentifie3 = _api$contextIdentifie2.contextIdentifierProvider) === null || _api$contextIdentifie3 === void 0 ? void 0 : _api$contextIdentifie3.objectId;
+          },
+          getSessionMode: () => {
+            var _api$editorViewMode, _api$editorViewMode$s;
+            const mode = api === null || api === void 0 ? void 0 : (_api$editorViewMode = api.editorViewMode) === null || _api$editorViewMode === void 0 ? void 0 : (_api$editorViewMode$s = _api$editorViewMode.sharedState.currentState()) === null || _api$editorViewMode$s === void 0 ? void 0 : _api$editorViewMode$s.mode;
+            if (mode === undefined) {
+              return undefined;
+            }
+            return mode === 'view' ? 'reading' : 'editing';
+          },
+          // A destroyed view still answers, with the document it was destroyed with, so
+          // both report nothing rather than a size the editor no longer has.
+          getNodeSize: () => editorView.isDestroyed ? undefined : editorView.state.doc.nodeSize,
+          // `getElementsByTagName` counts descendants in the browser engine, so this
+          // cannot overflow the stack on very large documents.
+          getEditorDomSize: () => editorView.isDestroyed ? undefined : editorView.dom.getElementsByTagName('*').length
+        });
+
+        // Effects run in declaration order, so the one below always finds it.
+        collectorRef.current = collector;
+        if (!collector.start()) {
+          return;
+        }
+
+        // Confluence live pages navigate and switch between reading and editing without
+        // remounting the editor. A session covers one document in one mode, so either
+        // change ends it and starts the next.
+        const unsubscribeFromObjectId = api === null || api === void 0 ? void 0 : (_api$contextIdentifie4 = api.contextIdentifier) === null || _api$contextIdentifie4 === void 0 ? void 0 : _api$contextIdentifie4.sharedState.onChange(() => collector.onObjectIdChanged());
+        const unsubscribeFromViewMode = api === null || api === void 0 ? void 0 : (_api$editorViewMode2 = api.editorViewMode) === null || _api$editorViewMode2 === void 0 ? void 0 : _api$editorViewMode2.sharedState.onChange(() => collector.onViewModeChanged());
+        return () => {
+          unsubscribeFromObjectId === null || unsubscribeFromObjectId === void 0 ? void 0 : unsubscribeFromObjectId();
+          unsubscribeFromViewMode === null || unsubscribeFromViewMode === void 0 ? void 0 : unsubscribeFromViewMode();
+          collector.stop();
+        };
+      } catch (error) {
+        // Instrumentation must not fail the editor around it, but a failure that hits every
+        // browser of one engine would be invisible without this.
+        void logException(error, {
+          location: 'editor-plugin-interactivity/start'
+        });
+        return;
+      }
+      // `api` is deliberately not a dependency: a preset reconfigure hands out a new
+      // proxy object, but the one captured here keeps resolving plugins from the same
+      // live registry, and restarting the session on a reconfigure would split one
+      // editor session in two.
+    }, [editorView]);
+    useEffect(() => {
+      try {
+        var _collectorRef$current;
+        (_collectorRef$current = collectorRef.current) === null || _collectorRef$current === void 0 ? void 0 : _collectorRef$current.setEditorRoot(wrapperElement);
+      } catch (error) {
+        void logException(error, {
+          location: 'editor-plugin-interactivity/observe'
+        });
+      }
+    }, [wrapperElement]);
+  }
 });

package/dist/esm/analytics/fire-interactivity-event.js

@@ -0,0 +1,33 @@
+import { ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics/types/enums';
+/** The reasons that mean the page may not be around long enough to deliver a queued event. */
+var REASONS_THE_PAGE_MAY_NOT_OUTLIVE = ['hidden', 'pagehide', 'unmount'];
+
+/**
+ * The `editor interactivity` operational event.
+ *
+ * `editorSessionId` arrives without being set here: `@atlaskit/analytics-listeners` merges
+ * the editor analytics context into the attributes of every event on the editor channel.
+ * `objectId` comes both from that context and from the snapshot, which carries the value
+ * the session was collected against.
+ */
+
+/**
+ * Sends a snapshot as the `editor interactivity` event.
+ *
+ * Does nothing without the analytics plugin: an editor without it has nowhere to send events,
+ * and the collector keeps measuring either way.
+ */
+export function fireInteractivityEvent(analytics, snapshot) {
+  analytics === null || analytics === void 0 || analytics.fireAnalyticsEvent({
+    action: 'interactivity',
+    actionSubject: ACTION_SUBJECT.EDITOR,
+    eventType: EVENT_TYPE.OPERATIONAL,
+    attributes: snapshot
+  }, undefined,
+  // Events are queued into an idle callback by default, which a page being unloaded never
+  // runs and a backgrounded tab throttles. The snapshots taken because the page is going
+  // away go immediately; the rest can wait their turn.
+  {
+    immediate: REASONS_THE_PAGE_MAY_NOT_OUTLIVE.includes(snapshot.reason)
+  });
+}

package/dist/esm/collector/bucket-boundaries.js

@@ -0,0 +1,130 @@
+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; }
+/**
+ * Bucket boundaries for the interaction latency buckets, version 1.
+ *
+ * Two ranges:
+ * - 16 ms to 200 ms — a boundary every 8 ms: 16, 24, 32, … 200. Event Timing rounds
+ *   durations to 8 ms, so nothing finer is measurable.
+ * - above 200 ms — each boundary ~15% above the previous one, five of them per doubling:
+ *   222, 256, 294, 337, 388, 445, 512, … A 40 ms difference matters at 100 ms and is
+ *   noise at 4 seconds, so buckets grow with the latency instead of staying 8 ms wide.
+ *
+ * 500 ms — the Google INP "poor" threshold — falls inside the 445…512 bucket, so that one
+ * bucket is split at 500 to count the threshold instead of interpolating it. 200 ms, the
+ * "good" threshold, is already a boundary.
+ *
+ * Bump SCHEMA_VERSION whenever any boundary moves; queries group by it.
+ */
+export var SCHEMA_VERSION = 1;
+
+/**
+ * Event Timing reporting threshold. Faster interactions are never delivered to the
+ * observer, so they reach no bucket at all — `performance.interactionCount` is what counts
+ * them, as `totalCount - observedCount`. This bucket holds the interactions reported at
+ * exactly the threshold.
+ */
+export var REPORTING_THRESHOLD_MS = 16;
+
+/**
+ * Exceptions to the grid: latencies that must be a boundary of their own so that they are
+ * counted exactly rather than read off a bucket that spans them. Each one splits the bucket it
+ * falls inside. 500 ms is the Google INP "poor" threshold; the "good" one, 200 ms, needs no
+ * exception because the evenly spaced range already ends there.
+ *
+ * Every entry has to sit above that range, and adding one changes the reported keys, so bump
+ * SCHEMA_VERSION with it.
+ */
+var EXACT_THRESHOLDS_MS = [500];
+var EVENLY_SPACED_MAX_MS = 200;
+/**
+ * Keep this a multiple of 8 (8, 16, 24, …). Event Timing reports durations in 8 ms steps, so a
+ * step that is not a multiple of 8 leaves buckets no interaction can ever land in.
+ */
+var EVENLY_SPACED_STEP_MS = 8;
+var BOUNDARIES_PER_DOUBLING = 5;
+
+/**
+ * The first boundary at or above `latencyMs`, for the range above 200 ms.
+ *
+ * Five boundaries per doubling is the same as saying the nth boundary sits at `2^(n/5)` ms —
+ * boundary 40 at 256 ms, 45 at 512 ms, 50 at 1024 ms. So this turns the latency into a
+ * boundary number, rounds that up, and turns it back into milliseconds.
+ *
+ * Boundaries are floored to whole milliseconds, which keeps each one at or below the exact
+ * value it stands for. That is what makes `bucketKeyForMs(boundary) === boundary` hold.
+ */
+function firstBoundaryAtOrAbove(latencyMs) {
+  // `Math.log2(latencyMs) * 5` is the boundary number: log2 answers how many doublings of
+  // 1 ms reach this latency, and five boundaries cover each doubling.
+  //
+  // A latency sitting on a boundary makes that a whole number, which `Math.ceil` has to
+  // keep. ECMA-262 only requires `Math.log2` to be approximate, so 9.0000000000000002 for
+  // `log2(512)` would round up to boundary 46 and report 512 ms as 588 ms. EPSILON is
+  // larger than such imprecision and far smaller than the gap between two boundaries.
+  var EPSILON = 1e-9;
+  var boundaryNumber = Math.ceil(BOUNDARIES_PER_DOUBLING * Math.log2(latencyMs) - EPSILON);
+
+  // One `Math.pow` over the whole exponent, so the result is rounded once. Multiplying the
+  // ratio between neighbouring boundaries (2^(1/5) ≈ 1.1487) by itself instead accumulates
+  // the rounding of every step, reaching 512.0000000000018 by boundary 45.
+  return Math.floor(Math.pow(2, boundaryNumber / BOUNDARIES_PER_DOUBLING));
+}
+
+/** The bucket each exact threshold splits — 500 ms splits the one ending at 512 ms. */
+var EXACT_THRESHOLD_BUCKETS = EXACT_THRESHOLDS_MS.map(function (thresholdMs) {
+  return {
+    thresholdMs: thresholdMs,
+    bucketMs: firstBoundaryAtOrAbove(thresholdMs)
+  };
+});
+
+/**
+ * The bucket a latency belongs to, identified by the bucket's upper boundary in whole
+ * milliseconds — which is also its key in the reported buckets.
+ *
+ * Every latency gets a bucket, however slow: the boundaries continue upwards, so there is no
+ * overflow bucket. Expects the whole-millisecond durations Event Timing reports; boundaries
+ * are floored, so a fractional latency can land in a bucket whose key reads up to a
+ * millisecond below it. Non-finite latencies never reach here — `InteractionTracker` drops
+ * them as it reads the entry.
+ */
+export function bucketKeyForMs(latencyMs) {
+  if (latencyMs <= REPORTING_THRESHOLD_MS) {
+    return REPORTING_THRESHOLD_MS;
+  }
+  if (latencyMs <= EVENLY_SPACED_MAX_MS) {
+    // How many 8 ms steps above the threshold the latency is, rounded up: 17 ms is 0.125
+    // steps up and lands on the boundary one step up, 24 ms. Rounding up is what keeps the
+    // set of keys fixed when a latency is not a multiple of 8 ms.
+    //
+    // No EPSILON here, unlike the branch below: subtracting whole numbers gives a whole
+    // number, and dividing by a power of two shifts a binary float's exponent without
+    // touching its digits, so a latency on a boundary cannot come out just above a whole
+    // number of steps.
+    var steps = Math.ceil((latencyMs - REPORTING_THRESHOLD_MS) / EVENLY_SPACED_STEP_MS);
+    return REPORTING_THRESHOLD_MS + steps * EVENLY_SPACED_STEP_MS;
+  }
+  var boundary = firstBoundaryAtOrAbove(latencyMs);
+
+  // A latency in the lower part of a split bucket is reported as the threshold itself, so the
+  // threshold is counted exactly.
+  var _iterator = _createForOfIteratorHelper(EXACT_THRESHOLD_BUCKETS),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+        thresholdMs = _step$value.thresholdMs,
+        bucketMs = _step$value.bucketMs;
+      if (boundary === bucketMs && latencyMs <= thresholdMs) {
+        return thresholdMs;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return boundary;
+}

package/dist/esm/collector/editor-event-observer.js

@@ -0,0 +1,57 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { bindAll } from 'bind-event-listener';
+import { INTERACTION_EVENT_TYPES } from './interaction-events';
+
+/**
+ * Reports the events the interactions with the editor are made of, as the browser dispatched
+ * them. What they mean is the tracker's business.
+ *
+ * Event Timing cannot answer which interactions were with the editor, because it observes the
+ * whole document, nor how many there were, because it reports none below 16 ms.
+ */
+export var EditorEventObserver = /*#__PURE__*/function () {
+  function EditorEventObserver(onEvent) {
+    _classCallCheck(this, EditorEventObserver);
+    this.onEvent = onEvent;
+  }
+
+  /**
+   * Called as the element the editor renders itself into changes: the editor only knows it after
+   * its first render, and can replace it.
+   */
+  return _createClass(EditorEventObserver, [{
+    key: "observe",
+    value: function observe(root) {
+      var _this = this;
+      var next = root !== null && root !== void 0 ? root : undefined;
+      if (next === this.root) {
+        return;
+      }
+      this.stop();
+      this.root = next;
+      if (!next) {
+        return;
+      }
+      this.unbind = bindAll(next, INTERACTION_EVENT_TYPES.map(function (type) {
+        return {
+          type: type,
+          listener: _this.onEvent
+        };
+      }),
+      // Capture, so a handler in the editor cannot stop an interaction from being reported.
+      {
+        capture: true,
+        passive: true
+      });
+    }
+  }, {
+    key: "stop",
+    value: function stop() {
+      var _this$unbind;
+      (_this$unbind = this.unbind) === null || _this$unbind === void 0 || _this$unbind.call(this);
+      this.unbind = undefined;
+      this.root = undefined;
+    }
+  }]);
+}();

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

@@ -0,0 +1,55 @@
+/**
+ * The editor group an interaction belongs to, which is also the field the event reports it in.
+ *
+ * `editorOther` is the remainder — an interaction the browser counts that is neither typing nor
+ * pointing — so the three groups together cover whatever the browser calls an interaction.
+ */
+
+/**
+ * The events an interaction is made of, and the group they belong to. Both sides of the collector
+ * read this, so counting and grouping cannot disagree.
+ *
+ * These are the events Event Timing can report with a non-zero `interactionId`, so any of them can
+ * be the one an entry measured — and it is usually not the one the interaction is counted on: for a
+ * pointer press the slow part is normally the `click` handler.
+ *
+ * The counted event is at a different end of the interaction in each group, because what can go
+ * wrong differs. Typing is counted on `keydown`, since the browser opens a new interaction for
+ * every repeat of a held key, and nothing cancels a key press. Pointing is counted on `pointerup`,
+ * since a press cannot repeat but can be taken over by a scroll — which the browser does not count
+ * either, and in that case `pointerup` never arrives.
+ */
+var INTERACTION_EVENTS = {
+  keydown: {
+    group: 'editorTyping',
+    counts: true
+  },
+  keyup: {
+    group: 'editorTyping'
+  },
+  // Only while an IME composes: the browser counts the text it commits in the interaction of the
+  // key that caused it.
+  input: {
+    group: 'editorTyping'
+  },
+  pointerdown: {
+    group: 'editorPointer'
+  },
+  pointerup: {
+    group: 'editorPointer',
+    counts: true
+  },
+  click: {
+    group: 'editorPointer'
+  },
+  // Ends a pointer press the way `pointerup` does, so the browser counts it as an interaction.
+  contextmenu: {
+    group: 'editorPointer'
+  }
+};
+
+/** Derived, so the types listened for cannot drift from the table. */
+export var INTERACTION_EVENT_TYPES = Object.keys(INTERACTION_EVENTS);
+export function interactionEventKind(type) {
+  return INTERACTION_EVENTS[type];
+}

package/dist/esm/collector/interaction-group.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 { 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.
+ *
+ * The two counters count different populations: `add` takes the interactions Event Timing
+ * measured, `countTotal` takes all of them, including the ones below the 16 ms reporting threshold
+ * it never delivers. So `totalCount >= observedCount`, and the difference is how many were too
+ * fast to be measured.
+ */
+export var InteractionGroup = /*#__PURE__*/function () {
+  function InteractionGroup() {
+    _classCallCheck(this, InteractionGroup);
+    _defineProperty(this, "countByLatency", new Map());
+    _defineProperty(this, "totalCount", 0);
+  }
+  return _createClass(InteractionGroup, [{
+    key: "add",
+    value: function add(latencyMs) {
+      this.increment(latencyMs);
+    }
+
+    /**
+     * Counts an interaction towards the group's total, measured or not. `page` has no use for it:
+     * `performance.interactionCount` counts the page's interactions.
+     */
+  }, {
+    key: "countTotal",
+    value: function countTotal() {
+      this.totalCount += 1;
+    }
+  }, {
+    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. Defaults to what `countTotal` was told, which is where an editor
+     * group's total comes from; `page` passes `performance.interactionCount` instead.
+     */
+  }, {
+    key: "snapshot",
+    value: function snapshot() {
+      var _latencies;
+      var totalCount = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.totalCount;
+      // 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);
+      }
+    }
+  }]);
+}();