@atlaskit/insm 0.0.2 → 0.1.0

package/dist/esm/insm-period.js

@@ -0,0 +1,339 @@
+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; }
+/* eslint-disable @repo/internal/dom-events/no-unsafe-event-listeners */
+
+export var PeriodTracking = /*#__PURE__*/function () {
+  function PeriodTracking(session) {
+    _classCallCheck(this, PeriodTracking);
+    _defineProperty(this, "periodMeasurements", {
+      active: {
+        features: new Set(),
+        heavyTasks: new Set(),
+        measurements: {},
+        duration: 0,
+        count: 0
+      },
+      inactive: {
+        features: new Set(),
+        heavyTasks: new Set(),
+        measurements: {},
+        duration: 0,
+        count: 0
+      }
+    });
+    _defineProperty(this, "state", 'inactive');
+    _defineProperty(this, "pauses", new Set());
+    /**
+     * Warning: this can be reset mid period when pausing/resuming.
+     * It's intended use is to build the `periodMeasurements` duration.
+     */
+    _defineProperty(this, "currentPeriodStart", performance.now());
+    _defineProperty(this, "activeStartListeners", []);
+    _defineProperty(this, "activeEndListeners", []);
+    /**
+     * This works by;
+     * On setup
+     * - starts activity listeners
+     *   - on activity received
+     *     - possible end active count down started.
+     *       3 animation frames or 3 seconds of inactivity - whichever comes first
+     *     - any existing end count down ended
+     */
+    _defineProperty(this, "activeEndCountDownAbortController", new AbortController());
+    this.session = session;
+    this.latestPeriodFeatures = new Set(session.runningFeatures);
+    this.latestHeavyTasks = new Set(session.insm.runningHeavyTasks);
+    this.pauses = new Set(session.insm.runningHeavyTasks);
+    var startInteractivityMeasuresPaused = this.latestHeavyTasks.size !== 0;
+    var _iterator = _createForOfIteratorHelper(session.insm.periodMeasurers),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var periodMeasurer = _step.value;
+        periodMeasurer.start(startInteractivityMeasuresPaused);
+        this.periodMeasurements.active.measurements[periodMeasurer.name] = {
+          numerator: 0,
+          denominator: 0,
+          max: 0,
+          min: 0,
+          average: 0
+        };
+        this.periodMeasurements.inactive.measurements[periodMeasurer.name] = {
+          numerator: 0,
+          denominator: 0,
+          max: 0,
+          min: 0,
+          average: 0
+        };
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    this.setupActiveStartInteractionListeners();
+  }
+  return _createClass(PeriodTracking, [{
+    key: "startFeature",
+    value: function startFeature(featureName) {
+      this.latestPeriodFeatures.add(featureName);
+      this.periodMeasurements[this.state].features.add(featureName);
+    }
+  }, {
+    key: "startHeavyTask",
+    value: function startHeavyTask(heavyTaskName) {
+      this.latestHeavyTasks.add(heavyTaskName);
+      this.periodMeasurements[this.state].heavyTasks.add(heavyTaskName);
+      this.pause(heavyTaskName);
+    }
+  }, {
+    key: "endHeavyTask",
+    value: function endHeavyTask(heavyTaskName) {
+      this.resume(heavyTaskName);
+    }
+
+    /**
+     * Sets a pause based on a key.  If this is the first pause, then it will also halt
+     * running interactivity measures, and update the current measurements duration.
+     */
+  }, {
+    key: "pause",
+    value: function pause(pauseName) {
+      if (this.pauses.size === 0) {
+        this.periodMeasurements[this.state].duration = this.periodMeasurements[this.state].duration + (performance.now() - this.currentPeriodStart);
+        var _iterator2 = _createForOfIteratorHelper(this.session.insm.periodMeasurers),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var periodMeasurer = _step2.value;
+            periodMeasurer.pause();
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+      this.pauses.add(pauseName);
+    }
+
+    /**
+     * Releases a pause for a key.
+     *
+     * **NOTE**: The session will only resume if this was the only
+     * currently tracked pause key.
+     */
+  }, {
+    key: "resume",
+    value: function resume(pauseName) {
+      this.pauses.delete(pauseName);
+      if (this.pauses.size === 0) {
+        this.currentPeriodStart = performance.now();
+        var _iterator3 = _createForOfIteratorHelper(this.session.insm.periodMeasurers),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var periodMeasurer = _step3.value;
+            periodMeasurer.resume();
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
+    }
+  }, {
+    key: "endResults",
+    get: function get() {
+      this.changePeriodAndTrackLast(this.state);
+      return this.periodMeasurements;
+    }
+  }, {
+    key: "setupActiveStartInteractionListeners",
+    value: function setupActiveStartInteractionListeners() {
+      var _this = this;
+      var events = ['mousemove', 'pointerdown', 'pointerup', 'click', 'keydown', 'keyup', 'scroll'];
+      for (var _i = 0, _events = events; _i < _events.length; _i++) {
+        var event = _events[_i];
+        var eventListener = function eventListener() {
+          // start event
+          _this.changePeriodAndTrackLast('inactive', 'active');
+        };
+        window.addEventListener(event, eventListener, {
+          once: true
+        });
+        this.activeStartListeners.push([event, eventListener]);
+      }
+    }
+  }, {
+    key: "setupEndActiveInteractionListeners",
+    value: function setupEndActiveInteractionListeners() {
+      var _this2 = this;
+      this.activeEndCountDownVisibilityListener = function () {
+        if (document.visibilityState === 'hidden') {
+          endSession();
+        }
+      };
+      window.addEventListener('visibilitychange', this.activeEndCountDownVisibilityListener);
+      var events = ['mousemove', 'pointerdown', 'pointerup', 'click', 'keydown', 'keyup', 'scroll'];
+      for (var _i2 = 0, _events2 = events; _i2 < _events2.length; _i2++) {
+        var event = _events2[_i2];
+        var eventListener = function eventListener() {
+          _this2.activeEndCountDownAbortController.abort();
+          _this2.activeEndCountDownAbortController = new AbortController();
+          startPeriodEndCountDown(_this2.activeEndCountDownAbortController.signal, function () {
+            endSession();
+          });
+        };
+        window.addEventListener(event, eventListener);
+        this.activeEndListeners.push([event, eventListener]);
+      }
+      var endSession = function endSession() {
+        _this2.activeEndCountDownAbortController.abort();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        window.removeEventListener('visibilitychange', _this2.activeEndCountDownVisibilityListener);
+        var _iterator4 = _createForOfIteratorHelper(_this2.activeEndListeners),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var activeEndListener = _step4.value;
+            window.removeEventListener(activeEndListener[0], activeEndListener[1]);
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+        _this2.changePeriodAndTrackLast('active', 'inactive');
+      };
+
+      // When first setting up -- there has just been an interaction -- so we start a countdown
+      this.activeEndCountDownAbortController.abort();
+      this.activeEndCountDownAbortController = new AbortController();
+      startPeriodEndCountDown(this.activeEndCountDownAbortController.signal, function () {
+        endSession();
+      });
+    }
+  }, {
+    key: "changePeriodAndTrackLast",
+    value: function changePeriodAndTrackLast(lastPeriod, newPeriod) {
+      var _this$activeEndCountD,
+        _this3 = this;
+      this.periodMeasurements[lastPeriod].duration = this.periodMeasurements[lastPeriod].duration + (performance.now() - this.currentPeriodStart);
+      this.periodMeasurements[lastPeriod].count++;
+      var interactivityMeasuresPaused = this.latestHeavyTasks.size !== 0;
+      var _iterator5 = _createForOfIteratorHelper(this.session.insm.periodMeasurers),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var interactivityMeasure = _step5.value;
+          var finalResult = newPeriod ? interactivityMeasure.start(interactivityMeasuresPaused) : interactivityMeasure.end();
+          var tracked = this.periodMeasurements[lastPeriod].measurements[interactivityMeasure.name];
+          if (finalResult.average === 0) {
+            // In this case -- we haven't had any measurements complete since last measurement
+            // so we do nothing
+          } else if (tracked.average === 0) {
+            // In this case -- we haven't had any entries come through yet - so we replace any existing entries
+            this.periodMeasurements[lastPeriod].measurements[interactivityMeasure.name] = finalResult;
+          } else {
+            // In this case there is a new measurement which we merge with the previous measurement
+            var merged = {
+              numerator: finalResult.numerator + tracked.numerator,
+              denominator: finalResult.denominator + tracked.denominator,
+              average: (finalResult.numerator + tracked.numerator) / (finalResult.denominator + tracked.denominator),
+              max: tracked.max === 0 || finalResult.max > tracked.max ? finalResult.max : tracked.max,
+              min: tracked.min === 0 || finalResult.min < tracked.min ? finalResult.min : tracked.min
+            };
+            this.periodMeasurements[lastPeriod].measurements[interactivityMeasure.name] = merged;
+          }
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      var _iterator6 = _createForOfIteratorHelper(this.activeStartListeners),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var listener = _step6.value;
+          window.removeEventListener(listener[0], listener[1]);
+        }
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      var _iterator7 = _createForOfIteratorHelper(this.activeEndListeners),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var _listener = _step7.value;
+          window.removeEventListener(_listener[0], _listener[1]);
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+      (_this$activeEndCountD = this.activeEndCountDownAbortController) === null || _this$activeEndCountD === void 0 || _this$activeEndCountD.abort();
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      window.removeEventListener('visibilitychange', this.activeEndCountDownVisibilityListener);
+      if (newPeriod) {
+        this.latestPeriodFeatures = new Set(this.session.runningFeatures);
+        this.session.runningFeatures.forEach(function (featureName) {
+          _this3.periodMeasurements[newPeriod].features.add(featureName);
+        });
+        this.latestHeavyTasks = new Set(this.session.insm.runningHeavyTasks);
+        this.currentPeriodStart = performance.now();
+        switch (newPeriod) {
+          case 'active':
+            this.setupEndActiveInteractionListeners();
+            this.state = 'active';
+            break;
+          case 'inactive':
+            this.setupActiveStartInteractionListeners();
+            this.state = 'inactive';
+            break;
+        }
+      }
+    }
+  }]);
+}();
+function startPeriodEndCountDown(signal, handleEnd) {
+  var animationFramesSinceLastInteraction = 0;
+  var inactiveTimeReached = false;
+  var timer;
+  var animationFrameHandler;
+  var _monitorAnimationFrames = function monitorAnimationFrames() {
+    animationFrameHandler = requestAnimationFrame(function () {
+      animationFramesSinceLastInteraction++;
+      if (animationFramesSinceLastInteraction < 3) {
+        _monitorAnimationFrames();
+      } else {
+        if (inactiveTimeReached) {
+          handleEnd();
+        }
+      }
+    });
+  };
+  var monitorTime = function monitorTime() {
+    timer = setTimeout(function () {
+      inactiveTimeReached = true;
+      if (animationFramesSinceLastInteraction === 3) {
+        handleEnd();
+      }
+    }, 3000);
+  };
+  monitorTime();
+  _monitorAnimationFrames();
+  signal.addEventListener('abort', function () {
+    clearTimeout(timer);
+    cancelAnimationFrame(animationFrameHandler);
+  });
+}

package/dist/esm/insm-session.js

@@ -0,0 +1,177 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 { PeriodTracking } from './insm-period';
+
+/**
+ * Only intended for internal use.
+ *
+ * Exported for consumers who may require the type.
+ */
+export var INSMSession = /*#__PURE__*/function () {
+  function INSMSession(experienceKey, experienceProperties, insm) {
+    _classCallCheck(this, INSMSession);
+    _defineProperty(this, "startedAt", performance.now());
+    _defineProperty(this, "running", true);
+    _defineProperty(this, "addedProperties", []);
+    _defineProperty(this, "runningFeatures", new Set());
+    this.experienceKey = experienceKey;
+    this.experienceProperties = experienceProperties;
+    this.insm = insm;
+    this.periodTracking = new PeriodTracking(this);
+
+    /**
+     * Note: Events are not reliably fired from mobile browsers (ie. when a browser is closed when not in use)
+     */
+  }
+
+  /**
+   * Adds a feature to the currently running session
+   */
+  return _createClass(INSMSession, [{
+    key: "startFeature",
+    value: function startFeature(featureName) {
+      var _this$periodTracking;
+      this.runningFeatures.add(featureName);
+      (_this$periodTracking = this.periodTracking) === null || _this$periodTracking === void 0 || _this$periodTracking.startFeature(featureName);
+    }
+
+    /**
+     * Ends a features usage in the currently running session
+     */
+  }, {
+    key: "endFeature",
+    value: function endFeature(featureName) {
+      this.runningFeatures.delete(featureName);
+    }
+
+    /**
+     * Returns details on the current session.
+     */
+  }, {
+    key: "details",
+    get: function get() {
+      return {
+        experienceKey: this.experienceKey,
+        experienceProperties: this.experienceProperties,
+        paused: this.periodTracking.pauses.size > 0,
+        periodState: this.periodTracking.state,
+        /**
+         * The only scenario where this value should return false is when
+         * the experience has been stopped early.
+         */
+        running: this.running
+      };
+    }
+
+    /**
+     * This api takes either a static single-level key-value object, or callbacks which return the same and
+     * will be evaluated on session end.
+     *
+     * When ending a session, all properties received via this api are merged, in order, into the resulting
+     * insm event’s properties; last write wins.
+     *
+     * Callback values are evaluated at session end.
+     *
+     * For example, for the following
+     *
+     * ```ts
+     * insm.experience.addProperties({ one: 1, two: 2 });
+     * insm.experience.addProperties(() => ({ one: 'one' }));
+     * insm.experience.addProperties({ three: 3 });
+     * ```
+     *
+     * The resulting added properties will be
+     *
+     * ```ts
+     * { one: 'one', two: 2, three: 3 }
+     * ```
+     */
+  }, {
+    key: "addProperties",
+    value: function addProperties(propertiesToAdd) {
+      this.addedProperties.push(propertiesToAdd);
+    }
+
+    /**
+     * In some scenarios (ie. when a page error boundary is hit), you will want to exit early.
+     * This is api supports these scenarios
+     *
+     * ```ts
+     * insm.stopEarly(reasonKey: string, description: string);
+     * ```
+     *
+     * Sessions closed early are identifiable by their end details
+     * `"endDetails": { stoppedBy: "early-stop", reasonKey, description }`.
+     *
+     * **Note**: The session is ended as soon as this is called, and any `addProperties` handlers will
+     * called immediately.
+     */
+  }, {
+    key: "earlyStop",
+    value: function earlyStop(reason, description) {
+      this.end({
+        stoppedBy: 'early-stop',
+        reason: reason,
+        description: description
+      });
+    }
+  }, {
+    key: "end",
+    value: function end(endDetails) {
+      var _this$insm$analyticsW;
+      if (this.running === false) {
+        // If an experience has already been ended -- don't repeat the ending
+        return;
+      }
+      this.running = false;
+      var endedAt = performance.now();
+      var duration = endedAt - this.startedAt;
+      var evaluatedAddedProperties = {};
+      var _iterator = _createForOfIteratorHelper(this.addedProperties),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var addedProperty = _step.value;
+          if (typeof addedProperty === 'function') {
+            Object.assign(evaluatedAddedProperties, addedProperty());
+          } else {
+            Object.assign(evaluatedAddedProperties, addedProperty);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      var periodResults = this.periodTracking.endResults;
+
+      /**
+       * This event ends up as "insm measured"
+       */
+      var operationalEvent = {
+        actionSubject: 'insm',
+        action: 'measured',
+        attributes: _objectSpread(_objectSpread({}, evaluatedAddedProperties), {}, {
+          experienceKey: this.experienceKey,
+          initial: this.experienceProperties.initial,
+          contentId: this.experienceProperties.contentId,
+          timing: {
+            startedAt: this.startedAt,
+            duration: duration
+          },
+          periods: periodResults,
+          endDetails: endDetails
+        }),
+        tags: ['insm'],
+        source: 'insm'
+      };
+      (_this$insm$analyticsW = this.insm.analyticsWebClient) === null || _this$insm$analyticsW === void 0 || _this$insm$analyticsW.sendOperationalEvent(operationalEvent);
+    }
+  }]);
+}();

package/dist/esm/insm.js

@@ -0,0 +1,122 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { INSMSession } from './insm-session';
+import { AnimationFPSIM } from './period-measurers/afps';
+import { INPTracker } from './inp-measurers/inp';
+export var INSM = /*#__PURE__*/function () {
+  function INSM(options) {
+    var _this = this;
+    _classCallCheck(this, INSM);
+    /**
+     * Heavy tasks are tracked at the insm layer as heavy tasks
+     * are expected at times to be unrelated to the current
+     * page session.
+     */
+    _defineProperty(this, "runningHeavyTasks", new Set());
+    this.periodMeasurers = [new AnimationFPSIM(), new INPTracker(), new INPTracker({
+      includedInteractions: ['pointerup']
+    }), new INPTracker({
+      includedInteractions: ['pointerdown']
+    }), new INPTracker({
+      includedInteractions: ['click']
+    }), new INPTracker({
+      includedInteractions: ['keydown']
+    }), new INPTracker({
+      includedInteractions: ['keyup']
+    })];
+    this.options = options;
+
+    // If this does throw -- we do want an unhandledRejection rejection to be passed to the window
+    // this is to ease debugging.
+    options.getAnalyticsWebClient.then(function (analyticsWebClient) {
+      return _this.analyticsWebClient = analyticsWebClient;
+    });
+
+    // No cleanup needs to be performed -- as this is intended to run until the tab is closed
+    // eslint-disable-next-line @repo/internal/dom-events/no-unsafe-event-listeners
+    window.addEventListener('pagehide', function () {
+      var _this$runningSession;
+      (_this$runningSession = _this.runningSession) === null || _this$runningSession === void 0 || _this$runningSession.end({
+        stoppedBy: 'pagehide'
+      });
+    });
+  }
+
+  /**
+   * Starts a heavy task in the currently running session.
+   *
+   * This also pauses measurement.
+   */
+  return _createClass(INSM, [{
+    key: "startHeavyTask",
+    value: function startHeavyTask(heavyTaskName) {
+      var _this$runningSession2, _this$runningSession3;
+      this.runningHeavyTasks.add(heavyTaskName);
+      (_this$runningSession2 = this.runningSession) === null || _this$runningSession2 === void 0 || (_this$runningSession2 = _this$runningSession2.periodTracking) === null || _this$runningSession2 === void 0 || _this$runningSession2.startHeavyTask(heavyTaskName);
+      (_this$runningSession3 = this.runningSession) === null || _this$runningSession3 === void 0 || _this$runningSession3.periodTracking.pause(heavyTaskName);
+    }
+
+    /**
+     * Ends a heavy task in the currently running session
+     */
+  }, {
+    key: "endHeavyTask",
+    value: function endHeavyTask(heavyTaskName) {
+      var _this$runningSession4;
+      this.runningHeavyTasks.delete(heavyTaskName);
+      (_this$runningSession4 = this.runningSession) === null || _this$runningSession4 === void 0 || _this$runningSession4.periodTracking.resume(heavyTaskName);
+    }
+
+    /**
+     * Call this when starting a new experience.  This is expected to be wired to the product
+     * routing solution.
+     *
+     * It's expected this call will be paired with a `insm.session.startHeavyTask('page-load')` and subsequent `insm.session.endHeavyTask('page-load')`
+     * so that performance degradations linked to the page initialisation are excluded from the active interactivity monitoring.
+     *
+     *
+     * ```ts
+     * insm.start('edit-page', { initial: true, contentId: '9001' })
+     * insm.session.startHeavyTask(''page-load')
+     * // ... heavy initialisation work
+     * insm.session.endHeavyTask(''page-load')
+     * ```
+     */
+  }, {
+    key: "start",
+    value: function start(experienceKey, experienceProperties) {
+      var _this$options$experie;
+      if (this.runningSession !== undefined) {
+        this.runningSession.end({
+          stoppedBy: 'new-experience',
+          experienceKey: experienceKey,
+          contentId: experienceProperties.contentId
+        });
+      }
+      if ((_this$options$experie = this.options.experiences[experienceKey]) !== null && _this$options$experie !== void 0 && _this$options$experie.enabled) {
+        this.runningSession = new INSMSession(experienceKey, experienceProperties, this);
+      }
+    }
+
+    /**
+     * This prematurely halts any running experience measurement. It's expected to be used in
+     * scenarios such as when error boundaries are hit.
+     */
+  }, {
+    key: "stopEarly",
+    value: function stopEarly(reasonKey, description) {
+      var _this$runningSession5;
+      (_this$runningSession5 = this.runningSession) === null || _this$runningSession5 === void 0 || _this$runningSession5.earlyStop(reasonKey, description);
+    }
+
+    /**
+     * Gets the current running session details
+     */
+  }, {
+    key: "session",
+    get: function get() {
+      return this.runningSession;
+    }
+  }]);
+}();