@atlaskit/editor-plugin-interactivity 0.1.0 → 0.3.0

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

@@ -0,0 +1,55 @@
+"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());
+  (0, _defineProperty2.default)(this, "editorTyping", new _interactionGroup.InteractionGroup());
+  (0, _defineProperty2.default)(this, "editorPointer", new _interactionGroup.InteractionGroup());
+  (0, _defineProperty2.default)(this, "editorOther", 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;
+    }
+  }]);
+}();

package/dist/cjs/interactivityPlugin.js

@@ -4,15 +4,102 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.interactivityPlugin = void 0;
+var _react = require("react");
+var _monitoring = require("@atlaskit/editor-common/monitoring");
+var _fireInteractivityEvent = require("./analytics/fire-interactivity-event");
+var _interactivityCollector = require("./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.
  */
-var interactivityPlugin = exports.interactivityPlugin = function interactivityPlugin() {
+var interactivityPlugin = exports.interactivityPlugin = function interactivityPlugin(_ref) {
+  var api = _ref.api;
   return {
-    name: 'interactivity'
+    name: 'interactivity',
+    usePluginHook: function usePluginHook(_ref2) {
+      var editorView = _ref2.editorView,
+        wrapperElement = _ref2.wrapperElement;
+      var collectorRef = (0, _react.useRef)(undefined);
+      (0, _react.useEffect)(function () {
+        try {
+          var _api$contextIdentifie2, _api$editorViewMode2;
+          var collector = new _interactivityCollector.InteractivityCollector({
+            emit: function emit(snapshot) {
+              var _api$analytics;
+              return (0, _fireInteractivityEvent.fireInteractivityEvent)(api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions, snapshot);
+            },
+            getObjectId: function getObjectId() {
+              var _api$contextIdentifie;
+              return api === null || api === void 0 || (_api$contextIdentifie = api.contextIdentifier) === null || _api$contextIdentifie === void 0 || (_api$contextIdentifie = _api$contextIdentifie.sharedState.currentState()) === null || _api$contextIdentifie === void 0 || (_api$contextIdentifie = _api$contextIdentifie.contextIdentifierProvider) === null || _api$contextIdentifie === void 0 ? void 0 : _api$contextIdentifie.objectId;
+            },
+            getSessionMode: function getSessionMode() {
+              var _api$editorViewMode;
+              var mode = api === null || api === void 0 || (_api$editorViewMode = api.editorViewMode) === null || _api$editorViewMode === void 0 || (_api$editorViewMode = _api$editorViewMode.sharedState.currentState()) === null || _api$editorViewMode === void 0 ? void 0 : _api$editorViewMode.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: function getNodeSize() {
+              return 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: function getEditorDomSize() {
+              return 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.
+          var unsubscribeFromObjectId = api === null || api === void 0 || (_api$contextIdentifie2 = api.contextIdentifier) === null || _api$contextIdentifie2 === void 0 ? void 0 : _api$contextIdentifie2.sharedState.onChange(function () {
+            return collector.onObjectIdChanged();
+          });
+          var unsubscribeFromViewMode = api === null || api === void 0 || (_api$editorViewMode2 = api.editorViewMode) === null || _api$editorViewMode2 === void 0 ? void 0 : _api$editorViewMode2.sharedState.onChange(function () {
+            return collector.onViewModeChanged();
+          });
+          return function () {
+            unsubscribeFromObjectId === null || unsubscribeFromObjectId === void 0 || unsubscribeFromObjectId();
+            unsubscribeFromViewMode === null || unsubscribeFromViewMode === 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 (0, _monitoring.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]);
+      (0, _react.useEffect)(function () {
+        try {
+          var _collectorRef$current;
+          (_collectorRef$current = collectorRef.current) === null || _collectorRef$current === void 0 || _collectorRef$current.setEditorRoot(wrapperElement);
+        } catch (error) {
+          void (0, _monitoring.logException)(error, {
+            location: 'editor-plugin-interactivity/observe'
+          });
+        }
+      }, [wrapperElement]);
+    }
   };
 };

package/dist/es2019/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. */
+const 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 ? 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/es2019/collector/bucket-boundaries.js

@@ -0,0 +1,117 @@
+/**
+ * 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 const 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 const 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.
+ */
+const EXACT_THRESHOLDS_MS = [500];
+const 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.
+ */
+const EVENLY_SPACED_STEP_MS = 8;
+const 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.
+  const EPSILON = 1e-9;
+  const 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. */
+const EXACT_THRESHOLD_BUCKETS = EXACT_THRESHOLDS_MS.map(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.
+    const steps = Math.ceil((latencyMs - REPORTING_THRESHOLD_MS) / EVENLY_SPACED_STEP_MS);
+    return REPORTING_THRESHOLD_MS + steps * EVENLY_SPACED_STEP_MS;
+  }
+  const 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.
+  for (const {
+    thresholdMs,
+    bucketMs
+  } of EXACT_THRESHOLD_BUCKETS) {
+    if (boundary === bucketMs && latencyMs <= thresholdMs) {
+      return thresholdMs;
+    }
+  }
+  return boundary;
+}

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

@@ -0,0 +1,46 @@
+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 class EditorEventObserver {
+  constructor(onEvent) {
+    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.
+   */
+  observe(root) {
+    const 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(type => ({
+      type,
+      listener: this.onEvent
+    })),
+    // Capture, so a handler in the editor cannot stop an interaction from being reported.
+    {
+      capture: true,
+      passive: true
+    });
+  }
+  stop() {
+    var _this$unbind;
+    (_this$unbind = this.unbind) === null || _this$unbind === void 0 ? void 0 : _this$unbind.call(this);
+    this.unbind = undefined;
+    this.root = undefined;
+  }
+}

package/dist/es2019/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.
+ */
+const 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 const INTERACTION_EVENT_TYPES = Object.keys(INTERACTION_EVENTS);
+export function interactionEventKind(type) {
+  return INTERACTION_EVENTS[type];
+}