@atlaskit/insm 1.2.12 → 2.0.0

package/dist/es2019/insm.js

@@ -1,6 +1,7 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { countDomElements } from './dom-element-count';
+import { EditorDomRegistry } from './editor-dom-registry';
 import { INSMSession } from './insm-session';
-import { AnimationFPSIM } from './period-measurers/afps';
 import { INPTracker } from './inp-measurers/inp';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 export class INSM {
@@ -11,7 +12,12 @@ export class INSM {
      * page session.
      */
     _defineProperty(this, "runningHeavyTasks", new Set());
-    this.periodMeasurers = [expValEquals('platform_editor_disable_afps', 'isEnabled', true) ? undefined : new AnimationFPSIM(), new INPTracker()];
+    /**
+     * The editor is tracked at the insm layer (rather than per session) as it can
+     * outlive, or be mounted after, the session it is measured by.
+     */
+    _defineProperty(this, "editorDomRegistry", new EditorDomRegistry());
+    this.periodMeasurers = [new INPTracker()];
     this.options = options;
 
     // If this does throw -- we do want an unhandledRejection rejection to be passed to the window
@@ -72,6 +78,44 @@ export class INSM {
     }
   }
 
+  /**
+   * Registers the page editor's content DOM element (`editorView.dom`) with insm.
+   *
+   * insm does not locate the editor itself - the element is provided by the editor so
+   * that session events can report its DOM element count (`editorDomSize`).
+   *
+   * A session measures a page, so only the page's own editor should register. Secondary
+   * editors (inline comments, nested legacy content extensions) must not, as the
+   * reported size would then depend on which editor registered last.
+   *
+   * ```ts
+   * insm.registerEditorDom(editorView.dom);
+   * ```
+   */
+  registerEditorDom(editorDom) {
+    this.editorDomRegistry.register(editorDom);
+  }
+
+  /**
+   * Unregisters the editor's content DOM element. This is expected to be called when
+   * the editor is destroyed.
+   */
+  unregisterEditorDom(editorDom) {
+    this.editorDomRegistry.unregister(editorDom);
+  }
+
+  /**
+   * The number of DOM elements inside the registered editor, used as a proxy for
+   * document complexity in performance events.
+   *
+   * Undefined when no editor is registered, or the registered one is no longer in
+   * the document.
+   */
+  getEditorDomSize() {
+    const editorDom = this.editorDomRegistry.editorDom;
+    return editorDom ? countDomElements(editorDom) : undefined;
+  }
+
   /**
    * Call this when starting a new experience.  This is expected to be wired to the product
    * routing solution.

package/dist/esm/api.js

@@ -0,0 +1,70 @@
+import { INSM } from './insm';
+var initialisedInsm;
+
+/**
+ * Initializes the INSM (Interactivity Session Measurement) tooling
+ */
+export function init(options) {
+  initialisedInsm = new INSM(options);
+}
+function insmInitialised() {
+  if (!initialisedInsm) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * **In**teractivity **s**ession **m**onitoring
+ */
+export var insm = {
+  startHeavyTask: function startHeavyTask(heavyTaskName) {
+    if (insmInitialised()) {
+      initialisedInsm.startHeavyTask(heavyTaskName);
+    }
+  },
+  endHeavyTask: function endHeavyTask(heavyTaskName) {
+    if (insmInitialised()) {
+      initialisedInsm.endHeavyTask(heavyTaskName);
+    }
+  },
+  registerEditorDom: function registerEditorDom(editorDom) {
+    if (insmInitialised()) {
+      initialisedInsm.registerEditorDom(editorDom);
+    }
+  },
+  unregisterEditorDom: function unregisterEditorDom(editorDom) {
+    if (insmInitialised()) {
+      initialisedInsm.unregisterEditorDom(editorDom);
+    }
+  },
+  start: function start(experienceKey, experienceProperties) {
+    if (insmInitialised()) {
+      initialisedInsm.start(experienceKey, experienceProperties);
+    }
+  },
+  overrideExperienceKey: function overrideExperienceKey(experienceKey) {
+    if (insmInitialised()) {
+      initialisedInsm.overrideExperienceKey(experienceKey);
+    }
+  },
+  stopEarly: function stopEarly(reasonKey, description) {
+    if (insmInitialised()) {
+      initialisedInsm.stopEarly(reasonKey, description);
+    }
+  },
+  // We only expose details and feature start/stop to consumers
+  // as the other properties are internals for the insm and InsmPeriod
+  // to interact with the running session.
+  get session() {
+    if (insmInitialised()) {
+      return initialisedInsm.runningSession;
+    }
+  },
+  // @ts-expect-error Private method for testing purposes
+  __setAnalyticsWebClient: function __setAnalyticsWebClient(analyticsWebClient) {
+    if (initialisedInsm) {
+      initialisedInsm.analyticsWebClient = analyticsWebClient;
+    }
+  }
+};

package/dist/esm/dom-element-count.js

@@ -0,0 +1,10 @@
+/**
+ * Returns the total number of DOM elements inside the given element.
+ *
+ * Uses the native `getElementsByTagName('*')`, which counts descendants iteratively in the
+ * browser engine -- intentionally not a recursive JS walk, so it can't overflow the stack on
+ * very large documents.
+ */
+export function countDomElements(element) {
+  return element.getElementsByTagName('*').length;
+}

package/dist/esm/editor-dom-registry.js

@@ -0,0 +1,58 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+/**
+ * Holds the page editor's content DOM.
+ *
+ * insm holds no reference to the editor, so the element is registered from the outside — it is
+ * the same `editorView.dom` element the editor measures for the `editorDomSize` attribute on
+ * its INP event.
+ *
+ * Only the page editor registers itself: an insm session measures a page, and secondary
+ * editors on the page (inline comments, nested legacy content extensions) would make the
+ * registration ambiguous.
+ *
+ * The element is held via a `WeakRef` so a destroyed editor's DOM can be collected even if
+ * `unregister` is never reached.
+ */
+export var EditorDomRegistry = /*#__PURE__*/function () {
+  function EditorDomRegistry() {
+    _classCallCheck(this, EditorDomRegistry);
+  }
+  return _createClass(EditorDomRegistry, [{
+    key: "register",
+    value:
+    /**
+     * Registers the page editor's content DOM element (`editorView.dom`).
+     */
+    function register(editorDom) {
+      this.registered = new WeakRef(editorDom);
+    }
+
+    /**
+     * Unregisters an editor's content DOM element. Expected to be called when the editor is
+     * destroyed. Ignored when a different editor is currently registered, so an editor being
+     * torn down after its replacement registered does not clear the newer one.
+     */
+  }, {
+    key: "unregister",
+    value: function unregister(editorDom) {
+      var _this$registered;
+      if (((_this$registered = this.registered) === null || _this$registered === void 0 ? void 0 : _this$registered.deref()) === editorDom) {
+        this.registered = undefined;
+      }
+    }
+
+    /**
+     * The registered editor's content DOM, or undefined when no editor is registered or the
+     * registered one is no longer in the document -- ie. an experience without a page editor,
+     * or a session which outlived the editor.
+     */
+  }, {
+    key: "editorDom",
+    get: function get() {
+      var _this$registered2;
+      var editorDom = (_this$registered2 = this.registered) === null || _this$registered2 === void 0 ? void 0 : _this$registered2.deref();
+      return editorDom !== null && editorDom !== void 0 && editorDom.isConnected ? editorDom : undefined;
+    }
+  }]);
+}();

package/dist/esm/index.js

@@ -1,60 +1,5 @@
-import { INSM } from './insm';
-var initialisedInsm;
-
-/**
- * Initializes the INSM (Interactivity Session Measurement) tooling
- */
-export function init(options) {
-  initialisedInsm = new INSM(options);
-}
-function insmInitialised() {
-  if (!initialisedInsm) {
-    return false;
-  }
-  return true;
-}
-
-/**
- * **In**teractivity **s**ession **m**onitoring
- */
-export var insm = {
-  startHeavyTask: function startHeavyTask(heavyTaskName) {
-    if (insmInitialised()) {
-      initialisedInsm.startHeavyTask(heavyTaskName);
-    }
-  },
-  endHeavyTask: function endHeavyTask(heavyTaskName) {
-    if (insmInitialised()) {
-      initialisedInsm.endHeavyTask(heavyTaskName);
-    }
-  },
-  start: function start(experienceKey, experienceProperties) {
-    if (insmInitialised()) {
-      initialisedInsm.start(experienceKey, experienceProperties);
-    }
-  },
-  overrideExperienceKey: function overrideExperienceKey(experienceKey) {
-    if (insmInitialised()) {
-      initialisedInsm.overrideExperienceKey(experienceKey);
-    }
-  },
-  stopEarly: function stopEarly(reasonKey, description) {
-    if (insmInitialised()) {
-      initialisedInsm.stopEarly(reasonKey, description);
-    }
-  },
-  // We only expose details and feature start/stop to consumers
-  // as the other properties are internals for the insm and InsmPeriod
-  // to interact with the running session.
-  get session() {
-    if (insmInitialised()) {
-      return initialisedInsm.runningSession;
-    }
-  },
-  // @ts-expect-error Private method for testing purposes
-  __setAnalyticsWebClient: function __setAnalyticsWebClient(analyticsWebClient) {
-    if (initialisedInsm) {
-      initialisedInsm.analyticsWebClient = analyticsWebClient;
-    }
-  }
-};
+/* eslint-disable @atlaskit/editor/no-re-export */
+// Entry file in package.json
+// Barrel kept for existing consumers -- new call sites should import from the
+// `@atlaskit/insm/api` entry point instead.
+export { init, insm } from './api';

package/dist/esm/insm-session.js

@@ -7,6 +7,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 Bowser from 'bowser-ultralight';
+import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { PeriodTracking } from './insm-period';
 import { LongAnimationFrameMeasurer } from './session-measurers/LongAnimationFrameMeasurer';
@@ -198,11 +199,14 @@ export var INSMSession = /*#__PURE__*/function () {
       var operationalEvent = {
         actionSubject: 'insm',
         action: 'measured',
-        attributes: _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, this.staticProperties), evaluatedAddedProperties), {}, {
+        attributes: _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, this.staticProperties), evaluatedAddedProperties), {}, {
           'event:population': this.insm.options.population,
           experienceKey: this.experienceKey,
           initial: this.experienceProperties.initial,
-          contentId: this.experienceProperties.contentId,
+          contentId: this.experienceProperties.contentId
+        }, isExperimentEnabled('platform_editor_insm_dom_node_count') ? {
+          editorDomSize: this.insm.getEditorDomSize()
+        } : {}), {}, {
           timing: {
             startedAt: this.startedAt,
             // Note: this will not match up with the periods sum of durations, as it includes

package/dist/esm/insm.js

@@ -1,8 +1,9 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { countDomElements } from './dom-element-count';
+import { EditorDomRegistry } from './editor-dom-registry';
 import { INSMSession } from './insm-session';
-import { AnimationFPSIM } from './period-measurers/afps';
 import { INPTracker } from './inp-measurers/inp';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 export var INSM = /*#__PURE__*/function () {
@@ -15,7 +16,12 @@ export var INSM = /*#__PURE__*/function () {
      * page session.
      */
     _defineProperty(this, "runningHeavyTasks", new Set());
-    this.periodMeasurers = [expValEquals('platform_editor_disable_afps', 'isEnabled', true) ? undefined : new AnimationFPSIM(), new INPTracker()];
+    /**
+     * The editor is tracked at the insm layer (rather than per session) as it can
+     * outlive, or be mounted after, the session it is measured by.
+     */
+    _defineProperty(this, "editorDomRegistry", new EditorDomRegistry());
+    this.periodMeasurers = [new INPTracker()];
     this.options = options;
 
     // If this does throw -- we do want an unhandledRejection rejection to be passed to the window
@@ -82,6 +88,50 @@ export var INSM = /*#__PURE__*/function () {
       }
     }
 
+    /**
+     * Registers the page editor's content DOM element (`editorView.dom`) with insm.
+     *
+     * insm does not locate the editor itself - the element is provided by the editor so
+     * that session events can report its DOM element count (`editorDomSize`).
+     *
+     * A session measures a page, so only the page's own editor should register. Secondary
+     * editors (inline comments, nested legacy content extensions) must not, as the
+     * reported size would then depend on which editor registered last.
+     *
+     * ```ts
+     * insm.registerEditorDom(editorView.dom);
+     * ```
+     */
+  }, {
+    key: "registerEditorDom",
+    value: function registerEditorDom(editorDom) {
+      this.editorDomRegistry.register(editorDom);
+    }
+
+    /**
+     * Unregisters the editor's content DOM element. This is expected to be called when
+     * the editor is destroyed.
+     */
+  }, {
+    key: "unregisterEditorDom",
+    value: function unregisterEditorDom(editorDom) {
+      this.editorDomRegistry.unregister(editorDom);
+    }
+
+    /**
+     * The number of DOM elements inside the registered editor, used as a proxy for
+     * document complexity in performance events.
+     *
+     * Undefined when no editor is registered, or the registered one is no longer in
+     * the document.
+     */
+  }, {
+    key: "getEditorDomSize",
+    value: function getEditorDomSize() {
+      var editorDom = this.editorDomRegistry.editorDom;
+      return editorDom ? countDomElements(editorDom) : undefined;
+    }
+
     /**
      * Call this when starting a new experience.  This is expected to be wired to the product
      * routing solution.

package/dist/types/api.d.ts

@@ -0,0 +1,13 @@
+import type { INSMOptions } from './types';
+import type { INSMSession } from './insm-session';
+import { INSM } from './insm';
+/**
+ * Initializes the INSM (Interactivity Session Measurement) tooling
+ */
+export declare function init(options: INSMOptions): void;
+/**
+ * **In**teractivity **s**ession **m**onitoring
+ */
+export declare const insm: Pick<INSM, 'start' | 'stopEarly' | 'startHeavyTask' | 'endHeavyTask' | 'overrideExperienceKey' | 'registerEditorDom' | 'unregisterEditorDom'> & {
+    session: Pick<INSMSession, 'details' | 'startFeature' | 'endFeature' | 'addProperties' | 'setProperty'> | undefined;
+};

package/dist/types/dom-element-count.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the total number of DOM elements inside the given element.
+ *
+ * Uses the native `getElementsByTagName('*')`, which counts descendants iteratively in the
+ * browser engine -- intentionally not a recursive JS walk, so it can't overflow the stack on
+ * very large documents.
+ */
+export declare function countDomElements(element: Element): number;

package/dist/types/editor-dom-registry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Holds the page editor's content DOM.
+ *
+ * insm holds no reference to the editor, so the element is registered from the outside — it is
+ * the same `editorView.dom` element the editor measures for the `editorDomSize` attribute on
+ * its INP event.
+ *
+ * Only the page editor registers itself: an insm session measures a page, and secondary
+ * editors on the page (inline comments, nested legacy content extensions) would make the
+ * registration ambiguous.
+ *
+ * The element is held via a `WeakRef` so a destroyed editor's DOM can be collected even if
+ * `unregister` is never reached.
+ */
+export declare class EditorDomRegistry {
+    private registered;
+    /**
+     * Registers the page editor's content DOM element (`editorView.dom`).
+     */
+    register(editorDom: HTMLElement): void;
+    /**
+     * Unregisters an editor's content DOM element. Expected to be called when the editor is
+     * destroyed. Ignored when a different editor is currently registered, so an editor being
+     * torn down after its replacement registered does not clear the newer one.
+     */
+    unregister(editorDom: HTMLElement): void;
+    /**
+     * The registered editor's content DOM, or undefined when no editor is registered or the
+     * registered one is no longer in the document -- ie. an experience without a page editor,
+     * or a session which outlived the editor.
+     */
+    get editorDom(): HTMLElement | undefined;
+}

package/dist/types/index.d.ts

@@ -1,13 +1 @@
-import type { INSMOptions } from './types';
-import type { INSMSession } from './insm-session';
-import { INSM } from './insm';
-/**
- * Initializes the INSM (Interactivity Session Measurement) tooling
- */
-export declare function init(options: INSMOptions): void;
-/**
- * **In**teractivity **s**ession **m**onitoring
- */
-export declare const insm: Pick<INSM, 'start' | 'stopEarly' | 'startHeavyTask' | 'endHeavyTask' | 'overrideExperienceKey'> & {
-    session: Pick<INSMSession, 'details' | 'startFeature' | 'endFeature' | 'addProperties' | 'setProperty'> | undefined;
-};
+export { init, insm } from './api';

package/dist/types/insm.d.ts

@@ -1,19 +1,23 @@
 import type { AnalyticsWebClient } from '@atlaskit/analytics-listeners';
 import { INSMSession } from './insm-session';
 import type { ExperienceProperties, INSMOptions } from './types';
-import { AnimationFPSIM } from './period-measurers/afps';
 import { INPTracker } from './inp-measurers/inp';
 export declare class INSM {
     analyticsWebClient?: AnalyticsWebClient;
     runningSession?: INSMSession;
     options: INSMOptions;
-    periodMeasurers: [AnimationFPSIM | undefined, INPTracker];
+    periodMeasurers: [INPTracker];
     /**
      * Heavy tasks are tracked at the insm layer as heavy tasks
      * are expected at times to be unrelated to the current
      * page session.
      */
     runningHeavyTasks: Set<string>;
+    /**
+     * The editor is tracked at the insm layer (rather than per session) as it can
+     * outlive, or be mounted after, the session it is measured by.
+     */
+    private editorDomRegistry;
     constructor(options: INSMOptions);
     /**
      * Starts a heavy task in the currently running session.
@@ -28,6 +32,34 @@ export declare class INSM {
      * Ends a heavy task in the currently running session
      */
     endHeavyTask(heavyTaskName: string): void;
+    /**
+     * Registers the page editor's content DOM element (`editorView.dom`) with insm.
+     *
+     * insm does not locate the editor itself - the element is provided by the editor so
+     * that session events can report its DOM element count (`editorDomSize`).
+     *
+     * A session measures a page, so only the page's own editor should register. Secondary
+     * editors (inline comments, nested legacy content extensions) must not, as the
+     * reported size would then depend on which editor registered last.
+     *
+     * ```ts
+     * insm.registerEditorDom(editorView.dom);
+     * ```
+     */
+    registerEditorDom(editorDom: HTMLElement): void;
+    /**
+     * Unregisters the editor's content DOM element. This is expected to be called when
+     * the editor is destroyed.
+     */
+    unregisterEditorDom(editorDom: HTMLElement): void;
+    /**
+     * The number of DOM elements inside the registered editor, used as a proxy for
+     * document complexity in performance events.
+     *
+     * Undefined when no editor is registered, or the registered one is no longer in
+     * the document.
+     */
+    getEditorDomSize(): number | undefined;
     /**
      * Call this when starting a new experience.  This is expected to be wired to the product
      * routing solution.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/insm",
-	"version": "1.2.12",
+	"version": "2.0.0",
 	"description": "INSM tooling measures user-perceived interactivity of a page",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -18,7 +18,8 @@
 	"atlaskit:src": "src/index.ts",
 	"dependencies": {
 		"@atlaskit/analytics-listeners": "^11.1.0",
-		"@atlaskit/tmp-editor-statsig": "^147.0.0",
+		"@atlaskit/platform-feature-experiments": "^0.3.0",
+		"@atlaskit/tmp-editor-statsig": "^147.1.0",
 		"@babel/runtime": "^7.0.0",
 		"bowser-ultralight": "^1.0.6"
 	},
@@ -26,6 +27,7 @@
 		"react": "^18.2.0 || ^19.2.0"
 	},
 	"devDependencies": {
+		"@atlassian/experiment-test-utils": "^0.2.0",
 		"@atlassian/structured-docs-types": "workspace:^",
 		"react": "^19.2.0"
 	}