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

package/{node_modules/@schibsted/tpaas-event-builder/dist/cjs → dist/cjs/tpaas-builders}/index.js

@@ -14,4 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPageType = void 0;
 __exportStar(require("./builders"), exports);
+var guards_1 = require("./guards");
+Object.defineProperty(exports, "isPageType", { enumerable: true, get: function () { return guards_1.isPageType; } });

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptActorToNewFormat = adaptActorToNewFormat;
+exports.adaptConsentsToNewFormat = adaptConsentsToNewFormat;
+exports.adaptExperiments = adaptExperiments;
+const experiments_1 = require("../builders/experiments");
+const utils_1 = require("../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
+ */
+function adaptActorToNewFormat(actor) {
+    if (!actor) {
+        return;
+    }
+    return {
+        id: actor.id?.toString() || '',
+        realm: actor.realm || '',
+        hasAnySubscription: !!actor.hasAnySubscription,
+        region: (0, utils_1.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
+ */
+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
+ */
+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 : (0, experiments_1.generateExperimentSDRN)(exp.id, exp.platform),
+            platform: exp.platform || '',
+            testId: exp.custom?.testId,
+        };
+    });
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureBrowserContext = void 0;
+const utils_1 = require("../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
+ */
+const captureBrowserContext = () => {
+    if (!utils_1.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,
+    };
+};
+exports.captureBrowserContext = captureBrowserContext;
+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/cjs/tpaas-context/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareTpaasEventContext = exports.prepareAnonymousTpaasEventContext = void 0;
+var prepare_1 = require("./prepare");
+Object.defineProperty(exports, "prepareAnonymousTpaasEventContext", { enumerable: true, get: function () { return prepare_1.prepareAnonymousTpaasEventContext; } });
+Object.defineProperty(exports, "prepareTpaasEventContext", { enumerable: true, get: function () { return prepare_1.prepareTpaasEventContext; } });

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;

package/{node_modules/@schibsted/pulse-cis-sync/dist/cjs → dist/cjs/tpaas-context}/types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map