@schibsted/pulse-sdk 8.0.0-rc.2 → 8.0.0-rc.20

package/dist/ejs/Tracker.js

@@ -1,7 +1,3 @@
-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, ViewListing, ViewLockedArticle, ViewLockedVideo, ViewPage, ViewTitle, } from '@schibsted/tpaas-schemas';
 import logger from 'loglevel';
 import { v4 } from 'uuid';
 import { getDefaultAltHandler, getDefaultNativeJwe } from './app-integration';
@@ -10,7 +6,9 @@ import { getConsentsWaitForAnalytics, getFallbackConsents } from './builders/con
 import { applyAdvertisingConsent, applyAdvertisingConsentSync, } from './builders/consents';
 import { engagementEvent, identityEvent, routableEvent, trackerEvent } from './builders/events';
 import { anonymousEngagementEvent, anonymousTrackerEvent } from './builders/events-anonymous-node';
+import { generateExperimentSDRN } from './builders/experiments';
 import { readSession } from './builders/session-browser';
+import { parsePulseCookies } from './cis-sync';
 import { baseConfig as defaultConfig } from './config';
 import { CISEndpoints, collectorEndpoints, remoteConfig } from './config-browser';
 import defer from './defer';
@@ -20,11 +18,16 @@ import { addPageLeaveTracking, leaveTrackingIsActive, removePageLeaveTracking, r
 import { addTpaasLeaveTracking, getTpaasLeaveObject, leaveTpaasTrackingIsActive, resetTpaasViewedContent, shouldEnableLeaveTracking, trackTpaasActiveLeave, updateTpaasLeaveTracking, updateTpaasViewedContent, } from './leaveTrackingTpaas';
 import send from './network';
 import * as config from './remoteConfig';
+import { buildAnonymousViewUIElementEvent, buildCompletedHealthActionEvent, buildEngagementAdEvent, buildEngagementAffiliateEvent, buildEngagementAudioEvent, buildEngagementFormEvent, buildEngagementHealthUIElementEvent, buildEngagementOfferEvent, buildEngagementSchoolUIElementEvent, buildEngagementSportsUIElementEvent, buildEngagementTeaserEvent, buildEngagementTvModuleEvent, buildEngagementTvSearchEvent, buildEngagementUIElementEvent, buildEngagementVideoAdEvent, buildEngagementVideoEvent, buildEngagementWidgetEvent, buildHeartbeatCommercialArticleEvent, buildImpressionAdEvent, buildImpressionAdSlotEvent, buildImpressionAffiliateEvent, buildImpressionFormEvent, buildImpressionHealthUIElementEvent, buildImpressionOfferEvent, buildImpressionPlayerEvent, buildImpressionSchoolUIElementEvent, buildImpressionSportsUIElementEvent, buildImpressionTeaserEvent, buildImpressionUIElementEvent, buildImpressionWidgetEvent, buildLeaveArticleEvent, buildLeaveAudioPageEvent, buildLeaveErrorEvent, buildLeaveFrontpageEvent, buildLeaveLandingpageEvent, buildLeaveListingEvent, buildLeaveLockedArticleEvent, buildLeaveLockedAudioPageEvent, buildLeaveLockedPageEvent, buildLeaveLockedVideoPageEvent, buildLeavePageEvent, buildLeaveSchoolPageEvent, buildLeaveSportsPageEvent, buildLeaveVideoPageEvent, buildLeaveWeatherEvent, buildLoadAdEvent, buildRequestAdEvent, buildViewArticleEvent, buildViewAudioPageEvent, buildViewErrorEvent, buildViewFrontpageEvent, buildViewHealthPageEvent, buildViewLandingpageEvent, buildViewListingEvent, buildViewLockedArticleEvent, buildViewLockedAudioPageEvent, buildViewLockedPageEvent, buildViewLockedVideoPageEvent, buildViewPageEvent, buildViewSchoolPageEvent, buildViewSportsPageEvent, buildViewTitleEvent, buildViewVideoPageEvent, buildViewWeatherEvent, } from './tpaas-builders';
+import { LeaveArticle, LeaveAudioPage, LeaveError, LeaveFrontpage, LeaveLandingpage, LeaveListing, LeaveLockedArticle, LeaveLockedAudioPage, LeaveLockedPage, LeaveLockedVideoPage, LeavePage, LeaveSchoolPage, LeaveSportsPage, LeaveVideoPage, LeaveWeather, ViewArticle, ViewAudioPage, ViewError, ViewFrontpage, ViewHealthPage, ViewLandingpage, ViewListing, ViewLockedArticle, ViewLockedAudioPage, ViewLockedPage, ViewLockedVideoPage, ViewPage, ViewSportsPage, ViewTitle, ViewVideoPage, ViewWeather, } from './tpaas-schemas';
 import { startProxyProviderListener } from './tracker-proxy/proxy-provider';
+import { evaluateAndFlatten, isBrowser, isFunction, isPromise, isString, omit, pulseMerge, throttle } from './utils';
 import { SDK_VERSION } from './version';
 import { VisibilityObserver } from './visibility-observer';
 import warnOnce from './warnOnce';
 import { buildClickUIElementEvent } from './wrapper/engagement/ui-element/event-builder';
+import { isLegacyPageType } from './wrapper/types';
+import { mapPageToPageRef } from './wrapper/utils/map-page-to-page-ref';
 import { pageFromPageView } from './wrapper/utils/page-from-page-view';
 import { buildLegacyViewArticleEvent } from './wrapper/view/article/event-builder';
 import { buildLegacyViewFrontpageEvent } from './wrapper/view/frontpage/event-builder';
@@ -60,6 +63,7 @@ const anonymousEvents = {
     trackerEvent: anonymousTrackerEvent,
     engagementEvent: anonymousEngagementEvent,
 };
+const ANONYMOUS_EVENT_FORBIDDEN_FIELDS = ['session', 'actor', 'device', 'location', 'pageViewId'];
 /**
  * @typeParam T Type of event to track
  * @param name
@@ -68,6 +72,17 @@ const anonymousEvents = {
 function getAnonymousEventBuilder(name) {
     return name in anonymousEvents ? anonymousEvents[name] : anonymousEvents.trackerEvent;
 }
+// This looks overkill, but a mapping feels safer than doing string operations (capitalize) with javascript
+const mapDeployStageToTpaasStage = (deployStage) => {
+    switch (deployStage) {
+        case 'dev':
+            return 'Dev';
+        case 'pre':
+            return 'Pre';
+        case 'pro':
+            return 'Pro';
+    }
+};
 /**
  * Determines if the SDK is running in a Hybrid (WebView) environment.
  *
@@ -114,6 +129,21 @@ export function unsubscribe(eventName, callback) {
  * @class Tracker
  */
 export default class Tracker {
+    async getCurrentTpaasPage(currentPageInfo = this.currentPageContext.info) {
+        const { id, type, url } = await currentPageInfo;
+        return mapPageToPageRef(id, type, url);
+    }
+    async getCurrentLegacyPage() {
+        const { id, type, url } = await this.currentPageContext.info;
+        // make sure the pageType is valid for legacy events
+        const validatedType = 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]
      * >
@@ -132,12 +162,36 @@ export default 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',
-            type: 'Page',
-            url: typeof window !== 'undefined' ? window.location.href : '',
+        /**
+         * Current page state shared by legacy and TPaaS tracking. See CurrentPageContext for
+         * which properties are shared and which are exclusively TPaaS metadata.
+         */
+        this.currentPageContext = {
+            info: {
+                id: 'unknown',
+                type: 'Page',
+                url: isBrowser ? window.location.href : undefined,
+            },
+            referrer: {
+                url: isBrowser ? document.referrer || undefined : undefined,
+            },
+        };
+        this.setCurrentTpaasPageData = ({ id, type, referrer, content, sports, }) => {
+            // TPaaS Views replace the context, intentionally resetting omitted content and sports.
+            this.currentPageContext = {
+                info: {
+                    id: id || 'unknown',
+                    type: type || 'Page',
+                    url: isBrowser ? window.location.href : undefined,
+                },
+                referrer: {
+                    ...referrer,
+                    url: referrer?.url ?? (isBrowser ? document.referrer || undefined : undefined),
+                },
+                content,
+                sports,
+            };
         };
-        this.currentPage = undefined;
         /**
          * Promise that resolves when a session ID becomes available
          * @private
@@ -149,24 +203,22 @@ export default class Tracker {
          */
         this.hasProxyListener = false;
         this.setPageDefaults = (pageViewEvent) => {
-            this.legacyCurrentPage = pageFromPageView(pageViewEvent);
+            // Legacy Views update only the shared properties, preserving TPaaS-only content and sports.
+            this.currentPageContext.info = pageFromPageView(pageViewEvent);
+            this.currentPageContext.referrer = Promise.resolve(pageViewEvent.origin).then((originProperties) => mapPageToPageRef(originProperties?.id, originProperties?.type, originProperties?.url));
             if (pageViewEvent.origin) {
                 const pageDefaults = { origin: pageViewEvent.origin };
                 this.update(pageDefaults, true);
             }
         };
-        this.setCurrentPage = (id, type) => {
-            this.currentPage = {
-                pageId: id,
-                pageType: type,
-                url: isBrowser ? window.location.href : undefined,
-            };
-        };
         logger.setLevel(config?.logLevel ?? logger.levels.ERROR);
         // runtime check for providerId inconsistency
         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 (isBrowser && config?.autoCreateConsents) {
             config.consents = getConsentsWaitForAnalytics((consents) => {
@@ -205,11 +257,15 @@ export default class Tracker {
             tpaasCollectorBaseUrl: collectorEndpoints[deployStageTpaas],
             trackerId: v4(),
             vendors: config?.vendors?.length ? [] : ['xandr'],
+            useBeacon: true,
+            useBeaconWhenAvailable: true,
         }, config);
         // Move to default config?
         this.builders = pulseMerge({}, builders, {
             provider: {
                 id: providerId,
+                ...(config?.component !== undefined && { component: config.component }),
+                ...(config?.componentVersion !== undefined && { componentVersion: config.componentVersion }),
             },
             tracker: {
                 version: SDK_VERSION,
@@ -326,6 +382,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);
     }
     /**
@@ -358,11 +419,11 @@ export default class Tracker {
      */
     async trackAnonymous(eventType, input, options) {
         // We must create the event as soon as possible, as it defines the creationDate.
-        const newEvent = this.createAnonymousEvent(input);
+        const newEvent = omit(this.createAnonymousEvent(input), ANONYMOUS_EVENT_FORBIDDEN_FIELDS);
         // Remote config values ----------------
         await this._applyRemoteConfigEndpoints();
         // Resolve all available properties ----------------
-        const resolvedOutput = await Promise.all([this.resolveTrackInput(newEvent), this.resolveTrackGlobals()]);
+        const resolvedOutput = await Promise.all([this.resolveTrackInput(newEvent), this.resolveAnonymousTrackGlobals()]);
         let eventOutput = resolvedOutput.reduce((acc, p) => pulseMerge(acc, p), {});
         eventOutput = this.applyAnonymousEventTypeDefaults(eventOutput, eventType);
         // Leave Events ----------------
@@ -376,6 +437,7 @@ export default class Tracker {
             eventInput: eventOutput,
             sdkConfig: this.state,
         });
+        eventOutput = omit(eventOutput, ANONYMOUS_EVENT_FORBIDDEN_FIELDS);
         if (options?.bookmarkKey) {
             this.bookmark.set(options.bookmarkKey, eventOutput);
         }
@@ -395,6 +457,11 @@ export default 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 : generateExperimentSDRN(exp.id, exp.platform),
+                platform: exp.platform || '',
+                testId: exp.custom?.testId,
             };
         });
     }
@@ -404,29 +471,52 @@ export default class Tracker {
      * @category TPaaS Tracking
      */
     async prepareAnonymousTpaasEvent() {
+        const { isHybrid, pageViewId, providerId, component, componentVersion, stage: providerStage, product: providerProduct, version: providerVersion, deployStageTpaas, } = this.state;
+        const providerName = this.state.provider?.name;
+        const providerGroup = this.state.provider?.group;
+        const experimentsInput = this.builders.experiments;
+        const currentPageReferrerInput = this.currentPageContext.referrer;
         try {
             await this._applyRemoteConfigEndpoints();
         }
         catch (ex) {
             logger.trace('Failed to sync remote config', ex);
         }
+        const [experiments, currentPageReferrer] = await Promise.all([
+            this.adaptExperiments(experimentsInput),
+            currentPageReferrerInput,
+        ]);
         return {
-            autoTrackerVersion: this.builders.tracker?.autoTrackerVersion,
             version: SDK_VERSION,
-            isHybrid: !!this.state.isHybrid,
-            pageviewId: this.state.pageViewId,
-            providerId: this.state.providerId,
-            experiments: await this.adaptExperiments(this.builders.experiments),
+            isHybrid: !!isHybrid,
+            pageviewId: pageViewId,
+            providerId,
+            providerName,
+            providerGroup,
+            providerStage,
+            providerProduct,
+            providerVersion,
+            component,
+            componentVersion,
+            routingStage: mapDeployStageToTpaasStage(deployStageTpaas),
+            experiments,
+            currentPageReferrer,
         };
     }
     /**
-     *
      * @private
      * @category TPaaS Tracking
      */
     async prepareTpaasEvent() {
+        // Capture event context before any asynchronous work so a concurrent update or View
+        // event cannot change the dependencies used to finish building this event.
+        const builders = { ...this.builders };
+        const { isHybrid, providerId, component, componentVersion, stage: providerStage, product: providerProduct, version: providerVersion, pageViewId, deployStageTpaas, } = this.state;
+        const providerName = this.state.provider?.name;
+        const providerGroup = this.state.provider?.group;
+        const { info: currentPageInfoInput, content: currentPageContent, sports: currentPageSports, referrer: currentPageReferrerInput, } = this.currentPageContext;
         try {
-            await this.syncRemoteResources(undefined, { ...this.builders });
+            await this.syncRemoteResources(undefined, builders);
         }
         catch (ex) {
             logger.trace('Failed to sync remote resources', ex);
@@ -480,42 +570,40 @@ export default class Tracker {
                 source: source || 'unknown',
             };
         }
-        const [actor, consents, experiments] = await Promise.all([
-            this.getActor(),
+        // Consents are intentionally not part of the event-context snapshot. Read them after
+        // remote synchronization so a blocking tracking call can use newly resolved consents.
+        const [actor, consents, experiments, currentPage, currentPageReferrer] = await Promise.all([
+            identity.getActor(builders),
             this.getConsents(),
-            this.adaptExperiments(this.builders.experiments),
+            this.adaptExperiments(builders.experiments),
+            this.getCurrentTpaasPage(currentPageInfoInput),
+            currentPageReferrerInput,
         ]);
         const { environmentId, jwe } = parsePulseCookies();
         return {
-            autoTrackerVersion: this.builders.tracker?.autoTrackerVersion,
             version: SDK_VERSION,
-            isHybrid: !!this.state.isHybrid,
+            isHybrid: !!isHybrid,
             user: adaptActorToNewFormat(actor),
             consents: adaptConsentsToNewFormat(consents),
-            providerId: this.state.providerId,
-            pageviewId: this.state.pageViewId,
-            currentPage: this.currentPage,
+            providerId,
+            providerName,
+            providerGroup,
+            providerStage,
+            providerProduct,
+            providerVersion,
+            component,
+            componentVersion,
+            pageviewId: pageViewId,
+            routingStage: mapDeployStageToTpaasStage(deployStageTpaas),
+            currentPage,
+            currentPageContent,
+            currentPageSports,
+            currentPageReferrer,
             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 pulseMerge({}, input, getCommonBuildersOutput(new Date(), dependencies));
-    }
     /**
      * This method extends the list of base experiments that will be automatically included in every event sent by the tracker.
      *
@@ -537,6 +625,9 @@ export default class Tracker {
      * @category Tracking
      */
     addExperiments(experiments) {
+        if (experiments.some((experiment) => experiment.id.startsWith('sdrn:'))) {
+            logger.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);
     }
     /**
@@ -571,7 +662,7 @@ export default 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.
@@ -603,7 +694,38 @@ export default 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 VisibilityObserver((element) => {
+            callback(element);
+        }));
+        this.visibilityObservers.get(selector)?.observe(selector, options);
     }
     /**
      * The old trackViewArticle method from the Media Wrapper.
@@ -697,7 +819,7 @@ export default class Tracker {
      * @category Legacy Tracking
      */
     trackLegacyViewUIElement(inputProperties, trackOptions) {
-        const viewUIElementEventData = buildLegacyViewUIElementEvent(inputProperties, this.legacyCurrentPage);
+        const viewUIElementEventData = buildLegacyViewUIElementEvent(inputProperties, this.getCurrentLegacyPage());
         return this.track('trackerEvent', viewUIElementEventData, trackOptions);
     }
     /**
@@ -708,7 +830,7 @@ export default class Tracker {
      * @category Legacy Tracking
      */
     trackLegacyClickUIElement(inputProperties, trackOptions) {
-        const clickUIElementEventData = buildClickUIElementEvent(inputProperties, this.legacyCurrentPage);
+        const clickUIElementEventData = buildClickUIElementEvent(inputProperties, this.getCurrentLegacyPage());
         return this.track('trackerEvent', clickUIElementEventData, trackOptions);
     }
     /**
@@ -735,19 +857,22 @@ 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.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewHealthPage.object.objectType,
+            referrer: input.page?.referrer,
+        });
         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, userHealthData, ...restInput } = input;
+                const { category, custom, name, tags, food, physicalActivity, training, ...restObject } = input.object;
+                await this.trackLeavePage({
                     leave,
                     ...restInput,
                     object: {
@@ -757,10 +882,7 @@ export default class Tracker {
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: LeavePage.object.objectType,
                 trackMethod: leavePageCallback,
             });
@@ -779,23 +901,23 @@ export default class Tracker {
      */
     async trackViewPage(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, ViewPage.object.objectType);
+        this.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewPage.object.objectType,
+            referrer: input.page?.referrer,
+        });
         const dependencies = await this.prepareTpaasEvent();
         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) => {
+                await this.trackLeavePage({
                     leave,
                     ...input,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: LeavePage.object.objectType,
                 trackMethod: leavePageCallback,
             });
@@ -809,36 +931,77 @@ 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.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewSportsPage.object.objectType,
+            referrer: input.page?.referrer,
+            sports: {
+                sportName: input.object.sportName,
+                sportSubview: input.object.sportSubview,
+                sportView: input.object.sportView,
+                sports: input.object.sports,
+            },
+        });
         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,
             });
         }
         return result;
     }
+    /**
+     * @param input
+     * @param options
+     * @category TPaaS Tracking
+     */
+    async trackViewSchoolPage(input, options) {
+        this.newPageView();
+        // TODO: SchoolPage is not currently part of the catalog's PageRef.pageType enum.
+        this.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: 'Page',
+            referrer: input.page?.referrer,
+        });
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildViewSchoolPageEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const leaveSchoolPageCallback = async (leave) => {
+                await this.trackLeaveSchoolPage({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                ...options.leaveTracking,
+                schema: LeaveSchoolPage.object.objectType,
+                trackMethod: leaveSchoolPageCallback,
+            });
+        }
+        return result;
+    }
     /**
      * @param input
      * @category TPaaS Tracking
      */
     async trackViewTitle(input) {
         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, ViewTitle.object.objectType);
+        this.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewTitle.object.objectType,
+            referrer: input.page?.referrer,
+        });
         const dependencies = await this.prepareTpaasEvent();
         const event = buildViewTitleEvent(input, dependencies);
         return this.sendTpaasEvent(event);
@@ -857,9 +1020,18 @@ export default class Tracker {
      * @param input
      * @category TPaaS Tracking
      */
-    async trackImpressionAdSlot(input) {
+    async trackLoadAd(input) {
         const dependencies = await this.prepareTpaasEvent();
-        const event = buildImpressionAdSlotEvent(input, dependencies);
+        const event = buildLoadAdEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackRequestAd(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildRequestAdEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
     /**
@@ -869,41 +1041,30 @@ export default class Tracker {
      */
     async trackViewArticle(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, ViewArticle.object.objectType);
+        this.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewArticle.object.objectType,
+            referrer: input.page?.referrer,
+            content: input.page?.content,
+        });
         const dependencies = await this.prepareTpaasEvent();
         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) => {
+                await this.trackLeaveArticle({
                     leave,
                     ...input,
                 });
             };
             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.
@@ -946,20 +1107,25 @@ 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.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewAudioPage.object.objectType,
+            referrer: input.page?.referrer,
+            content: input.page?.content,
+        });
         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,
@@ -970,10 +1136,7 @@ export default class Tracker {
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...restLeaveTrackingOptions,
                 schema: LeaveAudioPage.object.objectType,
                 trackMethod: leaveAudioPageCallback,
             });
@@ -987,29 +1150,56 @@ export default class Tracker {
      */
     async trackViewError(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, ViewError.object.objectType);
+        this.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewError.object.objectType,
+            referrer: input.page?.referrer,
+        });
         const dependencies = await this.prepareTpaasEvent();
         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,
             });
         }
         return result;
     }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionAd(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionAdEvent(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
+     * @category TPaaS Tracking
+     */
+    async trackImpressionAffiliate(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionAffiliateEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -1037,6 +1227,24 @@ export default class Tracker {
         const event = buildImpressionPlayerEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionSportsUIElement(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionSportsUIElementEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackImpressionSchoolUIElement(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildImpressionSchoolUIElementEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -1062,23 +1270,23 @@ export default class Tracker {
      */
     async trackViewFrontpage(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, ViewFrontpage.object.objectType);
+        this.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewFrontpage.object.objectType,
+            referrer: input.page?.referrer,
+        });
         const dependencies = await this.prepareTpaasEvent();
         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) => {
+                await this.trackLeaveFrontpage({
                     leave,
                     ...input,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                objectResizable,
-                heightBuilder,
+                ...options.leaveTracking,
                 schema: LeaveFrontpage.object.objectType,
                 trackMethod: leaveFrontpageCallback,
             });
@@ -1092,23 +1300,23 @@ export default 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.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewLandingpage.object.objectType,
+            referrer: input.page?.referrer,
+        });
         const dependencies = await this.prepareTpaasEvent();
         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,
             });
@@ -1122,23 +1330,23 @@ export default class Tracker {
      */
     async trackViewListing(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, ViewListing.object.objectType);
+        this.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewListing.object.objectType,
+            referrer: input.page?.referrer,
+        });
         const dependencies = await this.prepareTpaasEvent();
         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,
             });
@@ -1152,41 +1360,30 @@ export default class Tracker {
      */
     async trackViewLockedArticle(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, ViewLockedArticle.object.objectType);
+        this.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewLockedArticle.object.objectType,
+            referrer: input.page?.referrer,
+            content: input.page?.content,
+        });
         const dependencies = await this.prepareTpaasEvent();
         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) => {
+                await this.trackLeaveLockedArticle({
                     leave,
                     ...input,
                 });
             };
             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
@@ -1194,23 +1391,24 @@ 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.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewLockedAudioPage.object.objectType,
+            referrer: input.page?.referrer,
+            content: input.page?.content,
+        });
         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,
             });
@@ -1219,14 +1417,33 @@ export default class Tracker {
     }
     /**
      * @param input
+     * @param options
      * @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
+    async trackViewLockedPage(input, options) {
+        this.newPageView();
+        this.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewLockedPage.object.objectType,
+            referrer: input.page?.referrer,
+        });
         const dependencies = await this.prepareTpaasEvent();
-        const event = buildViewLockedVideoEvent(input, dependencies);
-        return this.sendTpaasEvent(event);
+        const event = buildViewLockedPageEvent(input, dependencies);
+        const result = this.sendTpaasEvent(event);
+        if (shouldEnableLeaveTracking(options.leaveTracking)) {
+            const leaveLockedPageCallback = async (leave) => {
+                await this.trackLeaveLockedPage({
+                    leave,
+                    ...input,
+                });
+            };
+            addTpaasLeaveTracking({
+                ...options.leaveTracking,
+                schema: LeaveLockedPage.object.objectType,
+                trackMethod: leaveLockedPageCallback,
+            });
+        }
+        return result;
     }
     /**
      * @param input
@@ -1235,40 +1452,30 @@ 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.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewLockedVideoPage.object.objectType,
+            referrer: input.page?.referrer,
+            content: input.page?.content,
+        });
         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.
@@ -1313,29 +1520,27 @@ 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.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewVideoPage.object.objectType,
+            referrer: input.page?.referrer,
+            content: input.page?.content,
+        });
         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,
-                        activityDurationMs: leave.activityDurationMs,
-                        durationMs: leave.durationMs,
-                    },
+                    leaveStories: leaveStoriesInput,
                     ...input,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...restLeaveTrackingOptions,
                 schema: LeaveVideoPage.object.objectType,
                 trackMethod: leaveVideoCallback,
             });
@@ -1349,23 +1554,23 @@ export default 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.setCurrentTpaasPageData({
+            id: input.object.objectId,
+            type: ViewWeather.object.objectType,
+            referrer: input.page?.referrer,
+        });
         const dependencies = await this.prepareTpaasEvent();
         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) => {
+                await this.trackLeaveWeather({
                     leave,
                     ...input,
                 });
             };
             addTpaasLeaveTracking({
-                objectElement,
-                pageElement,
-                heightBuilder,
-                objectResizable,
+                ...options.leaveTracking,
                 schema: LeaveWeather.object.objectType,
                 trackMethod: leaveWeatherCallback,
             });
@@ -1435,15 +1640,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
@@ -1457,9 +1653,9 @@ export default class Tracker {
      * @param input
      * @category TPaaS Tracking
      */
-    async trackLeaveLockedVideo(input) {
+    async trackLeaveLockedPage(input) {
         const dependencies = await this.prepareTpaasEvent();
-        const event = buildLeaveLockedVideoEvent(input, dependencies);
+        const event = buildLeaveLockedPageEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
     /**
@@ -1489,6 +1685,15 @@ export default class Tracker {
         const event = buildLeaveSportsPageEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackLeaveSchoolPage(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildLeaveSchoolPageEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -1507,6 +1712,24 @@ export default class Tracker {
         const event = buildLeaveWeatherEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementAd(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementAdEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementAffiliate(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementAffiliateEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -1534,6 +1757,24 @@ export default class Tracker {
         const event = buildEngagementOfferEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementSportsUIElement(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementSportsUIElementEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementSchoolUIElement(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementSchoolUIElementEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -1543,6 +1784,24 @@ export default class Tracker {
         const event = buildEngagementTeaserEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementTvModule(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementTvModuleEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackEngagementTvSearch(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildEngagementTvSearchEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
     /**
      * @param input
      * @category TPaaS Tracking
@@ -1579,6 +1838,15 @@ export default class Tracker {
         const event = buildEngagementWidgetEvent(input, dependencies);
         return this.sendTpaasEvent(event);
     }
+    /**
+     * @param input
+     * @category TPaaS Tracking
+     */
+    async trackHeartbeatCommercialArticle(input) {
+        const dependencies = await this.prepareTpaasEvent();
+        const event = buildHeartbeatCommercialArticleEvent(input, dependencies);
+        return this.sendTpaasEvent(event);
+    }
     /**
      * this is the method that actually sends the event to the server
      * @private
@@ -2222,8 +2490,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)
@@ -2252,8 +2520,9 @@ export default class Tracker {
     /**
      * @private
      */
-    async resolveTrackGlobals() {
-        return evaluateAndFlatten({ ...this.builders });
+    async resolveAnonymousTrackGlobals() {
+        // Omit before evaluation so forbidden promise/function builders cannot delay or fail anonymous tracking.
+        return evaluateAndFlatten(omit(this.builders, ANONYMOUS_EVENT_FORBIDDEN_FIELDS));
     }
     /**
      * Send all anonymous events that are in the internal anonymous event queue.
@@ -2317,12 +2586,18 @@ export default class Tracker {
     async prepareQueuesAndSend(eventQueue, retryEventQueue) {
         const promisesToBeSent = eventQueue.splice(0);
         const eventsToBeSent = promisesToBeSent.map((p) => p.inputValue);
-        const eventsToRetry = retryEventQueue;
+        const eventsToRetry = retryEventQueue.splice(0);
         eventQueue.length = 0;
         retryEventQueue.length = 0;
         const evaluatedEvents = await Promise.all(eventsToBeSent);
         const url = this._getCollectorPath();
         const data = [...evaluatedEvents, ...eventsToRetry];
+        // in some cases, _sendImmediately executes an asynchronous operation (cisSync) after checking for empty array
+        // due to that, it's still possible for this function to be called with an empty array, so we need to check for that again before sending
+        // in order to avoid making an empty request to collector
+        if (data.length === 0) {
+            return [];
+        }
         // biome-ignore lint/suspicious/noExplicitAny: -
         async function onFailedSend(response) {
             // We retry an event once, but discard already retried events