@schibsted/pulse-sdk 8.0.0-rc.1 → 8.0.0-rc.10

package/dist/cjs/Tracker.js

@@ -53,6 +53,7 @@ const consent_manager_1 = require("./builders/consent-manager");
 const consents_1 = require("./builders/consents");
 const events_1 = require("./builders/events");
 const events_anonymous_node_1 = require("./builders/events-anonymous-node");
+const experiments_1 = require("./builders/experiments");
 const session_browser_1 = require("./builders/session-browser");
 const config_1 = require("./config");
 const config_browser_1 = require("./config-browser");
@@ -68,6 +69,7 @@ const version_1 = require("./version");
 const visibility_observer_1 = require("./visibility-observer");
 const warnOnce_1 = __importDefault(require("./warnOnce"));
 const event_builder_1 = require("./wrapper/engagement/ui-element/event-builder");
+const types_1 = require("./wrapper/types");
 const page_from_page_view_1 = require("./wrapper/utils/page-from-page-view");
 const event_builder_2 = require("./wrapper/view/article/event-builder");
 const event_builder_3 = require("./wrapper/view/frontpage/event-builder");
@@ -157,6 +159,27 @@ function unsubscribe(eventName, callback) {
  * @class Tracker
  */
 class Tracker {
+    async getCurrentTpaasPage() {
+        const { id, type, url } = await this.currentPage;
+        return {
+            // remove the SDRN prefix, it's not expected for TPaaS
+            pageId: id.startsWith('sdrn:') ? id.split(':').slice(-1)[0] : id,
+            // make sure the pageType is valid for TPaaS
+            pageType: (0, tpaas_event_builder_1.isPageType)(type) ? type : 'Page',
+            url,
+        };
+    }
+    async getCurrentLegacyPage() {
+        const { id, type, url } = await this.currentPage;
+        // make sure the pageType is valid for legacy events
+        const validatedType = (0, types_1.isLegacyPageType)(type) ? type : 'Page';
+        return {
+            // add the SDRN prefix if it's not there, legacy events expect the full SDRN format
+            id: id.startsWith('sdrn:') ? id : `sdrn:${this.state.providerId}:${validatedType.toLowerCase()}:${id}`,
+            type: validatedType,
+            url,
+        };
+    }
     /**
      * > [!WARNING]
      * >
@@ -175,19 +198,30 @@ class Tracker {
         // the tracking of the same element with both old and new events at the same time
         this.legacyVisibilityObservers = new Map();
         this.visibilityObservers = new Map();
-        this.legacyCurrentPage = {
-            id: 'undefined-id',
+        /**
+         * @private
+         *
+         * This is used as the source of truth for the current page's information, which is updated based on the View Page-level event
+         * As a single source of truth for the current page, this needs to be compatible between legacy and TPaaS events, hence the need for a custom data type.
+         * Legacy events can provide an id with SDRN, while TPaaS events don't need it
+         */
+        this.currentPage = {
+            id: 'unknown',
             type: 'Page',
-            url: typeof window !== 'undefined' ? window.location.href : '',
+            url: pulse_utils_1.isBrowser ? window.location.href : undefined,
         };
-        this.currentPage = undefined;
         /**
          * Promise that resolves when a session ID becomes available
          * @private
          */
         this.sessionIdPromise = null;
+        /**
+         * A simple flag used to prevent duplicate listeners being registered
+         * if `exposeToProxyClients` or `startProxyProviderListener` is called more than once.
+         */
+        this.hasProxyListener = false;
         this.setPageDefaults = (pageViewEvent) => {
-            this.legacyCurrentPage = (0, page_from_page_view_1.pageFromPageView)(pageViewEvent);
+            this.currentPage = (0, page_from_page_view_1.pageFromPageView)(pageViewEvent);
             if (pageViewEvent.origin) {
                 const pageDefaults = { origin: pageViewEvent.origin };
                 this.update(pageDefaults, true);
@@ -195,8 +229,8 @@ class Tracker {
         };
         this.setCurrentPage = (id, type) => {
             this.currentPage = {
-                pageId: id,
-                pageType: type,
+                id: id || 'unknown',
+                type: type || 'Page',
                 url: pulse_utils_1.isBrowser ? window.location.href : undefined,
             };
         };
@@ -205,6 +239,9 @@ class Tracker {
         if (!providerId || !(typeof providerId === 'string')) {
             throw new Error('Required parameter `providerId` missing');
         }
+        if (config?.componentVersion !== undefined && config?.component === undefined) {
+            throw new Error('`componentVersion` cannot be provided without `component`');
+        }
         let includeAdvertising;
         if (pulse_utils_1.isBrowser && config?.autoCreateConsents) {
             config.consents = (0, consent_manager_1.getConsentsWaitForAnalytics)((consents) => {
@@ -248,6 +285,8 @@ class Tracker {
         this.builders = (0, pulse_utils_1.pulseMerge)({}, builders, {
             provider: {
                 id: providerId,
+                ...(config?.component !== undefined && { component: config.component }),
+                ...(config?.componentVersion !== undefined && { componentVersion: config.componentVersion }),
             },
             tracker: {
                 version: version_1.SDK_VERSION,
@@ -364,6 +403,11 @@ 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);
     }
     /**
@@ -433,6 +477,11 @@ class Tracker {
             return {
                 name: exp.name || exp.id,
                 variant: exp.variant || '',
+                // nobody should be sending experiment id with an sdrn format, but in case they do
+                // we want to be able to handle it and not generate an invalid sdrn by adding another layer to it
+                experimentSdrn: exp.id.startsWith('sdrn:') ? exp.id : (0, experiments_1.generateExperimentSDRN)(exp.id, exp.platform),
+                platform: exp.platform || '',
+                testId: exp.custom?.testId,
             };
         });
     }
@@ -454,11 +503,12 @@ class Tracker {
             isHybrid: !!this.state.isHybrid,
             pageviewId: this.state.pageViewId,
             providerId: this.state.providerId,
+            component: this.state.component,
+            componentVersion: this.state.componentVersion,
             experiments: await this.adaptExperiments(this.builders.experiments),
         };
     }
     /**
-     *
      * @private
      * @category TPaaS Tracking
      */
@@ -518,10 +568,11 @@ class Tracker {
                 source: source || 'unknown',
             };
         }
-        const [actor, consents, experiments] = await Promise.all([
+        const [actor, consents, experiments, currentPage] = await Promise.all([
             this.getActor(),
             this.getConsents(),
             this.adaptExperiments(this.builders.experiments),
+            this.getCurrentTpaasPage(),
         ]);
         const { environmentId, jwe } = (0, pulse_cis_sync_1.parsePulseCookies)();
         return {
@@ -531,29 +582,15 @@ class Tracker {
             user: adaptActorToNewFormat(actor),
             consents: adaptConsentsToNewFormat(consents),
             providerId: this.state.providerId,
+            component: this.state.component,
+            componentVersion: this.state.componentVersion,
             pageviewId: this.state.pageViewId,
-            currentPage: this.currentPage,
+            currentPage,
             experiments,
             environmentId,
             jwe,
         };
     }
-    /**
-     * Generate a generic TPaaS event with common builders output
-     * The method should be used for experiments, not for real production work.
-     * It doesn't have any real TPaaS schema associated with it.
-     * The method doesn't queue or send the event, it just returns the merged object.
-     * The method can be removed at any time in the future, so use it with caution.
-     *
-     * @param input - The input object to merge with the common builders output
-     * @returns A promise that resolves to the merged object
-     * @private
-     * @category TPaaS Tracking
-     */
-    async generateGenericTpaasEvent(input) {
-        const dependencies = await this.prepareTpaasEvent();
-        return (0, pulse_utils_1.pulseMerge)({}, input, (0, tpaas_event_builder_1.getCommonBuildersOutput)(new Date(), dependencies));
-    }
     /**
      * This method extends the list of base experiments that will be automatically included in every event sent by the tracker.
      *
@@ -575,6 +612,9 @@ class Tracker {
      * @category Tracking
      */
     addExperiments(experiments) {
+        if (experiments.some((experiment) => experiment.id.startsWith('sdrn:'))) {
+            loglevel_1.default.warn('Pulse - addExperiments received an experiment id starting with "sdrn:"; pass the raw experiment id instead. The SDK will generate the sdrn automatically.');
+        }
         this.update({ experiments }, true);
     }
     /**
@@ -609,7 +649,7 @@ class Tracker {
             const viewUIElementInputProperties = buildEventFromElement(element);
             this.trackLegacyViewUIElement(viewUIElementInputProperties);
         }));
-        this.legacyVisibilityObservers.get(selector)?.observe(selector);
+        this.legacyVisibilityObservers.get(selector)?.observe(selector, {});
     }
     /**
      * The `addUIElementVisibilityTracking` function provides an interface for sending tracking events when specific UI elements become visible within the viewport.
@@ -641,7 +681,38 @@ class Tracker {
             const eventInput = buildEventFromElement(element);
             this.trackImpressionUIElement(eventInput);
         }));
-        this.visibilityObservers.get(selector)?.observe(selector);
+        this.visibilityObservers.get(selector)?.observe(selector, {});
+    }
+    /**
+     * The `addElementVisibilityObserver` function provides an interface for executing arbitrary code when specific DOM Elements become visible within the viewport.
+     * It is built on the `VisibilityObserver` class, which efficiently detects visibility changes in DOM elements.
+     * When an element becomes at least 2/3 visible, a callback is triggered, with the Element that invoked the callback call as argument.
+     * It leverages the [Intersection Observer API](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API) for viewport tracking
+     * and the [Mutation Observer API](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver) to monitor lazy-loaded elements.
+     *
+     * Example usage:
+     *
+     * ```ts
+     * tracker.addElementVisibilityObserver('[data-pulse-entity-id]', (element) => {
+     *   const eventInput = parseElementIntoEventInput(element); // user-defined function
+     *   tracker.trackImpressionTeaser(eventInput); // can be anything actually, not necessarily a Teaser tracking call
+     * });
+     * ```
+     * @param selector
+     * @param callback
+     * @param options {ObserverOptions}
+     * @param options.threshold - A number between 0 and 1 indicating how much of the element should be visible to trigger
+     * the callback. Default is 0.67 (2/3 of the element).
+     */
+    addElementVisibilityObserver(selector, callback, options = {}) {
+        if (this.visibilityObservers.has(selector)) {
+            console.warn(`Cannot add UI Element visibility tracking for selector "${selector}" as it is already being tracked.`);
+            return;
+        }
+        this.visibilityObservers.set(selector, new visibility_observer_1.VisibilityObserver((element) => {
+            callback(element);
+        }));
+        this.visibilityObservers.get(selector)?.observe(selector, options);
     }
     /**
      * The old trackViewArticle method from the Media Wrapper.
@@ -735,7 +806,7 @@ class Tracker {
      * @category Legacy Tracking
      */
     trackLegacyViewUIElement(inputProperties, trackOptions) {
-        const viewUIElementEventData = (0, event_builder_8.buildLegacyViewUIElementEvent)(inputProperties, this.legacyCurrentPage);
+        const viewUIElementEventData = (0, event_builder_8.buildLegacyViewUIElementEvent)(inputProperties, this.getCurrentLegacyPage());
         return this.track('trackerEvent', viewUIElementEventData, trackOptions);
     }
     /**
@@ -746,7 +817,7 @@ class Tracker {
      * @category Legacy Tracking
      */
     trackLegacyClickUIElement(inputProperties, trackOptions) {
-        const clickUIElementEventData = (0, event_builder_1.buildClickUIElementEvent)(inputProperties, this.legacyCurrentPage);
+        const clickUIElementEventData = (0, event_builder_1.buildClickUIElementEvent)(inputProperties, this.getCurrentLegacyPage());
         return this.track('trackerEvent', clickUIElementEventData, trackOptions);
     }
     /**
@@ -773,19 +844,18 @@ 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, tpaas_schemas_1.ViewHealthPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = (0, tpaas_event_builder_1.buildViewHealthPageEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.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: {
@@ -795,10 +865,7 @@ class Tracker {
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.LeavePage.object.objectType,
                 trackMethod: leavePageCallback,
             });
@@ -822,18 +889,14 @@ class Tracker {
         const event = (0, tpaas_event_builder_1.buildViewPageEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leavePageCallback = (leave) => {
-                this.trackLeavePage({
+            const leavePageCallback = async (leave) => {
+                await this.trackLeavePage({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.LeavePage.object.objectType,
                 trackMethod: leavePageCallback,
             });
@@ -847,23 +910,19 @@ 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, tpaas_schemas_1.ViewSportsPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = (0, tpaas_event_builder_1.buildViewSportsPageEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveSportsPageCallback = (leave) => {
-                this.trackLeaveSportsPage({
+            const leaveSportsPageCallback = async (leave) => {
+                await this.trackLeaveSportsPage({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.LeaveSportsPage.object.objectType,
                 trackMethod: leaveSportsPageCallback,
             });
@@ -891,15 +950,6 @@ class Tracker {
         const event = (0, tpaas_event_builder_1.buildImpressionWidgetEvent)(input, dependencies);
         return this.sendTpaasEvent(event);
     }
-    /**
-     * @param input
-     * @category TPaaS Tracking
-     */
-    async trackImpressionAdSlot(input) {
-        const dependencies = await this.prepareTpaasEvent();
-        const event = (0, tpaas_event_builder_1.buildImpressionAdSlotEvent)(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * @param input
      * @param options
@@ -912,36 +962,20 @@ class Tracker {
         const event = (0, tpaas_event_builder_1.buildViewArticleEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveArticleCallback = (leave) => {
-                this.trackLeaveArticle({
+            const leaveArticleCallback = async (leave) => {
+                await this.trackLeaveArticle({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.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 = (0, tpaas_event_builder_1.buildViewAudioEvent)(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * Tracks a View AudioPage event and automatically fires a Leave AudioPage event when the user
      * navigates away.
@@ -984,20 +1018,20 @@ 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, tpaas_schemas_1.ViewAudioPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = (0, tpaas_event_builder_1.buildViewAudioPageEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.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,
@@ -1008,10 +1042,7 @@ class Tracker {
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...restLeaveTrackingOptions,
                 schema: tpaas_schemas_1.LeaveAudioPage.object.objectType,
                 trackMethod: leaveAudioPageCallback,
             });
@@ -1030,24 +1061,29 @@ class Tracker {
         const event = (0, tpaas_event_builder_1.buildViewErrorEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveErrorCallback = (leave) => {
-                this.trackLeaveError({
+            const leaveErrorCallback = async (leave) => {
+                await this.trackLeaveError({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.LeaveError.object.objectType,
                 trackMethod: leaveErrorCallback,
             });
         }
         return result;
     }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionAdSlot(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = (0, tpaas_event_builder_1.buildImpressionAdSlotEvent)(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -1105,18 +1141,14 @@ class Tracker {
         const event = (0, tpaas_event_builder_1.buildViewFrontpageEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveFrontpageCallback = (leave) => {
-                this.trackLeaveFrontpage({
+            const leaveFrontpageCallback = async (leave) => {
+                await this.trackLeaveFrontpage({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.LeaveFrontpage.object.objectType,
                 trackMethod: leaveFrontpageCallback,
             });
@@ -1130,23 +1162,19 @@ class Tracker {
      */
     async trackViewLandingpage(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, 'LandingPage' /* TODO: ViewLandingpage.object.type once the schema is fixed */);
+        this.setCurrentPage(input.object.objectId, tpaas_schemas_1.ViewLandingpage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = (0, tpaas_event_builder_1.buildViewLandingpageEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveLandingpageCallback = (leave) => {
-                this.trackLeaveLandingpage({
+            const leaveLandingpageCallback = async (leave) => {
+                await this.trackLeaveLandingpage({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.LeaveLandingpage.object.objectType,
                 trackMethod: leaveLandingpageCallback,
             });
@@ -1165,18 +1193,14 @@ class Tracker {
         const event = (0, tpaas_event_builder_1.buildViewListingEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveListingCallback = (leave) => {
-                this.trackLeaveListing({
+            const leaveListingCallback = async (leave) => {
+                await this.trackLeaveListing({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.LeaveListing.object.objectType,
                 trackMethod: leaveListingCallback,
             });
@@ -1195,36 +1219,20 @@ class Tracker {
         const event = (0, tpaas_event_builder_1.buildViewLockedArticleEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveLockedArticleCallback = (leave) => {
-                this.trackLeaveLockedArticle({
+            const leaveLockedArticleCallback = async (leave) => {
+                await this.trackLeaveLockedArticle({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.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 = (0, tpaas_event_builder_1.buildViewLockedAudioEvent)(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * @param input
      * @param options
@@ -1232,40 +1240,25 @@ 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, tpaas_schemas_1.ViewLockedAudioPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = (0, tpaas_event_builder_1.buildViewLockedAudioPageEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveLockedAudioPageCallback = (leave) => {
-                this.trackLeaveLockedAudioPage({
+            const leaveLockedAudioPageCallback = async (leave) => {
+                await this.trackLeaveLockedAudioPage({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.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 = (0, tpaas_event_builder_1.buildViewLockedVideoEvent)(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * @param input
      * @param options
@@ -1273,40 +1266,25 @@ 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, tpaas_schemas_1.ViewLockedVideo.object.objectType);
+        this.setCurrentPage(input.object.objectId, tpaas_schemas_1.ViewLockedVideoPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = (0, tpaas_event_builder_1.buildViewLockedVideoPageEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveLockedVideoPageCallback = (leave) => {
-                this.trackLeaveLockedVideoPage({
+            const leaveLockedVideoPageCallback = async (leave) => {
+                await this.trackLeaveLockedVideoPage({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.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 = (0, tpaas_event_builder_1.buildViewVideoEvent)(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * Tracks a View VideoPage event and automatically fires a Leave VideoPage event when the user
      * navigates away.
@@ -1351,15 +1329,15 @@ 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, tpaas_schemas_1.ViewVideoPage.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = (0, tpaas_event_builder_1.buildViewVideoPageEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.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,
@@ -1370,10 +1348,7 @@ class Tracker {
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...restLeaveTrackingOptions,
                 schema: tpaas_schemas_1.LeaveVideoPage.object.objectType,
                 trackMethod: leaveVideoCallback,
             });
@@ -1387,23 +1362,19 @@ class Tracker {
      */
     async trackViewWeather(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' /* TODO: ViewWeather.object.type once the schema is fixed */);
+        this.setCurrentPage(input.object.objectId, tpaas_schemas_1.ViewWeather.object.objectType);
         const dependencies = await this.prepareTpaasEvent();
         const event = (0, tpaas_event_builder_1.buildViewWeatherEvent)(input, dependencies);
         const result = this.sendTpaasEvent(event);
         if ((0, leaveTrackingTpaas_1.shouldEnableLeaveTracking)(options.leaveTracking)) {
-            const { objectElement, pageElement, heightBuilder, objectResizable } = options.leaveTracking;
-            const leaveWeatherCallback = (leave) => {
-                this.trackLeaveWeather({
+            const leaveWeatherCallback = async (leave) => {
+                await this.trackLeaveWeather({
                     leave,
                     ...input,
                 });
             };
             (0, leaveTrackingTpaas_1.addTpaasLeaveTracking)({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: tpaas_schemas_1.LeaveWeather.object.objectType,
                 trackMethod: leaveWeatherCallback,
             });
@@ -1473,15 +1444,6 @@ class Tracker {
         const event = (0, tpaas_event_builder_1.buildLeaveLockedArticleEvent)(input, dependencies);
         return this.sendTpaasEvent(event);
     }
-    /**
-     * @param input
-     * @category TPaaS Tracking
-     */
-    async trackLeaveLockedAudio(input) {
-        const dependencies = await this.prepareTpaasEvent();
-        const event = (0, tpaas_event_builder_1.buildLeaveLockedAudioEvent)(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -1491,15 +1453,6 @@ class Tracker {
         const event = (0, tpaas_event_builder_1.buildLeaveLockedAudioPageEvent)(input, dependencies);
         return this.sendTpaasEvent(event);
     }
-    /**
-     * @param input
-     * @category TPaaS Tracking
-     */
-    async trackLeaveLockedVideo(input) {
-        const dependencies = await this.prepareTpaasEvent();
-        const event = (0, tpaas_event_builder_1.buildLeaveLockedVideoEvent)(input, dependencies);
-        return this.sendTpaasEvent(event);
-    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -2260,8 +2213,8 @@ 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() {
-        (0, leaveTrackingTpaas_1.trackTpaasActiveLeave)();
+    async trackTpaasActiveLeave() {
+        await (0, leaveTrackingTpaas_1.trackTpaasActiveLeave)();
     }
     /**
      * Check if leave tracking is enabled (if an event will be sent when the user leaves the page)