@schibsted/pulse-sdk 8.0.0-rc.4 → 8.0.0-rc.6

package/dist/ejs/Tracker.js

@@ -1,7 +1,7 @@
 import { parsePulseCookies } from '@schibsted/pulse-cis-sync';
 import { evaluateAndFlatten, isBrowser, isFunction, isPromise, isString, pulseMerge, throttle, } from '@schibsted/pulse-utils';
-import { buildAnonymousViewUIElementEvent, buildCompletedHealthActionEvent, buildEngagementAudioEvent, buildEngagementFormEvent, buildEngagementHealthUIElementEvent, buildEngagementOfferEvent, buildEngagementTeaserEvent, buildEngagementUIElementEvent, buildEngagementVideoAdEvent, buildEngagementVideoEvent, buildEngagementWidgetEvent, buildImpressionAdSlotEvent, buildImpressionFormEvent, buildImpressionHealthUIElementEvent, buildImpressionOfferEvent, buildImpressionPlayerEvent, buildImpressionTeaserEvent, buildImpressionUIElementEvent, buildImpressionWidgetEvent, buildLeaveArticleEvent, buildLeaveAudioPageEvent, buildLeaveErrorEvent, buildLeaveFrontpageEvent, buildLeaveLandingpageEvent, buildLeaveListingEvent, buildLeaveLockedArticleEvent, buildLeaveLockedAudioEvent, buildLeaveLockedAudioPageEvent, buildLeaveLockedVideoEvent, buildLeaveLockedVideoPageEvent, buildLeavePageEvent, buildLeaveSportsPageEvent, buildLeaveVideoPageEvent, buildLeaveWeatherEvent, buildViewArticleEvent, buildViewAudioEvent, buildViewAudioPageEvent, buildViewErrorEvent, buildViewFrontpageEvent, buildViewHealthPageEvent, buildViewLandingpageEvent, buildViewListingEvent, buildViewLockedArticleEvent, buildViewLockedAudioEvent, buildViewLockedAudioPageEvent, buildViewLockedVideoEvent, buildViewLockedVideoPageEvent, buildViewPageEvent, buildViewSportsPageEvent, buildViewTitleEvent, buildViewVideoEvent, buildViewVideoPageEvent, buildViewWeatherEvent, getCommonBuildersOutput, } from '@schibsted/tpaas-event-builder';
-import { LeaveArticle, LeaveAudioPage, LeaveError, LeaveFrontpage, LeaveLandingpage, LeaveListing, LeaveLockedArticle, LeaveLockedAudioPage, LeaveLockedVideoPage, LeavePage, LeaveSportsPage, LeaveVideoPage, LeaveWeather, ViewArticle, ViewError, ViewFrontpage, ViewLandingpage, ViewListing, ViewLockedArticle, ViewLockedVideo, ViewPage, ViewTitle, ViewWeather, } from '@schibsted/tpaas-schemas';
+import { buildAnonymousViewUIElementEvent, buildCompletedHealthActionEvent, buildEngagementAudioEvent, buildEngagementFormEvent, buildEngagementHealthUIElementEvent, buildEngagementOfferEvent, buildEngagementTeaserEvent, buildEngagementUIElementEvent, buildEngagementVideoAdEvent, buildEngagementVideoEvent, buildEngagementWidgetEvent, buildImpressionFormEvent, buildImpressionHealthUIElementEvent, buildImpressionOfferEvent, buildImpressionPlayerEvent, buildImpressionTeaserEvent, buildImpressionUIElementEvent, buildImpressionWidgetEvent, buildLeaveArticleEvent, buildLeaveAudioPageEvent, buildLeaveErrorEvent, buildLeaveFrontpageEvent, buildLeaveLandingpageEvent, buildLeaveListingEvent, buildLeaveLockedArticleEvent, buildLeaveLockedAudioPageEvent, buildLeaveLockedVideoPageEvent, buildLeavePageEvent, buildLeaveSportsPageEvent, buildLeaveVideoPageEvent, buildLeaveWeatherEvent, buildViewArticleEvent, buildViewAudioPageEvent, buildViewErrorEvent, buildViewFrontpageEvent, buildViewHealthPageEvent, buildViewLandingpageEvent, buildViewListingEvent, buildViewLockedArticleEvent, buildViewLockedAudioPageEvent, buildViewLockedVideoPageEvent, buildViewPageEvent, buildViewSportsPageEvent, buildViewTitleEvent, buildViewVideoPageEvent, buildViewWeatherEvent, getCommonBuildersOutput, } from '@schibsted/tpaas-event-builder';
+import { LeaveArticle, LeaveAudioPage, LeaveError, LeaveFrontpage, LeaveLandingpage, LeaveListing, LeaveLockedArticle, LeaveLockedAudioPage, LeaveLockedVideoPage, LeavePage, LeaveSportsPage, LeaveVideoPage, LeaveWeather, ViewArticle, ViewAudioPage, ViewError, ViewFrontpage, ViewHealthPage, ViewLandingpage, ViewListing, ViewLockedArticle, ViewLockedAudioPage, ViewLockedVideoPage, ViewPage, ViewSportsPage, ViewTitle, ViewVideoPage, ViewWeather, } from '@schibsted/tpaas-schemas';
 import logger from 'loglevel';
 import { v4 } from 'uuid';
 import { getDefaultAltHandler, getDefaultNativeJwe } from './app-integration';
@@ -326,6 +326,11 @@ export default class Tracker {
                 return queuedEvent.then((result) => result);
             });
         };
+        /*
+         * Casting `input` as `Partial<Builders>` to formalise the intention of processing the event input in relation to the properties in
+         * the Builders type. It would justify changing the public api for `.track`, but as this deals with legacy code, we
+         * keep it internal, so dependencies from now on can count on objects being a Partial<Builder>
+         */
         return this.syncRemoteResources(input, currentBuilders).then(_track, _track);
     }
     /**
@@ -423,7 +428,6 @@ export default class Tracker {
         };
     }
     /**
-     *
      * @private
      * @category TPaaS Tracking
      */
@@ -738,19 +742,18 @@ export default class Tracker {
     }
     async trackViewHealthPage(input, options) {
         this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
-        this.setCurrentPage(input.object.objectId, 'Page'); // ViewHealthPage.object.objectType is HealthPage, which is not allowed as a pageType
+        this.setCurrentPage(input.object.objectId, ViewHealthPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = buildViewHealthPageEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            // HealthView Page is a bit special, in the sense that in doesn't have a dedicated Leave event.
-            // Instead, we need to reuse the generic Leave Page event, but adapt the input accordingly.
-            // This means omitting some fields from HealthView Page that are not part of Leave Page schema.
-            const { experiments, metrics, object, ...restInput } = input;
-            const { category, custom, intent, name, tags, ...restObject } = input.object;
-            const leavePageCallback = (leave) => {
-                this.trackLeavePage({
+            const leavePageCallback = async (leave) => {
+                // HealthView Page is a bit special, in the sense that in doesn't have a dedicated Leave event.
+                // Instead, we need to reuse the generic Leave Page event, but adapt the input accordingly.
+                // This means omitting some fields from HealthView Page that are not part of Leave Page schema.
+                const { experiments, metrics, object, origin, ...restInput } = input;
+                const { category, custom, intent, name, tags, ...restObject } = input.object;
+                await this.trackLeavePage({
                     leave,
                     ...restInput,
                     object: {
@@ -760,10 +763,7 @@ export default class Tracker {
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: LeavePage.object.objectType,
                 trackMethod: leavePageCallback,
             });
@@ -787,18 +787,15 @@ export default class Tracker {
         const event = buildViewPageEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leavePageCallback = (leave) => {
-                this.trackLeavePage({
+            const leavePageCallback = async (leave) => {
+                const { metrics, ...rest } = input; // metrics are not part of LeavePage schema, so we need to omit them
+                await this.trackLeavePage({
                     leave,
-                    ...input,
+                    ...rest,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: LeavePage.object.objectType,
                 trackMethod: leavePageCallback,
             });
@@ -812,23 +809,19 @@ export default class Tracker {
      */
     async trackViewSportsPage(input, options) {
         this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
-        this.setCurrentPage(input.object.objectId, 'Page'); // ViewSportsPage.object.objectType is SportsPage, which is not allowed as a pageType
+        this.setCurrentPage(input.object.objectId, ViewSportsPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = buildViewSportsPageEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveSportsPageCallback = (leave) => {
-                this.trackLeaveSportsPage({
+            const leaveSportsPageCallback = async (leave) => {
+                await this.trackLeaveSportsPage({
                     leave,
                     ...input,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: LeaveSportsPage.object.objectType,
                 trackMethod: leaveSportsPageCallback,
             });
@@ -856,15 +849,6 @@ export default class Tracker {
         const event = buildImpressionWidgetEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
-    /**
-     * @param input
-     * @category TPaaS Tracking
-     */
-    async trackImpressionAdSlot(input) {
-        const dependencies = await this.prepareTpaasEvent();
-        const event = buildImpressionAdSlotEvent(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * @param input
      * @param options
@@ -877,36 +861,23 @@ export default class Tracker {
         const event = buildViewArticleEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveArticleCallback = (leave) => {
-                this.trackLeaveArticle({
+            const leaveArticleCallback = async (leave) => {
+                // omit these properties from LeaveArticle because they're not part of the LeaveArticle schema
+                const { authors, hotness, lifetime, sponsor, wordCount, ...rest } = input.object;
+                await this.trackLeaveArticle({
                     leave,
                     ...input,
+                    object: rest,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: LeaveArticle.object.objectType,
                 trackMethod: leaveArticleCallback,
             });
         }
         return result;
     }
-    /**
-     * @param input
-     * @param options
-     * @category TPaaS Tracking
-     */
-    async trackViewAudio(input) {
-        // despite the View event type, this is not a page view event, but rather a media object view event
-        // so we shouldn't reset the page view ID here or enable leave tracking
-        const dependencies = await this.prepareTpaasEvent();
-        const event = buildViewAudioEvent(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * Tracks a View AudioPage event and automatically fires a Leave AudioPage event when the user
      * navigates away.
@@ -949,20 +920,20 @@ export default class Tracker {
      */
     async trackViewAudioPage(input, options) {
         this.newPageView();
-        this.setCurrentPage(input.object.objectId, 'Audio'); // ViewAudioPage.object.objectType is AudioPage, which is not allowed as a pageType
+        this.setCurrentPage(input.object.objectId, ViewAudioPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = buildViewAudioPageEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable, leaveAudioBuilder } = options.leaveTracking;
-            const leaveAudioPageCallback = (leave) => {
+            const { leaveAudioBuilder, ...restLeaveTrackingOptions } = options.leaveTracking;
+            const leaveAudioPageCallback = async (leave) => {
                 const leaveAudioInput = leaveAudioBuilder?.() ?? {
                     audioCompleted: 0,
                     audioStarted: 0,
                     maxPlaylistPosition: 0,
                     playlistPositionPercentage: 0,
                 };
-                this.trackLeaveAudioPage({
+                await this.trackLeaveAudioPage({
                     leave,
                     leaveAudio: {
                         ...leaveAudioInput,
@@ -973,10 +944,7 @@ export default class Tracker {
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...restLeaveTrackingOptions,
                 schema: LeaveAudioPage.object.objectType,
                 trackMethod: leaveAudioPageCallback,
             });
@@ -995,18 +963,14 @@ export default class Tracker {
         const event = buildViewErrorEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveErrorCallback = (leave) => {
-                this.trackLeaveError({
+            const leaveErrorCallback = async (leave) => {
+                await this.trackLeaveError({
                     leave,
                     ...input,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: LeaveError.object.objectType,
                 trackMethod: leaveErrorCallback,
             });
@@ -1070,18 +1034,15 @@ export default class Tracker {
         const event = buildViewFrontpageEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveFrontpageCallback = (leave) => {
-                this.trackLeaveFrontpage({
+            const leaveFrontpageCallback = async (leave) => {
+                const { metrics, ...rest } = input; // metrics are not part of LeaveFrontpage schema, so we need to omit them
+                await this.trackLeaveFrontpage({
                     leave,
-                    ...input,
+                    ...rest,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: LeaveFrontpage.object.objectType,
                 trackMethod: leaveFrontpageCallback,
             });
@@ -1100,18 +1061,14 @@ export default class Tracker {
         const event = buildViewLandingpageEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveLandingpageCallback = (leave) => {
-                this.trackLeaveLandingpage({
+            const leaveLandingpageCallback = async (leave) => {
+                await this.trackLeaveLandingpage({
                     leave,
                     ...input,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: LeaveLandingpage.object.objectType,
                 trackMethod: leaveLandingpageCallback,
             });
@@ -1130,18 +1087,14 @@ export default class Tracker {
         const event = buildViewListingEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveListingCallback = (leave) => {
-                this.trackLeaveListing({
+            const leaveListingCallback = async (leave) => {
+                await this.trackLeaveListing({
                     leave,
                     ...input,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: LeaveListing.object.objectType,
                 trackMethod: leaveListingCallback,
             });
@@ -1160,36 +1113,23 @@ export default class Tracker {
         const event = buildViewLockedArticleEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveLockedArticleCallback = (leave) => {
-                this.trackLeaveLockedArticle({
+            const leaveLockedArticleCallback = async (leave) => {
+                // omit these properties because they're not part of the LeaveLockedArticle schema
+                const { authors, hotness, lifetime, sponsor, wordCount, ...rest } = input.object;
+                await this.trackLeaveLockedArticle({
                     leave,
                     ...input,
+                    object: rest,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: LeaveLockedArticle.object.objectType,
                 trackMethod: leaveLockedArticleCallback,
             });
         }
         return result;
     }
-    /**
-     * @param input
-     * @param options
-     * @category TPaaS Tracking
-     */
-    async trackViewLockedAudio(input) {
-        // despite the View event type, this is not a page view event, but rather a media object view event
-        // so we shouldn't reset the page view ID here or enable leave tracking
-        const dependencies = await this.prepareTpaasEvent();
-        const event = buildViewLockedAudioEvent(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * @param input
      * @param options
@@ -1197,40 +1137,25 @@ export default class Tracker {
      */
     async trackViewLockedAudioPage(input, options) {
         this.newPageView();
-        this.setCurrentPage(input.object.objectId, 'Audio'); // ViewLockedAudioPage.object.objectType is AudioPage, which is not allowed as a pageType
+        this.setCurrentPage(input.object.objectId, ViewLockedAudioPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = buildViewLockedAudioPageEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveLockedAudioPageCallback = (leave) => {
-                this.trackLeaveLockedAudioPage({
+            const leaveLockedAudioPageCallback = async (leave) => {
+                await this.trackLeaveLockedAudioPage({
                     leave,
                     ...input,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: LeaveLockedAudioPage.object.objectType,
                 trackMethod: leaveLockedAudioPageCallback,
             });
         }
         return result;
     }
-    /**
-     * @param input
-     * @category TPaaS Tracking
-     */
-    async trackViewLockedVideo(input) {
-        // despite the name, this is not a page-level event. trackViewLockedVideoPage is a page-level event
-        // as such, we don't support (yet) automatic leave event enabling
-        const dependencies = await this.prepareTpaasEvent();
-        const event = buildViewLockedVideoEvent(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * @param input
      * @param options
@@ -1238,40 +1163,25 @@ export default class Tracker {
      */
     async trackViewLockedVideoPage(input, options) {
         this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
-        this.setCurrentPage(input.object.objectId, ViewLockedVideo.object.objectType);
+        this.setCurrentPage(input.object.objectId, ViewLockedVideoPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = buildViewLockedVideoPageEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveLockedVideoPageCallback = (leave) => {
-                this.trackLeaveLockedVideoPage({
+            const leaveLockedVideoPageCallback = async (leave) => {
+                await this.trackLeaveLockedVideoPage({
                     leave,
                     ...input,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: LeaveLockedVideoPage.object.objectType,
                 trackMethod: leaveLockedVideoPageCallback,
             });
         }
         return result;
     }
-    /**
-     * @param input
-     * @category TPaaS Tracking
-     */
-    async trackViewVideo(input) {
-        // despite the View event type, this is not a page view event, but rather a media object view event
-        // so we shouldn't reset the page view ID here or enable leave tracking
-        const dependencies = await this.prepareTpaasEvent();
-        const event = buildViewVideoEvent(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * Tracks a View VideoPage event and automatically fires a Leave VideoPage event when the user
      * navigates away.
@@ -1316,15 +1226,15 @@ export default class Tracker {
      */
     async trackViewVideoPage(input, options) {
         this.newPageView(); // Reset the page view ID if it is not set, to ensure a new page view is tracked
-        this.setCurrentPage(input.object.objectId, 'Video'); // ViewVideoPage.object.type is VideoPage, which is not allowed as a pageType
+        this.setCurrentPage(input.object.objectId, ViewVideoPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = buildViewVideoPageEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable, leaveStoriesBuilder } = options.leaveTracking;
-            const leaveVideoCallback = (leave) => {
+            const { leaveStoriesBuilder, ...restLeaveTrackingOptions } = options.leaveTracking;
+            const leaveVideoCallback = async (leave) => {
                 const leaveStoriesInput = leaveStoriesBuilder?.();
-                this.trackLeaveVideoPage({
+                await this.trackLeaveVideoPage({
                     leave,
                     leaveStories: leaveStoriesInput && {
                         ...leaveStoriesInput,
@@ -1335,10 +1245,7 @@ export default class Tracker {
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...restLeaveTrackingOptions,
                 schema: LeaveVideoPage.object.objectType,
                 trackMethod: leaveVideoCallback,
             });
@@ -1357,18 +1264,16 @@ export default class Tracker {
         const event = buildViewWeatherEvent(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if (shouldEnableLeaveTracking(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveWeatherCallback = (leave) => {
-                this.trackLeaveWeather({
+            const leaveWeatherCallback = async (leave) => {
+                // omit object and page from input because they're not part of the LeaveWeather schema
+                const { object, page, ...rest } = input;
+                await this.trackLeaveWeather({
                     leave,
-                    ...input,
+                    ...rest,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: LeaveWeather.object.objectType,
                 trackMethod: leaveWeatherCallback,
             });
@@ -1438,15 +1343,6 @@ export default class Tracker {
         const event = buildLeaveLockedArticleEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
-    /**
-     * @param input
-     * @category TPaaS Tracking
-     */
-    async trackLeaveLockedAudio(input) {
-        const dependencies = await this.prepareTpaasEvent();
-        const event = buildLeaveLockedAudioEvent(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -1456,15 +1352,6 @@ export default class Tracker {
         const event = buildLeaveLockedAudioPageEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
-    /**
-     * @param input
-     * @category TPaaS Tracking
-     */
-    async trackLeaveLockedVideo(input) {
-        const dependencies = await this.prepareTpaasEvent();
-        const event = buildLeaveLockedVideoEvent(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -2225,8 +2112,8 @@ export default class Tracker {
      * with the added guarantee that a second Leave event will not be triggered if one already has been sent.
      * @category TPaaS Leave Tracking
      */
-    trackTpaasActiveLeave() {
-        trackTpaasActiveLeave();
+    async trackTpaasActiveLeave() {
+        await trackTpaasActiveLeave();
     }
     /**
      * Check if leave tracking is enabled (if an event will be sent when the user leaves the page)

package/dist/ejs/builders/actor.js

@@ -12,11 +12,11 @@ export function generateActorSDRN(id, realm = '__REALM_NOT_SET__') {
     return `sdrn:${realm}:user:${outputId}`;
 }
 /**
- * Type guard to check if the input is an ActorInput
+ * Type guard to check if the input has an Actor Builder
  * @param input
  * @internal
  */
-export function isActorInput(input) {
+export function hasActorBuilder(input) {
     // biome-ignore lint/suspicious/noPrototypeBuiltins: Object.hasOwn is not available in ES2020
     return isPlainObject(input) && Object.prototype.hasOwnProperty.call(input, 'actor');
 }

package/dist/ejs/identity/actor.js

@@ -1,12 +1,10 @@
 import { evaluateAndFlatten } from '@schibsted/pulse-utils';
-import { isActorInput } from '../builders/actor';
+import { hasActorBuilder } from '../builders/actor';
 import warnOnce from '../warnOnce';
 /**
  * @internal exported for testing
  */
-export const WARN_CIS_SYNC_LOGIN_UNDEFINED = 'Cis sync initiated with no actor builder and no event available. If you do not use a login system, please indicate' +
-    ' this using tracker.update({ actor: undefined }), otherwise do tracker.update({ actor: somePromise }) with a' +
-    ' promise that resolves to the login state.';
+export const WARN_CIS_SYNC_LOGIN_UNDEFINED = 'No Actor Builder found in event input or tracker builders. Please provide an Actor Builder to ensure the SDK resolves logged-in and logged-out scenarios correctly.';
 /**
  * Get the actor id (userId) from the current browser. A promise is returned
  * because a call may be made to complete the login process.
@@ -25,6 +23,19 @@ const getUserId = async (builders) => {
 const getActor = async (builders) => {
     return await evaluateActor(builders);
 };
+/**
+ * Pinpoints the Actor Builder from the Event payload or the available Builders
+ * @param eventInput - The event input which may contain an `actor` property
+ * @param builders - The builders managed by the SDK.
+ */
+function getActorSource(eventInput = {}, builders = {}) {
+    if (hasActorBuilder(eventInput)) {
+        return eventInput.actor;
+    }
+    if (hasActorBuilder(builders)) {
+        return builders.actor;
+    }
+}
 const userIsLoggedIn = async (builders) => {
     const actor = await getActor(builders);
     return !!actor?.id;
@@ -36,8 +47,9 @@ const userIsLoggedIn = async (builders) => {
  * @private
  */
 const evaluateActor = async (eventInput = {}, builders = {}) => {
-    if (isActorInput(eventInput) || isActorInput(builders)) {
-        const evaluatedActor = await evaluateAndFlatten(eventInput.actor || builders.actor);
+    const actorSource = getActorSource(eventInput, builders);
+    if (actorSource) {
+        const evaluatedActor = await evaluateAndFlatten(actorSource);
         if (evaluatedActor) {
             return evaluatedActor;
         }
@@ -45,7 +57,7 @@ const evaluateActor = async (eventInput = {}, builders = {}) => {
     // We allow an empty actor object, because it is a sign that the application is not setting nor updating Actor correctly.
     // Inferring "id: undefined" as a fallback would mask that bug.
     // Hence, the warning below.
-    warnOnce('no-actor-builder-and-no-event-present', WARN_CIS_SYNC_LOGIN_UNDEFINED);
+    warnOnce('no-actor-builder', WARN_CIS_SYNC_LOGIN_UNDEFINED);
     return {};
 };
 export { getUserId, getActor, userIsLoggedIn, evaluateActor };

package/dist/ejs/leaveTrackingTpaas/constants.js

@@ -1,8 +1,3 @@
-export const DEFAULT_ACTIVITY_DURATION = () => ({
-    value: 0,
-    interval: undefined,
-    timeSinceLastActivity: 0,
-});
 export const DEFAULT_PAGE_LEAVE_EVENT = () => ({
     objectViewPercentage: 0,
     maxObjectViewPercentage: 0,
@@ -11,3 +6,4 @@ export const DEFAULT_PAGE_LEAVE_EVENT = () => ({
     pageScrollPosition: 0,
     maxPageScrollPosition: 0,
 });
+export const ACTIVITY_DURATION_LIMIT_MS = 30000;