@atlaskit/editor-plugin-interactivity 0.2.0 → 1.0.0

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

@@ -4,6 +4,8 @@ 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
@@ -13,12 +15,13 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 /**
  * 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.
+ * 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. Entries of one
- * interaction arrive within the interaction itself, so anything older is not needed.
+ * 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;
 /**
@@ -28,7 +31,17 @@ var MAX_TRACKED = 256;
 var PRUNE_BATCH = 64;
 
 /**
- * Groups Event Timing entries into interactions.
+ * 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
@@ -38,6 +51,9 @@ var PRUNE_BATCH = 64;
  * 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 () {
   /**
@@ -50,7 +66,8 @@ export var InteractionTracker = /*#__PURE__*/function () {
   function InteractionTracker() {
     var startsAfterInteractionId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     _classCallCheck(this, InteractionTracker);
-    _defineProperty(this, "latencies", new Map());
+    _defineProperty(this, "interactions", new Map());
+    _defineProperty(this, "groupByEvent", new Map());
     _defineProperty(this, "highestInteractionId", 0);
     this.startsAfterInteractionId = startsAfterInteractionId;
   }
@@ -87,41 +104,66 @@ export var InteractionTracker = /*#__PURE__*/function () {
       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();
+      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
+          latencyMs: entry.duration,
+          group: group
         };
       }
-      if (entry.duration <= previousLatencyMs) {
+      if (entry.duration <= tracked.latencyMs) {
         return undefined;
       }
-      this.latencies.set(interactionId, entry.duration);
+      var fromMs = tracked.latencyMs;
+      tracked.latencyMs = entry.duration;
       return {
         type: 'remeasured',
-        fromMs: previousLatencyMs,
-        toMs: entry.duration
+        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() {
-      if (this.latencies.size <= MAX_TRACKED) {
+    value: function prune(entries) {
+      if (entries.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.
+      // `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(this.latencies.keys()),
+      var _iterator = _createForOfIteratorHelper(entries.keys()),
         _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var interactionId = _step.value;
-          this.latencies.delete(interactionId);
+          var key = _step.value;
+          entries.delete(key);
           remaining -= 1;
           if (remaining === 0) {
             return;

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

@@ -5,6 +5,7 @@ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol
 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';
@@ -13,6 +14,9 @@ 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
@@ -32,6 +36,9 @@ export var InteractivityCollector = /*#__PURE__*/function () {
     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();
     });
@@ -76,6 +83,7 @@ export var InteractivityCollector = /*#__PURE__*/function () {
       // 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;
@@ -92,10 +100,24 @@ export var InteractivityCollector = /*#__PURE__*/function () {
       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.
      *
@@ -205,6 +227,26 @@ export var InteractivityCollector = /*#__PURE__*/function () {
     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) {
@@ -222,8 +264,14 @@ export var InteractivityCollector = /*#__PURE__*/function () {
           }
           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;
         }
@@ -263,7 +311,7 @@ export var InteractivityCollector = /*#__PURE__*/function () {
       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;
+      var pageTotalCount = InteractionObserver.readPageInteractionCount() - session.interactionCountAtStart;
       this.emit({
         schema: SCHEMA_VERSION,
         interactivitySessionId: session.id,
@@ -275,7 +323,11 @@ export var InteractivityCollector = /*#__PURE__*/function () {
         hiddenMs: Math.round(hiddenMs),
         nodeSize: this.getNodeSize(),
         editorDomSize: this.getEditorDomSize(),
-        page: session.page.snapshot(totalCount)
+        // 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

@@ -27,6 +27,9 @@ export var InteractivitySession = /*#__PURE__*/_createClass(function Interactivi
   /** 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);

package/dist/esm/interactivityPlugin.js

@@ -1,4 +1,4 @@
-import { useEffect } from 'react';
+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';
@@ -16,11 +16,10 @@ export var interactivityPlugin = function interactivityPlugin(_ref) {
   return {
     name: 'interactivity',
     usePluginHook: function usePluginHook(_ref2) {
-      var editorView = _ref2.editorView;
+      var editorView = _ref2.editorView,
+        wrapperElement = _ref2.wrapperElement;
+      var collectorRef = useRef(undefined);
       useEffect(function () {
-        // Nothing measured here is worth an editor. This effect runs inside the plugin slot's
-        // error boundary, which also renders every plugin's content components, so a throw
-        // from instrumentation would take that UI down with it.
         try {
           var _api$contextIdentifie2, _api$editorViewMode2;
           var collector = new InteractivityCollector({
@@ -51,6 +50,9 @@ export var interactivityPlugin = function interactivityPlugin(_ref) {
               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;
           }
@@ -82,6 +84,16 @@ export var interactivityPlugin = function interactivityPlugin(_ref) {
         // live registry, and restarting the session on a reconfigure would split one
         // editor session in two.
       }, [editorView]);
+      useEffect(function () {
+        try {
+          var _collectorRef$current;
+          (_collectorRef$current = collectorRef.current) === null || _collectorRef$current === void 0 || _collectorRef$current.setEditorRoot(wrapperElement);
+        } catch (error) {
+          void logException(error, {
+            location: 'editor-plugin-interactivity/observe'
+          });
+        }
+      }, [wrapperElement]);
     }
   };
 };

package/dist/types/analytics/interactivity-snapshot.d.ts

@@ -48,10 +48,15 @@ export type InteractionGroupSnapshot = {
 export type InteractivitySnapshot = {
     activeMs: number;
     editorDomSize?: number;
+    /** Interactions inside the editor that are neither typing nor pointing. */
+    editorOther: InteractionGroupSnapshot;
+    editorPointer: InteractionGroupSnapshot;
+    editorTyping: InteractionGroupSnapshot;
     hiddenMs: number;
     interactivitySessionId: string;
     nodeSize?: number;
     objectId?: string;
+    /** Every interaction on the page, the editor groups included. */
     page: InteractionGroupSnapshot;
     reason: SnapshotReason;
     schema: number;

package/dist/types/collector/editor-event-observer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 declare class EditorEventObserver {
+    private readonly onEvent;
+    private root;
+    private unbind;
+    constructor(onEvent: (event: Event) => void);
+    /**
+     * 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: Element | null | undefined): void;
+    stop(): void;
+}

package/dist/types/collector/interaction-events.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+export type EditorInteractionGroupName = 'editorOther' | 'editorPointer' | 'editorTyping';
+export type InteractionEventKind = {
+    /**
+     * Whether an interaction is counted when this event arrives. One event of each group has it,
+     * because an interaction is several events — `keydown`, what the key produced, `keyup`, or
+     * `pointerdown`, `pointerup`, `click` — and counting each would count it three times.
+     */
+    counts?: boolean;
+    group: EditorInteractionGroupName;
+};
+/** Derived, so the types listened for cannot drift from the table. */
+export declare const INTERACTION_EVENT_TYPES: string[];
+export declare function interactionEventKind(type: string): InteractionEventKind | undefined;

package/dist/types/collector/interaction-group.d.ts

@@ -7,16 +7,28 @@ import type { InteractionGroupSnapshot } from '../analytics/interactivity-snapsh
  * 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 declare class InteractionGroup {
     private countByLatency;
+    private totalCount;
     add(latencyMs: number): void;
+    /**
+     * Counts an interaction towards the group's total, measured or not. `page` has no use for it:
+     * `performance.interactionCount` counts the page's interactions.
+     */
+    countTotal(): void;
     remeasure(previousLatencyMs: number, latencyMs: number): void;
     /**
      * @param totalCount every interaction of the group, including those below the Event Timing
-     * reporting threshold, which this group never sees.
+     * reporting threshold. Defaults to what `countTotal` was told, which is where an editor
+     * group's total comes from; `page` passes `performance.interactionCount` instead.
      */
-    snapshot(totalCount: number): InteractionGroupSnapshot;
+    snapshot(totalCount?: number): InteractionGroupSnapshot;
     private observedCount;
     /** Rounding lives here so that every count goes through the same step, in or out. */
     private roundLatencyUp;

package/dist/types/collector/interaction-tracker.d.ts

@@ -1,3 +1,4 @@
+import type { EditorInteractionGroupName } 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
@@ -9,18 +10,20 @@ export type InteractionEntry = PerformanceEntry & {
 /**
  * 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.
+ * known to be. Both carry the editor group of the interaction, if it is one of the editor's.
  */
 export type InteractionUpdate = {
+    group: EditorInteractionGroupName | undefined;
     latencyMs: number;
     type: 'new';
 } | {
     fromMs: number;
+    group: EditorInteractionGroupName | undefined;
     toMs: number;
     type: 'remeasured';
 };
 /**
- * Groups Event Timing entries into interactions.
+ * 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
@@ -30,10 +33,14 @@ export type InteractionUpdate = {
  * 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 declare class InteractionTracker {
-    private latencies;
     private readonly startsAfterInteractionId;
+    private readonly interactions;
+    private readonly groupByEvent;
     private highestInteractionId;
     /**
      * @param startsAfterInteractionId interactions up to and including this one belong to the
@@ -52,5 +59,7 @@ export declare class InteractionTracker {
      * part of an interaction, belongs to a previous tracker, or does not change one.
      */
     merge(entry: InteractionEntry): InteractionUpdate | undefined;
+    /** @returns the group of an interaction to count, when this is the event its group counts on. */
+    recordEditorEvent(event: Event): EditorInteractionGroupName | undefined;
     private prune;
 }

package/dist/types/collector/interactivity-collector.d.ts

@@ -11,6 +11,9 @@ export type InteractivityCollectorOptions = {
 /**
  * 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
@@ -23,9 +26,11 @@ export declare class InteractivityCollector {
     private readonly getObjectId;
     private readonly getSessionMode;
     private readonly interactionObserver;
+    private readonly editorEvents;
     private readonly snapshotScheduler;
     private readonly lifecycleObserver;
     private session;
+    private editorRoot;
     private started;
     private stopped;
     constructor(options: InteractivityCollectorOptions);
@@ -38,6 +43,11 @@ export declare class InteractivityCollector {
     start(): boolean;
     /** Reports the session as ended by the editor unmounting, and stops collecting. */
     stop(): void;
+    /**
+     * 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`.
+     */
+    setEditorRoot(root: Element | null | undefined): void;
     /**
      * Rotates the session when the editor is pointed at different content.
      *
@@ -70,6 +80,11 @@ export declare class InteractivityCollector {
      * one is due.
      */
     private onPageShow;
+    /**
+     * 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.
+     */
+    private recordEditorEvent;
     private recordEntries;
     private takeSnapshot;
 }

package/dist/types/collector/interactivity-session.d.ts

@@ -20,6 +20,9 @@ export declare class InteractivitySession {
     readonly interactionCountAtStart: number;
     readonly tracker: InteractionTracker;
     readonly page: InteractionGroup;
+    readonly editorTyping: InteractionGroup;
+    readonly editorPointer: InteractionGroup;
+    readonly editorOther: InteractionGroup;
     /** Increments per snapshot; a query takes the highest one per session. */
     seq: number;
     /** Both fixed for the session: a change to either closes it and opens the next. */

package/docs/0-intro.tsx

@@ -24,7 +24,8 @@ ${createEditorUseOnlyNotice('Editor Plugin Interactivity', [
   This package includes the interactivity plugin used by \`@atlaskit/editor-core\`.
 
   It reports the \`editor interactivity\` operational event: session-to-date interaction latency
-  histograms for full page editor sessions, per [RFC 095](https://hello.atlassian.net/wiki/spaces/EDITOR/pages/7527607488/Editor+RFC+095+Confluence+editor+responsiveness+bucketed+INP+telemetry).
+  histograms for full page editor sessions — for the page as a whole, and for the editor's typing,
+  pointer and other interactions — per [RFC 095](https://hello.atlassian.net/wiki/spaces/EDITOR/pages/7527607488/Editor+RFC+095+Confluence+editor+responsiveness+bucketed+INP+telemetry).
   See the package README for the event shape, the snapshot cadence and what ends a session.
 
   The plugin has no configuration, state, actions or commands — adding it to a preset is what turns

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-interactivity",
-	"version": "0.2.0",
+	"version": "1.0.0",
 	"description": "Interactivity plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -20,14 +20,14 @@
 	"sideEffects": false,
 	"dependencies": {
 		"@atlaskit/browser-apis": "^1.2.0",
-		"@atlaskit/editor-plugin-analytics": "^15.0.0",
-		"@atlaskit/editor-plugin-context-identifier": "^15.0.0",
-		"@atlaskit/editor-plugin-editor-viewmode": "^17.0.0",
+		"@atlaskit/editor-plugin-analytics": "^16.0.0",
+		"@atlaskit/editor-plugin-context-identifier": "^16.0.0",
+		"@atlaskit/editor-plugin-editor-viewmode": "^18.0.0",
 		"@babel/runtime": "^7.0.0",
 		"bind-event-listener": "^3.0.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^119.9.0",
+		"@atlaskit/editor-common": "^120.0.0",
 		"react": "^18.2.0 || ^19.2.0"
 	},
 	"devDependencies": {