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

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

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareAnonymousTpaasEventContext = prepareAnonymousTpaasEventContext;
+exports.prepareTpaasEventContext = prepareTpaasEventContext;
+const loglevel_1 = __importDefault(require("loglevel"));
+const cis_sync_1 = require("../cis-sync");
+const identity = __importStar(require("../identity"));
+const version_1 = require("../version");
+const map_page_to_page_ref_1 = require("../wrapper/utils/map-page-to-page-ref");
+const adapters_1 = require("./adapters");
+const browser_1 = require("./browser");
+const session_1 = require("./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: version_1.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)
+        loglevel_1.default.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 (0, map_page_to_page_ref_1.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
+ */
+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 = (0, browser_1.captureBrowserContext)();
+    const stateContext = getStateContext(source.state);
+    const experiments = source.builders.experiments;
+    const { referrer } = source.currentPage;
+    try {
+        await source.applyRemoteConfig();
+    }
+    catch (ex) {
+        loglevel_1.default.trace('Failed to sync remote config', ex);
+    }
+    return {
+        input: eventInput,
+        createdAt,
+        browser,
+        ...stateContext,
+        experiments: (0, adapters_1.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
+ */
+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 = (0, session_1.resolveSession)(createdAt);
+    const browser = (0, browser_1.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) {
+        loglevel_1.default.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 } = (0, cis_sync_1.parsePulseCookies)();
+    return {
+        input: eventInput,
+        createdAt,
+        session,
+        browser,
+        ...stateContext,
+        user: (0, adapters_1.adaptActorToNewFormat)(actor),
+        consents: (0, adapters_1.adaptConsentsToNewFormat)(consents),
+        experiments: (0, adapters_1.adaptExperiments)(builders.experiments),
+        currentPage,
+        currentPageContent: content,
+        currentPageSports: sports,
+        currentPageReferrer,
+        environmentId,
+        jwe,
+    };
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSession = void 0;
+const store_1 = require("../session/store");
+const utils_1 = require("../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
+ */
+const resolveSession = (createdAt) => {
+    const { sessionId, startTime, isFirstEvent } = (0, store_1.touchSession)(createdAt);
+    return {
+        isFirstEvent,
+        sessionId,
+        startTime: startTime.toISOString(),
+        xDomainId: (0, utils_1.getXDomainId)(),
+    };
+};
+exports.resolveSession = resolveSession;