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

package/dist/ejs/tpaas-builders/builders.js

@@ -0,0 +1,259 @@
+import { merge } from 'ts-deepmerge';
+import { AnonymousImpressionUIElement, CompletedHealthAction, EngagementAd, EngagementAffiliate, EngagementAudio, EngagementForm, EngagementHealthUIElement, EngagementOffer, EngagementSchoolUIElement, EngagementSportsUIElement, EngagementTeaser, EngagementTvModule, EngagementTvSearch, EngagementUIElement, EngagementVideo, EngagementVideoAd, EngagementWidget, HeartbeatCommercialArticle, ImpressionAd, ImpressionAdSlot, ImpressionAffiliate, ImpressionForm, ImpressionHealthUIElement, ImpressionOffer, ImpressionPlayer, ImpressionSchoolUIElement, ImpressionSportsUIElement, ImpressionTeaser, ImpressionUIElement, ImpressionWidget, LeaveArticle, LeaveAudioPage, LeaveError, LeaveFrontpage, LeaveLandingpage, LeaveListing, LeaveLockedArticle, LeaveLockedAudioPage, LeaveLockedPage, LeaveLockedVideoPage, LeavePage, LeaveSchoolPage, LeaveSportsPage, LeaveVideoPage, LeaveWeather, LoadAd, ViewArticle, ViewAudioPage, ViewError, ViewFrontpage, ViewHealthPage, ViewLandingpage, ViewListing, ViewLockedArticle, ViewLockedAudioPage, ViewLockedPage, ViewLockedVideoPage, ViewPage, ViewSchoolPage, ViewSportsPage, ViewTitle, ViewVideoPage, ViewWeather, } from '../tpaas-schemas';
+import { builder as anonymousBuilder } from './builders/anonymous';
+import { builder as baseEventBuilder } from './builders/baseEvent';
+import { builder as catalogVersionBuilder } from './builders/catalogVersion';
+import { builder as consentsBuilder } from './builders/consents';
+import { builder as deviceBuilder } from './builders/device';
+import { builder as experimentsBuilder } from './builders/experiments';
+import { builder as navigationTypeBuilder } from './builders/navigationType';
+import { builder as pageContentBuilder } from './builders/pageContent';
+import { builder as pageInfoBuilder } from './builders/pageInfo';
+import { builder as pageSportsBuilder } from './builders/pageSports';
+import { builder as pageviewIdBuilder } from './builders/pageviewId';
+import { builder as providerBuilder } from './builders/provider';
+import { builder as referrerBuilder } from './builders/referrer';
+import { builder as sessionBuilder } from './builders/session';
+import { builder as timeBuilder } from './builders/time';
+import { builder as trackerBuilder } from './builders/trackerBuilder';
+import { builder as userBuilder } from './builders/user';
+import { builder as utmBuilder } from './builders/utm';
+export const getCommonBuildersOutput = (context) => {
+    const { createdAt, session, isHybrid, version, environmentId, jwe, user, consents, providerId, providerName, providerGroup, providerStage, providerProduct, providerVersion, component, componentVersion, pageviewId, currentPage, currentPageReferrer, routingStage, browser, } = context;
+    const { experiments } = context.input;
+    return merge(trackerBuilder({ isHybrid, version, routingStage }), timeBuilder(createdAt), sessionBuilder(session), deviceBuilder(environmentId, jwe, browser), userBuilder(user), baseEventBuilder(), consentsBuilder(consents), providerBuilder(providerId, providerStage, providerProduct, providerVersion, component, componentVersion, providerName, providerGroup), pageInfoBuilder(currentPage, browser.url), pageviewIdBuilder(pageviewId), utmBuilder(browser.search), referrerBuilder(currentPageReferrer), catalogVersionBuilder(), experimentsBuilder(context.experiments, experiments));
+};
+const getElementEventBuildersOutput = (context) => merge(getCommonBuildersOutput(context), pageContentBuilder(context.currentPageContent));
+const getSportsElementEventBuildersOutput = (context) => merge(getElementEventBuildersOutput(context), pageSportsBuilder(context.currentPageSports));
+// there's a bug in the ts-deepmerge library that doesn't properly resolve merging optionals with required properties
+// due to this, we need to do 2 things:
+// (1) manually omit navigationType from the input before merging.
+// it has no effect on the final value since navigationType will always be set by the navigationTypeBuilder.
+// (2) ensure page is always defined in the input, even when it's not passed to the SDK
+// again, it has no effect on the final value because several builders are passing a page object
+// But this makes TS happy in an elegant way, without type assertions at the merge level
+const normalizePageInput = (input) => {
+    const { page, ...rest } = input;
+    if (!page) {
+        return {
+            ...rest,
+            page: {},
+        };
+    }
+    if (!('navigationType' in page)) {
+        return input;
+    }
+    const { navigationType: _, ...pageRest } = page;
+    return {
+        ...rest,
+        page: {
+            ...pageRest,
+        },
+    };
+};
+// #region AnonymousImpression Event Builders
+export function buildAnonymousImpressionUIElementEvent(context) {
+    const { createdAt, isHybrid, version, pageviewId, providerId, providerName, providerGroup, providerStage, providerProduct, providerVersion, component, componentVersion, currentPageReferrer, routingStage, } = context;
+    return merge(AnonymousImpressionUIElement, baseEventBuilder(), trackerBuilder({ isHybrid, version, routingStage }), timeBuilder(createdAt), pageviewIdBuilder(pageviewId), utmBuilder(context.browser.search), anonymousBuilder(), providerBuilder(providerId, providerStage, providerProduct, providerVersion, component, componentVersion, providerName, providerGroup), referrerBuilder(currentPageReferrer), experimentsBuilder(context.experiments, context.input.experiments), catalogVersionBuilder(), normalizePageInput(context.input));
+}
+// #endregion
+// #region View Event Builders
+export function buildViewArticleEvent(context) {
+    return merge(ViewArticle, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewAudioPageEvent(context) {
+    return merge(ViewAudioPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewErrorEvent(context) {
+    return merge(ViewError, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewFrontpageEvent(context) {
+    return merge(ViewFrontpage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewLandingpageEvent(context) {
+    return merge(ViewLandingpage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewListingEvent(context) {
+    return merge(ViewListing, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewLockedArticleEvent(context) {
+    return merge(ViewLockedArticle, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewLockedAudioPageEvent(context) {
+    return merge(ViewLockedAudioPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewLockedPageEvent(context) {
+    return merge(ViewLockedPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewLockedVideoPageEvent(context) {
+    return merge(ViewLockedVideoPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveLockedVideoPageEvent(context) {
+    return merge(LeaveLockedVideoPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewPageEvent(context) {
+    return merge(ViewPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewSportsPageEvent(context) {
+    return merge(ViewSportsPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewSchoolPageEvent(context) {
+    return merge(ViewSchoolPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewTitleEvent(context) {
+    return merge(ViewTitle, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewVideoPageEvent(context) {
+    return merge(ViewVideoPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildViewWeatherEvent(context) {
+    return merge(ViewWeather, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+// #endregion
+// #region Leave Event Builders
+export function buildLeaveArticleEvent(context) {
+    return merge(LeaveArticle, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveAudioPageEvent(context) {
+    return merge(LeaveAudioPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveErrorEvent(context) {
+    return merge(LeaveError, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveFrontpageEvent(context) {
+    return merge(LeaveFrontpage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveLandingpageEvent(context) {
+    return merge(LeaveLandingpage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveListingEvent(context) {
+    return merge(LeaveListing, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveLockedArticleEvent(context) {
+    return merge(LeaveLockedArticle, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveLockedAudioPageEvent(context) {
+    return merge(LeaveLockedAudioPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveLockedPageEvent(context) {
+    return merge(LeaveLockedPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeavePageEvent(context) {
+    return merge(LeavePage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveSportsPageEvent(context) {
+    return merge(LeaveSportsPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveSchoolPageEvent(context) {
+    return merge(LeaveSchoolPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveVideoPageEvent(context) {
+    return merge(LeaveVideoPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildLeaveWeatherEvent(context) {
+    return merge(LeaveWeather, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+// #endregion
+// #region Engagement Event Builders
+export function buildEngagementAdEvent(context) {
+    return merge(EngagementAd, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementAffiliateEvent(context) {
+    return merge(EngagementAffiliate, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementAudioEvent(context) {
+    return merge(EngagementAudio, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementFormEvent(context) {
+    return merge(EngagementForm, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementOfferEvent(context) {
+    return merge(EngagementOffer, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementSportsUIElementEvent(context) {
+    return merge(EngagementSportsUIElement, getSportsElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementSchoolUIElementEvent(context) {
+    return merge(EngagementSchoolUIElement, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementTeaserEvent(context) {
+    return merge(EngagementTeaser, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementTvModuleEvent(context) {
+    return merge(EngagementTvModule, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementTvSearchEvent(context) {
+    return merge(EngagementTvSearch, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementUIElementEvent(context) {
+    return merge(EngagementUIElement, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementVideoEvent(context) {
+    return merge(EngagementVideo, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementVideoAdEvent(context) {
+    return merge(EngagementVideoAd, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementWidgetEvent(context) {
+    return merge(EngagementWidget, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+// #endregion
+// #region Heartbeat Event Builders
+export function buildHeartbeatCommercialArticleEvent(context) {
+    return merge(HeartbeatCommercialArticle, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+// #endregion
+// #region Health Event Builders
+export function buildCompletedHealthActionEvent(context) {
+    return merge(CompletedHealthAction, getCommonBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildEngagementHealthUIElementEvent(context) {
+    return merge(EngagementHealthUIElement, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildViewHealthPageEvent(context) {
+    return merge(ViewHealthPage, getCommonBuildersOutput(context), normalizePageInput(context.input), navigationTypeBuilder(context.input.page?.navigationType));
+}
+export function buildImpressionHealthUIElementEvent(context) {
+    return merge(ImpressionHealthUIElement, getCommonBuildersOutput(context), normalizePageInput(context.input));
+}
+// #endregion
+// #region Impression Event Builders
+export function buildImpressionAdEvent(context) {
+    return merge(ImpressionAd, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildImpressionAdSlotEvent(context) {
+    return merge(ImpressionAdSlot, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildImpressionAffiliateEvent(context) {
+    return merge(ImpressionAffiliate, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildImpressionFormEvent(context) {
+    return merge(ImpressionForm, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildImpressionOfferEvent(context) {
+    return merge(ImpressionOffer, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildImpressionPlayerEvent(context) {
+    return merge(ImpressionPlayer, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildImpressionSportsUIElementEvent(context) {
+    return merge(ImpressionSportsUIElement, getSportsElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildImpressionSchoolUIElementEvent(context) {
+    return merge(ImpressionSchoolUIElement, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildImpressionTeaserEvent(context) {
+    return merge(ImpressionTeaser, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildImpressionUIElementEvent(context) {
+    return merge(ImpressionUIElement, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+export function buildImpressionWidgetEvent(context) {
+    return merge(ImpressionWidget, getElementEventBuildersOutput(context), normalizePageInput(context.input));
+}
+// #endregion
+// #region Ad Lifecycle Event Builders
+export function buildLoadAdEvent(context) {
+    return merge(LoadAd, getCommonBuildersOutput(context), normalizePageInput(context.input));
+}
+// #endregion

package/dist/ejs/tpaas-builders/guards.js

@@ -0,0 +1,4 @@
+import { PAGE_TYPE_VALUES } from '../tpaas-schemas';
+export function isPageType(pageType) {
+    return PAGE_TYPE_VALUES.some((val) => val === pageType);
+}

package/dist/ejs/tpaas-builders/index.js

@@ -0,0 +1,2 @@
+export * from './builders';
+export { isPageType } from './guards';

package/dist/ejs/tpaas-context/adapters.js

@@ -0,0 +1,80 @@
+import { generateExperimentSDRN } from '../builders/experiments';
+import { isString } from '../utils';
+/**
+ * Adapts the legacy actor input to the TPaaS user format.
+ *
+ * @privateRemarks
+ * This is a temporary solution to adapt the actor to the new format.
+ * It should be removed once we have new methods in place to get the actor.
+ *
+ * @private
+ */
+export function adaptActorToNewFormat(actor) {
+    if (!actor) {
+        return;
+    }
+    return {
+        id: actor.id?.toString() || '',
+        realm: actor.realm || '',
+        hasAnySubscription: !!actor.hasAnySubscription,
+        region: isString(actor.region) ? actor.region : undefined,
+    };
+}
+function adaptStatusOrOptIn({ status, optIn }) {
+    // doing an unnecessary check for status here
+    // because otherwise the code after the switch will be marked as unreachable in the IDE
+    if (status) {
+        switch (status) {
+            case 'accepted':
+                return 'Accepted';
+            case 'rejected':
+                return 'Rejected';
+            case 'unknown':
+                return 'Unknown';
+        }
+    }
+    if (optIn === true) {
+        return 'Accepted';
+    }
+    if (optIn === false) {
+        return 'Rejected';
+    }
+    return 'Unknown';
+}
+/**
+ * Adapts the legacy consents to the TPaaS consents format.
+ *
+ * @private
+ */
+export function adaptConsentsToNewFormat(consents) {
+    if (!consents) {
+        return;
+    }
+    const { purposes, source } = consents;
+    const { CMP_ADVERTISING, CMP_ANALYTICS, CMP_MARKETING, CMP_PERSONALIZATION } = purposes;
+    return {
+        advertising: adaptStatusOrOptIn(CMP_ADVERTISING),
+        analytics: adaptStatusOrOptIn(CMP_ANALYTICS),
+        marketing: adaptStatusOrOptIn(CMP_MARKETING),
+        personalization: adaptStatusOrOptIn(CMP_PERSONALIZATION),
+        source: source || 'unknown',
+    };
+}
+/**
+ * Adapts the base experiments stored in the tracker to the TPaaS experiments format.
+ *
+ * @private
+ */
+export function adaptExperiments(baseExperiments = []) {
+    return baseExperiments.map((exp) => {
+        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,
+        };
+    });
+}

package/dist/ejs/tpaas-context/browser.js

@@ -0,0 +1,47 @@
+import { isBrowser } from '../utils';
+/**
+ * Reads the browser state that can change between events, such as the URL after an SPA navigation
+ * or the viewport after a resize. Call it synchronously, when the event is tracked.
+ *
+ * @private
+ */
+export const captureBrowserContext = () => {
+    if (!isBrowser) {
+        return {
+            url: undefined,
+            search: '',
+            screenOrientationType: undefined,
+            viewportWidth: 0,
+            viewportHeight: 0,
+            userAgent: undefined,
+        };
+    }
+    const { viewportWidth, viewportHeight } = getViewportDimensions();
+    return {
+        url: window.location.href,
+        search: window.location.search ?? '',
+        screenOrientationType: window.screen.orientation?.type,
+        viewportWidth,
+        viewportHeight,
+        userAgent: window.navigator.userAgent,
+    };
+};
+function getViewportDimensions() {
+    let viewportWidth;
+    let viewportHeight;
+    const { document } = window;
+    if (typeof window.innerWidth !== 'undefined') {
+        viewportWidth = window.innerWidth;
+        viewportHeight = window.innerHeight;
+    }
+    else if (typeof document.documentElement.clientWidth !== 'undefined' &&
+        document.documentElement.clientWidth !== 0) {
+        viewportWidth = document.documentElement.clientWidth;
+        viewportHeight = document.documentElement.clientHeight;
+    }
+    else {
+        viewportWidth = document.getElementsByTagName('body')[0].clientWidth;
+        viewportHeight = document.getElementsByTagName('body')[0].clientHeight;
+    }
+    return { viewportWidth, viewportHeight };
+}

package/dist/ejs/tpaas-context/index.js

@@ -0,0 +1 @@
+export { prepareAnonymousTpaasEventContext, prepareTpaasEventContext } from './prepare';

package/dist/ejs/tpaas-context/prepare.js

@@ -0,0 +1,137 @@
+import logger from 'loglevel';
+import { parsePulseCookies } from '../cis-sync';
+import * as identity from '../identity';
+import { SDK_VERSION } from '../version';
+import { mapPageToPageRef } from '../wrapper/utils/map-page-to-page-ref';
+import { adaptActorToNewFormat, adaptConsentsToNewFormat, adaptExperiments } from './adapters';
+import { captureBrowserContext } from './browser';
+import { resolveSession } from './session';
+// 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';
+    }
+};
+/**
+ * The context fields derived from the tracker state, shared by all TPaaS events.
+ */
+const getStateContext = (state) => ({
+    version: SDK_VERSION,
+    isHybrid: !!state.isHybrid,
+    pageviewId: state.pageViewId,
+    providerId: state.providerId,
+    providerName: state.provider?.name,
+    providerGroup: state.provider?.group,
+    providerStage: state.stage,
+    providerProduct: state.product,
+    providerVersion: state.version,
+    component: state.component,
+    componentVersion: state.componentVersion,
+    routingStage: mapDeployStageToTpaasStage(state.deployStageTpaas),
+});
+/**
+ * Deep copies the tracking input, so a caller that reuses and changes the same input object afterwards
+ * cannot change an event that is still being prepared. When the input cannot be copied, it is used as it is.
+ */
+const copyInput = (input) => {
+    try {
+        return structuredClone(input);
+    }
+    catch (ex) {
+        // older browsers, or inputs with values that cannot be cloned (functions, Promises, framework proxies)
+        logger.debug('Could not copy the tracking input, using it as is', ex);
+        return input;
+    }
+};
+const getPageRef = async (pageInfo) => {
+    const { id, type, url } = await pageInfo;
+    return mapPageToPageRef(id, type, url);
+};
+/**
+ * Resolves the context of an anonymous TPaaS event.
+ * Callers specify the event schema because it cannot be inferred from `InputParams<I>`.
+ *
+ * @private
+ */
+export async function prepareAnonymousTpaasEventContext(source, input) {
+    // Read everything before any asynchronous work, so the context reflects the moment the event
+    // was tracked and a later update or View event cannot change it.
+    const createdAt = new Date();
+    const eventInput = copyInput(input);
+    const browser = captureBrowserContext();
+    const stateContext = getStateContext(source.state);
+    const experiments = source.builders.experiments;
+    const { referrer } = source.currentPage;
+    try {
+        await source.applyRemoteConfig();
+    }
+    catch (ex) {
+        logger.trace('Failed to sync remote config', ex);
+    }
+    return {
+        input: eventInput,
+        createdAt,
+        browser,
+        ...stateContext,
+        experiments: adaptExperiments(experiments),
+        currentPageReferrer: await referrer,
+    };
+}
+/**
+ * Resolves the context of a TPaaS event.
+ * Callers specify the event schema because it cannot be inferred from `InputParams<I>`.
+ *
+ * @private
+ */
+export async function prepareTpaasEventContext(source, input) {
+    // Read everything before any asynchronous work, so the context reflects the moment the event
+    // was tracked and a later update or View event cannot change it.
+    // The session is resolved here too, so sessions are updated in the order events are tracked.
+    const createdAt = new Date();
+    const eventInput = copyInput(input);
+    const session = resolveSession(createdAt);
+    const browser = captureBrowserContext();
+    const stateContext = getStateContext(source.state);
+    const builders = { ...source.builders };
+    const { info, content, sports, referrer } = source.currentPage;
+    // Session listeners run synchronously and may update the tracker or start another View.
+    // Notify them only after this event's context has been captured.
+    source.onSessionResolved();
+    try {
+        await source.syncRemoteResources(builders);
+    }
+    catch (ex) {
+        logger.trace('Failed to sync remote resources', ex);
+        // remote config and CIS failures are also ignored for the old track() method. doing the same here
+    }
+    // Consents are intentionally not read upfront. Read them after remote synchronization
+    // so a blocking tracking call can use newly resolved consents.
+    const [actor, consents, currentPage, currentPageReferrer] = await Promise.all([
+        identity.getActor(builders),
+        source.getConsents(),
+        getPageRef(info),
+        referrer,
+    ]);
+    const { environmentId, jwe } = parsePulseCookies();
+    return {
+        input: eventInput,
+        createdAt,
+        session,
+        browser,
+        ...stateContext,
+        user: adaptActorToNewFormat(actor),
+        consents: adaptConsentsToNewFormat(consents),
+        experiments: adaptExperiments(builders.experiments),
+        currentPage,
+        currentPageContent: content,
+        currentPageSports: sports,
+        currentPageReferrer,
+        environmentId,
+        jwe,
+    };
+}

package/dist/ejs/tpaas-context/session.js

@@ -0,0 +1,19 @@
+import { touchSession } from '../session/store';
+import { getXDomainId } from '../utils';
+/**
+ * Registers an event created at `createdAt` in the stored session and returns it in the TPaaS format.
+ *
+ * Call it synchronously, together with capturing `createdAt`, before any asynchronous work.
+ * Sessions are then updated in the order events are tracked, which is also their creation order.
+ *
+ * @private
+ */
+export const resolveSession = (createdAt) => {
+    const { sessionId, startTime, isFirstEvent } = touchSession(createdAt);
+    return {
+        isFirstEvent,
+        sessionId,
+        startTime: startTime.toISOString(),
+        xDomainId: getXDomainId(),
+    };
+};