@schibsted/pulse-sdk 8.0.0-alpha.16 → 8.0.0-alpha.18

package/dist/ejs/Tracker.test-d.js

@@ -0,0 +1,71 @@
+import { describe, it } from 'vitest';
+import Tracker from './Tracker';
+const ARTICLE_PAYLOAD = {
+    experiments: [
+        {
+            name: 'test-experiment',
+            variant: 'test-variant',
+        },
+    ],
+    object: {
+        category: 'abcd',
+        objectId: 'page-123',
+        objectSdrn: 'sdrn:the-standard:page:page-123',
+        tags: ['tag1', 'tag2'],
+        title: 'Test Page',
+    },
+    metrics: [
+        {
+            key: 'topKScore',
+            name: 'topKScore',
+            source: 'Curate',
+            value: 0,
+        },
+    ],
+    page: {
+        navigationType: 'Navigate',
+        referrer: {
+            pageId: 'referrer-page',
+            pageType: 'Article',
+        },
+    },
+    provider: {
+        component: 'test-component',
+        componentVersion: '1.0.0',
+        product: 'test-product',
+        stage: 'Dev',
+        version: '1.0.0',
+    },
+};
+const tracker = new Tracker('test-site', {});
+describe('Type tests for Tracker', () => {
+    it('should compile without errors', () => {
+        tracker.trackViewPage(ARTICLE_PAYLOAD, { leaveTracking: false });
+        tracker.trackViewPage(ARTICLE_PAYLOAD, {
+            leaveTracking: {
+                objectElement: document.body,
+            },
+        });
+        tracker.trackViewPage(ARTICLE_PAYLOAD, {
+            leaveTracking: {
+                objectElement: document.body,
+                pageElement: document.documentElement,
+                objectResizable: true,
+                heightBuilder: () => ({
+                    totalHeight: 0,
+                    viewedHeight: 0,
+                }),
+            },
+        });
+    });
+    it('expects errors because invalid API calls', () => {
+        tracker.trackViewPage(ARTICLE_PAYLOAD, {
+            // @ts-expect-error we expect an error here because leaveTracking shouldn't be passed as true
+            leaveTracking: true,
+        });
+        // @ts-expect-error we expect an error here because we're missing the second parameter (options)
+        tracker.trackViewPage(ARTICLE_PAYLOAD);
+        // @ts-expect-error we expect an error here because we're mising leaveTracking options
+        tracker.trackViewPage(ARTICLE_PAYLOAD, {});
+    });
+});

package/dist/ejs/app-integration.js

@@ -0,0 +1,33 @@
+import { isBrowser } from '@schibsted/pulse-utils';
+import logger from 'loglevel';
+export function getDefaultNativeJwe(config) {
+    if (config.nativeJwe) {
+        logger.debug('Using nativeJwe from config');
+        return config.nativeJwe;
+    }
+    if (!isBrowser) {
+        return;
+    }
+    if (!window.__nativeJwe__ && !window.hermesJwe) {
+        logger.debug('No __nativeJwe__ or hermesJwe found in window');
+        return;
+    }
+    // Special support for Hybrid apps, using Pulse tracking and/or ad identifiers within a webview
+    return window.__nativeJwe__ || window.hermesJwe;
+}
+export function getDefaultAltHandler(config) {
+    if (config.altEventHandler) {
+        logger.debug('Using altEventHandler from config');
+        return config.altEventHandler;
+    }
+    if (!isBrowser) {
+        return;
+    }
+    if (!window.pulseEventHandler) {
+        logger.debug('No pulseEventHandler found in window');
+        return;
+    }
+    // If the pulse event handler is set, e.g. by a native app in
+    // a hybrid app setup, we pick that as the 'altEventHandler'
+    return window.pulseEventHandler;
+}

package/dist/ejs/builders/actor.js

@@ -0,0 +1,53 @@
+import { isPlainObject, isString } from '@schibsted/pulse-utils';
+/**
+ * generateActorSDRN
+ * Generates a well-formed sdrn for an actor, based on id, realm inputs
+ * @param id String
+ * @param realm String Realm is not required, so, without a fully formed "@id" in the actors input object, the "realm"
+ * part of the sdrn is flagged with "__REALM_NOT_SET__", for early noticing implementation/integration errors.
+ * @internal
+ */
+export function generateActorSDRN(id, realm = '__REALM_NOT_SET__') {
+    const outputId = id || '__USER_ID_NOT_SET__';
+    return `sdrn:${realm}:user:${outputId}`;
+}
+/**
+ * Type guard to check if the input is an ActorInput
+ * @param input
+ * @internal
+ */
+export function isActorInput(input) {
+    // biome-ignore lint/suspicious/noPrototypeBuiltins: Object.hasOwn is not available in ES2020
+    return isPlainObject(input) && Object.prototype.hasOwnProperty.call(input, 'actor');
+}
+function formatActorInput(input) {
+    if (isString(input)) {
+        return { id: input };
+    }
+    const { id, realm, ...rest } = input || {};
+    return { id, realm, ...rest };
+}
+/**
+ * Function to generate a builder for Actor objects.
+ */
+export default function actor(input) {
+    const { actor: actorInput } = input || {};
+    if (!actorInput) {
+        return undefined;
+    }
+    const { id, realm, ...inputProps } = formatActorInput(actorInput);
+    // TODO: think in ways that a well-formed SDRN passed as @id in the input can render the "id" not necessary anymore.
+    if (!id) {
+        return undefined;
+    }
+    const actorSDRN = generateActorSDRN(id, realm);
+    const baseActor = {
+        '@id': actorSDRN,
+        'spt:userId': actorSDRN,
+    };
+    return Object.assign(baseActor, inputProps);
+}
+/**
+ * @internal
+ */
+export const defaultValue = () => undefined;

package/dist/ejs/builders/consent-manager.js

@@ -0,0 +1,125 @@
+import logger from 'loglevel';
+import { ConsentsCategory } from './consents';
+/**
+ * Fallback if TCF fails to initialize
+ * These should always be "unknown" since we don't know the user's choice
+ * @returns
+ */
+export function getFallbackConsents() {
+    return {
+        purposes: {
+            [ConsentsCategory.CMP_ADVERTISING]: {
+                optIn: false,
+                status: 'unknown',
+            },
+            [ConsentsCategory.CMP_ANALYTICS]: {
+                optIn: false,
+                status: 'unknown',
+            },
+            [ConsentsCategory.CMP_MARKETING]: {
+                optIn: false,
+                status: 'unknown',
+            },
+            [ConsentsCategory.CMP_PERSONALIZATION]: {
+                optIn: false,
+                status: 'unknown',
+            },
+        },
+        source: 'default',
+    };
+}
+/**
+ * Returns the consent manager (`_tcf_`), if available.
+ * It will await "cmp:loaded" event if the consent manager is not available yet and return it when it is.
+ * @returns The consent manager object.
+ * @example
+ * const manager = await consentManager();
+ */
+export const consentManager = () => {
+    // For ConsentManager/window._tcf_ type, either duck type something yourself for now or wait for better types to be exposed from sourcepoint package.
+    const getManager = () => window._tcf_;
+    return new Promise((resolve, reject) => {
+        const manager = getManager();
+        if (manager) {
+            resolve(manager);
+        }
+        else {
+            let hasTimedOut = false;
+            const timeoutForManager = setTimeout(() => {
+                logger.error('Pulse - timed out waiting for consentManager');
+                hasTimedOut = true;
+                reject(new Error('Pulse - timed out waiting for consentManager'));
+            }, 5000);
+            document.addEventListener('cmp:loaded', () => {
+                if (hasTimedOut) {
+                    logger.error('Pulse - consentManager triggered after timeout');
+                    return;
+                }
+                clearTimeout(timeoutForManager);
+                resolve(getManager());
+            }, {
+                once: true,
+            });
+        }
+    });
+};
+/**
+ * Waits for user to reply to consents, then retrieves the cached or default consents for Pulse from the consent manager.
+ * Only needed if you want to wait for user to respond to consents rather than sending events with default consent
+ * WARNING: Do not use this without analytics consent being activated in TCF or it will never resolve for users without cached consents!
+ * @returns A promise with the cached or default consents for Pulse.
+ * @example
+ * const getConsentsWaitForAnalyticsPromise = getConsentsWaitForAnalytics();
+ */
+export const getConsentsWaitForAnalytics = async (callback) => {
+    const consents = await getInitialConsentsFromTCF();
+    // no need to subscribe if we don't receive a callback to call
+    if (callback) {
+        await subscribeToConsentUpdates(callback);
+    }
+    return consents;
+};
+const subscribeToConsentUpdates = async (callback) => {
+    let manager;
+    try {
+        manager = await consentManager();
+    }
+    catch (error) {
+        logger.error('Unable to subscribe as tcf manager is not initialized', error);
+        // If we can't get the consent manager, we can't subscribe to updates
+        return;
+    }
+    manager.subscribeAny(() => {
+        const consents = manager.getCachedOrDefaultConsentsForPulse();
+        logger.debug('CMP:subscribeToConsentUpdates:subscribeAny - resolved after user replied to consent dialog', consents);
+        callback(consents);
+    });
+};
+const getInitialConsentsFromTCF = async () => {
+    let manager;
+    try {
+        manager = await consentManager();
+    }
+    catch (error) {
+        logger.error('Failed to get consent manager, using pulse default consents', error);
+        return getFallbackConsents();
+    }
+    // Check if analytics consent exists in cache.
+    const analyticsConsent = manager.getPermissionSync('CMP:analytics');
+    // null analyticsConsent means that the user has not yet replied to the consent dialog.
+    if (analyticsConsent === null) {
+        // Wait for the user to reply to the consent dialog.
+        return new Promise((resolve) => {
+            // Need to use subscribeAny since that is the only one resolving after all consents are properly set initially
+            const unsubscribe = manager.subscribeAny(() => {
+                logger.debug('CMP:getConsentsWaitForAnalytics - resolved after user replied to consent dialog');
+                resolve(manager.getCachedOrDefaultConsentsForPulse());
+                unsubscribe();
+            });
+            return;
+        });
+    }
+    // If we have consent in cache or do not need to wait, return the consents immediately.
+    logger.debug('CMP:getConsentsWaitForAnalytics - resolved immediately');
+    return manager.getCachedOrDefaultConsentsForPulse();
+};

package/dist/ejs/builders/consents.js

@@ -0,0 +1,138 @@
+import { clearCookieAdvertisingIds } from '@schibsted/pulse-cis-sync';
+import { isPromise } from '@schibsted/pulse-utils';
+import warnOnce from '../warnOnce';
+import { getFallbackConsents } from './consent-manager';
+/**
+ * @enum ConsentCategory
+ */
+export var ConsentsCategory;
+(function (ConsentsCategory) {
+    ConsentsCategory["CMP_ANALYTICS"] = "CMP_ANALYTICS";
+    ConsentsCategory["CMP_MARKETING"] = "CMP_MARKETING";
+    ConsentsCategory["CMP_ADVERTISING"] = "CMP_ADVERTISING";
+    ConsentsCategory["CMP_PERSONALIZATION"] = "CMP_PERSONALIZATION";
+})(ConsentsCategory || (ConsentsCategory = {}));
+export const ConsentsSourceValues = ['default', 'cmp', 'cache'];
+export const ConsentsPurposeCategoryStatusValues = ['accepted', 'rejected', 'unknown'];
+const isLegacyConsentsPurpose = (consentsPurposeCategory) => {
+    return !consentsPurposeCategory?.status;
+};
+const isLegacyConsents = (consents) => {
+    return !!(consents &&
+        !isPromise(consents) &&
+        consents?.purposes &&
+        Object.values(consents.purposes).every((purpose) => isLegacyConsentsPurpose(purpose)));
+};
+const NO_CONSENT_IN_CONFIG = 'Invalid consents passed to the Pulse SDK. "requireAdvertisingOptIn" and no "consents" config param present.';
+/**
+ *
+ * @param consents
+ * @param requireAdvertisingOptIn
+ * @returns The resolved consents and whether advertising is allowed
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ * @internal
+ */
+export async function applyAdvertisingConsent(consents, requireAdvertisingOptIn) {
+    if (!consents && typeof requireAdvertisingOptIn !== 'undefined' && requireAdvertisingOptIn !== undefined) {
+        warnOnce('NO_CONSENT_IN_CONFIG', NO_CONSENT_IN_CONFIG);
+    }
+    const includeAdvertising = await resolveIncludeAdvertising(consents, requireAdvertisingOptIn);
+    if (!includeAdvertising) {
+        clearCookieAdvertisingIds();
+    }
+    return includeAdvertising;
+}
+/**
+ *
+ * @param consents
+ * @param requireAdvertisingOptIn
+ * @returns The resolved consents and whether advertising is allowed
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ * @internal
+ */
+export function applyAdvertisingConsentSync(consents, requireAdvertisingOptIn) {
+    if (!consents && typeof requireAdvertisingOptIn !== 'undefined' && requireAdvertisingOptIn !== undefined) {
+        warnOnce('NO_CONSENT_IN_CONFIG', NO_CONSENT_IN_CONFIG);
+    }
+    const includeAdvertising = resolveIncludeAdvertisingSync(consents, requireAdvertisingOptIn);
+    if (!includeAdvertising) {
+        clearCookieAdvertisingIds();
+    }
+    return includeAdvertising;
+}
+/**
+ *
+ * @param consents
+ * @param requireAdvertisingOptIn
+ * @returns whether advertising is allowed
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ * @internal
+ */
+export async function resolveIncludeAdvertising(consents, requireAdvertisingOptIn) {
+    const resolvedRequireAdvertisingOptIn = await requireAdvertisingOptIn;
+    if (!resolvedRequireAdvertisingOptIn) {
+        return true;
+    }
+    if (isPromise(consents)) {
+        const resolvedConsents = await consents;
+        return resolvedConsents?.purposes?.[ConsentsCategory.CMP_ADVERTISING]?.status === 'accepted';
+    }
+    if (isLegacyConsents(consents)) {
+        return Boolean(consents?.purposes?.[ConsentsCategory.CMP_ADVERTISING]?.optIn);
+    }
+    return consents?.purposes?.[ConsentsCategory.CMP_ADVERTISING]?.status === 'accepted';
+}
+/**
+ *
+ * @param consents
+ * @param requireAdvertisingOptIn
+ * @returns whether advertising is allowed
+ * @deprecated Advertising Identifiers methods will be removed in the next major version.
+ * @internal
+ */
+export function resolveIncludeAdvertisingSync(consents, requireAdvertisingOptIn) {
+    if (!requireAdvertisingOptIn) {
+        return true;
+    }
+    if (isLegacyConsents(consents)) {
+        return Boolean(consents?.purposes?.[ConsentsCategory.CMP_ADVERTISING]?.optIn);
+    }
+    return consents?.purposes?.[ConsentsCategory.CMP_ADVERTISING]?.status === 'accepted';
+}
+/**
+ * Builds a consents object from input.
+ * @param input
+ */
+export default function consents(input) {
+    const { consents: consentsInput } = input || {};
+    if (!consentsInput) {
+        return undefined;
+    }
+    const purposesInput = consentsInput?.purposes ?? {};
+    return {
+        purposes: purposes(purposesInput),
+        source: consentsInput?.source,
+    };
+}
+/**
+ * This can be removed when we no longer fill purposeInput.optIn: boolean based on status string.
+ * isConsentsPurposes can be used to return an unmodified consent object.
+ * @see https://schibsted.io.atlassian.net/browse/SDP-11907
+ * @internal
+ */
+function purposes(purposesInput) {
+    const purposesOutput = getFallbackConsents().purposes;
+    for (const categoryInput in purposesInput) {
+        const consentCategory = categoryInput;
+        const purposeInput = purposesInput[consentCategory];
+        const isValidCategory = Boolean(purposesOutput[consentCategory]);
+        if (!purposeInput || !isValidCategory) {
+            continue;
+        }
+        if (!isLegacyConsentsPurpose(purposeInput)) {
+            purposeInput.optIn || (purposeInput.optIn = purposeInput.status === 'accepted');
+        }
+        purposesOutput[consentCategory] = purposeInput;
+    }
+    return purposesOutput;
+}

package/dist/ejs/builders/device-browser.js

@@ -0,0 +1,69 @@
+import { parsePulseCookies } from '@schibsted/pulse-cis-sync';
+import { deviceType, isBrowser, isString } from '@schibsted/pulse-utils';
+import { device } from './device-node';
+export * from './device-node';
+function supportsLocalStorage() {
+    try {
+        const { localStorage } = window;
+        localStorage.setItem('pulse4test', 'check');
+        localStorage.removeItem('pulse4test');
+        return true;
+    }
+    catch (_e) {
+        return false;
+    }
+}
+function getViewportDimensions() {
+    if (!isBrowser) {
+        return '';
+    }
+    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}x${viewportHeight}`;
+}
+export function getXEnvironmentId() {
+    if (!isBrowser) {
+        return undefined;
+    }
+    const urlParams = new URLSearchParams(window?.location?.search ?? '');
+    return urlParams.get('x_env_id') || undefined;
+}
+export const defaultValue = () => {
+    if (!isBrowser) {
+        return {};
+    }
+    const { navigator, screen } = window;
+    return {
+        acceptLanguage: navigator.userLanguage || navigator.language,
+        screenSize: `${screen.width}x${screen.height}`,
+        userAgent: navigator.userAgent,
+        deviceType: deviceType(window.navigator.userAgent),
+        viewportSize: getViewportDimensions(),
+        localStorageEnabled: supportsLocalStorage(),
+        xEnvironmentId: getXEnvironmentId(),
+    };
+};
+export default function (input) {
+    const { device: deviceInput } = input || {};
+    const { environmentId, jwe } = parsePulseCookies();
+    const data = {
+        id: environmentId,
+        jweIds: jwe,
+        ...(isString(deviceInput) ? { id: deviceInput } : deviceInput),
+    };
+    return device(defaultValue)({ device: data });
+}

package/dist/ejs/builders/device-node.js

@@ -0,0 +1,57 @@
+import { isString, pulseMerge } from '@schibsted/pulse-utils';
+/**
+ * Generate a well-formed environment SDRN from an ID
+ * @param id
+ * @internal
+ */
+export function generateEnvironmentSDRN(id) {
+    return `sdrn:schibsted:environment:${id}`;
+}
+function formatDeviceInput(input) {
+    if (isString(input)) {
+        return { id: input };
+    }
+    const { id, ...rest } = input || {};
+    return { id, ...rest };
+}
+/**
+ * Generate a device representation
+ *
+ * Several default values are used in a browser environment: acceptLanguage,
+ * screenSize, userAgent, deviceType, viewportSize, localStorageEnabled. See
+ * (device-browser.js)[device-browser.js] for implementation details.
+ *
+ * The browser implementation will also read the required values from the
+ * `_pulse2cookie` and if needed sync with CIS. Note that *this is not
+ * implemented for Node.js environments*. There are no default values in
+ * Node.js.
+ *
+ * @internal
+ */
+export const device = (defaultValueHandler) => (input) => {
+    const { device: deviceInput } = input || {};
+    if (!deviceInput) {
+        return undefined;
+    }
+    const formattedInput = pulseMerge({}, defaultValueHandler(), formatDeviceInput(deviceInput));
+    const { id, additionalIds, ...props } = formattedInput;
+    if (!id) {
+        return undefined;
+    }
+    const baseDevice = {
+        '@type': 'Device',
+        environmentId: generateEnvironmentSDRN(id),
+    };
+    if (additionalIds) {
+        baseDevice.additionalEnvironmentIds = additionalIds.map(generateEnvironmentSDRN);
+    }
+    return Object.assign(baseDevice, props);
+};
+/**
+ * @internal
+ */
+export const defaultValue = () => ({});
+/**
+ * Builder for Device objects.
+ */
+export default device(defaultValue);

package/dist/ejs/builders/device.js

@@ -0,0 +1,2 @@
+export * from './device-node';
+export { default } from './device-node';

package/dist/ejs/builders/events-anonymous-browser.js

@@ -0,0 +1 @@
+export { anonymousEngagementEvent, anonymousTrackerEvent } from './events-anonymous-node';

package/dist/ejs/builders/events-anonymous-node.js

@@ -0,0 +1,48 @@
+import { omit, pulseMerge } from '@schibsted/pulse-utils';
+import consentsBuilder from './consents';
+import { DEFAULT_SCHEMA_LOCATION } from './events-node';
+import experimentMetadataBuilder, { defaultValue as experimentMetadataDefaultValue } from './experimentMetadata';
+import experimentsBuilder, { defaultValue as experimentsDefaultValue } from './experiments';
+import objectBuilder, { defaultValue as objectDefaultValue } from './objects/objects-anonymous';
+import originBuilder, { defaultValue as originDefaultValue } from './origin';
+import providerBuilder, { defaultValue as providerDefaultValue } from './provider';
+import trackerBuilder, { defaultValue as trackerDefaultValue } from './trackerBuilder';
+/**
+ * Add default values to AnonymousTrackerEventInput.
+ */
+function trackerAnonymousEventInput(eventInput) {
+    return pulseMerge({
+        experiments: experimentsDefaultValue(),
+        experimentMetadata: experimentMetadataDefaultValue(),
+        object: objectDefaultValue(),
+        origin: originDefaultValue(),
+        provider: providerDefaultValue(),
+        tracker: trackerDefaultValue(),
+    }, eventInput);
+}
+export function anonymousTrackerEvent({ eventInput, sdkConfig } = {}) {
+    const parentInput = trackerAnonymousEventInput(eventInput);
+    return Object.assign({}, omit(eventInput, ['type']), {
+        '@type': eventInput?.type || 'View',
+        schema: eventInput?.schema ||
+            `http://${sdkConfig?.schemaLocation || DEFAULT_SCHEMA_LOCATION}/events/tracker-event.json/351.json`,
+        consents: consentsBuilder(parentInput),
+        experiments: experimentsBuilder(parentInput),
+        experimentMetadata: experimentMetadataBuilder(parentInput),
+        object: objectBuilder(parentInput),
+        origin: originBuilder(parentInput),
+        provider: providerBuilder(parentInput),
+        target: parentInput.target && objectBuilder(Object.assign({}, parentInput, { object: parentInput.target })),
+        tracker: trackerBuilder(parentInput),
+        isAnonymous: true,
+    });
+}
+anonymousTrackerEvent.defaults = trackerAnonymousEventInput;
+export function anonymousEngagementEvent({ eventInput, sdkConfig } = {}) {
+    return Object.assign(anonymousTrackerEvent({ eventInput, sdkConfig }), {
+        schema: eventInput?.schema ||
+            `http://${sdkConfig?.schemaLocation || DEFAULT_SCHEMA_LOCATION}/events/engagement-event.json/378.json`,
+        '@type': 'Engagement',
+    });
+}
+anonymousEngagementEvent.defaults = trackerAnonymousEventInput;

package/dist/ejs/builders/events-anonymous.js

@@ -0,0 +1 @@
+export * from './events-anonymous-node';

package/dist/ejs/builders/events-browser.js

@@ -0,0 +1 @@
+export { engagementEvent, identityEvent, routableEvent, trackerEvent } from './events-node';