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

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

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const Tracker_1 = __importDefault(require("./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_1.default('test-site', {});
+(0, vitest_1.describe)('Type tests for Tracker', () => {
+    (0, vitest_1.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,
+                }),
+            },
+        });
+    });
+    (0, vitest_1.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/cjs/app-integration.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultNativeJwe = getDefaultNativeJwe;
+exports.getDefaultAltHandler = getDefaultAltHandler;
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+const loglevel_1 = __importDefault(require("loglevel"));
+function getDefaultNativeJwe(config) {
+    if (config.nativeJwe) {
+        loglevel_1.default.debug('Using nativeJwe from config');
+        return config.nativeJwe;
+    }
+    if (!pulse_utils_1.isBrowser) {
+        return;
+    }
+    if (!window.__nativeJwe__ && !window.hermesJwe) {
+        loglevel_1.default.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;
+}
+function getDefaultAltHandler(config) {
+    if (config.altEventHandler) {
+        loglevel_1.default.debug('Using altEventHandler from config');
+        return config.altEventHandler;
+    }
+    if (!pulse_utils_1.isBrowser) {
+        return;
+    }
+    if (!window.pulseEventHandler) {
+        loglevel_1.default.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/cjs/builders/actor.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultValue = void 0;
+exports.generateActorSDRN = generateActorSDRN;
+exports.isActorInput = isActorInput;
+exports.default = actor;
+const pulse_utils_1 = require("@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
+ */
+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
+ */
+function isActorInput(input) {
+    // biome-ignore lint/suspicious/noPrototypeBuiltins: Object.hasOwn is not available in ES2020
+    return (0, pulse_utils_1.isPlainObject)(input) && Object.prototype.hasOwnProperty.call(input, 'actor');
+}
+function formatActorInput(input) {
+    if ((0, pulse_utils_1.isString)(input)) {
+        return { id: input };
+    }
+    const { id, realm, ...rest } = input || {};
+    return { id, realm, ...rest };
+}
+/**
+ * Function to generate a builder for Actor objects.
+ */
+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
+ */
+const defaultValue = () => undefined;
+exports.defaultValue = defaultValue;

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

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConsentsWaitForAnalytics = exports.consentManager = void 0;
+exports.getFallbackConsents = getFallbackConsents;
+const loglevel_1 = __importDefault(require("loglevel"));
+const consents_1 = require("./consents");
+/**
+ * Fallback if TCF fails to initialize
+ * These should always be "unknown" since we don't know the user's choice
+ * @returns
+ */
+function getFallbackConsents() {
+    return {
+        purposes: {
+            [consents_1.ConsentsCategory.CMP_ADVERTISING]: {
+                optIn: false,
+                status: 'unknown',
+            },
+            [consents_1.ConsentsCategory.CMP_ANALYTICS]: {
+                optIn: false,
+                status: 'unknown',
+            },
+            [consents_1.ConsentsCategory.CMP_MARKETING]: {
+                optIn: false,
+                status: 'unknown',
+            },
+            [consents_1.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();
+ */
+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(() => {
+                loglevel_1.default.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) {
+                    loglevel_1.default.error('Pulse - consentManager triggered after timeout');
+                    return;
+                }
+                clearTimeout(timeoutForManager);
+                resolve(getManager());
+            }, {
+                once: true,
+            });
+        }
+    });
+};
+exports.consentManager = consentManager;
+/**
+ * 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();
+ */
+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;
+};
+exports.getConsentsWaitForAnalytics = getConsentsWaitForAnalytics;
+const subscribeToConsentUpdates = async (callback) => {
+    let manager;
+    try {
+        manager = await (0, exports.consentManager)();
+    }
+    catch (error) {
+        loglevel_1.default.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();
+        loglevel_1.default.debug('CMP:subscribeToConsentUpdates:subscribeAny - resolved after user replied to consent dialog', consents);
+        callback(consents);
+    });
+};
+const getInitialConsentsFromTCF = async () => {
+    let manager;
+    try {
+        manager = await (0, exports.consentManager)();
+    }
+    catch (error) {
+        loglevel_1.default.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(() => {
+                loglevel_1.default.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.
+    loglevel_1.default.debug('CMP:getConsentsWaitForAnalytics - resolved immediately');
+    return manager.getCachedOrDefaultConsentsForPulse();
+};

package/dist/cjs/builders/consents.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsentsPurposeCategoryStatusValues = exports.ConsentsSourceValues = exports.ConsentsCategory = void 0;
+exports.applyAdvertisingConsent = applyAdvertisingConsent;
+exports.applyAdvertisingConsentSync = applyAdvertisingConsentSync;
+exports.resolveIncludeAdvertising = resolveIncludeAdvertising;
+exports.resolveIncludeAdvertisingSync = resolveIncludeAdvertisingSync;
+exports.default = consents;
+const pulse_cis_sync_1 = require("@schibsted/pulse-cis-sync");
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+const warnOnce_1 = __importDefault(require("../warnOnce"));
+const consent_manager_1 = require("./consent-manager");
+/**
+ * @enum ConsentCategory
+ */
+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 || (exports.ConsentsCategory = ConsentsCategory = {}));
+exports.ConsentsSourceValues = ['default', 'cmp', 'cache'];
+exports.ConsentsPurposeCategoryStatusValues = ['accepted', 'rejected', 'unknown'];
+const isLegacyConsentsPurpose = (consentsPurposeCategory) => {
+    return !consentsPurposeCategory?.status;
+};
+const isLegacyConsents = (consents) => {
+    return !!(consents &&
+        !(0, pulse_utils_1.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
+ */
+async function applyAdvertisingConsent(consents, requireAdvertisingOptIn) {
+    if (!consents && typeof requireAdvertisingOptIn !== 'undefined' && requireAdvertisingOptIn !== undefined) {
+        (0, warnOnce_1.default)('NO_CONSENT_IN_CONFIG', NO_CONSENT_IN_CONFIG);
+    }
+    const includeAdvertising = await resolveIncludeAdvertising(consents, requireAdvertisingOptIn);
+    if (!includeAdvertising) {
+        (0, pulse_cis_sync_1.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
+ */
+function applyAdvertisingConsentSync(consents, requireAdvertisingOptIn) {
+    if (!consents && typeof requireAdvertisingOptIn !== 'undefined' && requireAdvertisingOptIn !== undefined) {
+        (0, warnOnce_1.default)('NO_CONSENT_IN_CONFIG', NO_CONSENT_IN_CONFIG);
+    }
+    const includeAdvertising = resolveIncludeAdvertisingSync(consents, requireAdvertisingOptIn);
+    if (!includeAdvertising) {
+        (0, pulse_cis_sync_1.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
+ */
+async function resolveIncludeAdvertising(consents, requireAdvertisingOptIn) {
+    const resolvedRequireAdvertisingOptIn = await requireAdvertisingOptIn;
+    if (!resolvedRequireAdvertisingOptIn) {
+        return true;
+    }
+    if ((0, pulse_utils_1.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
+ */
+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
+ */
+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 = (0, consent_manager_1.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/cjs/builders/device-browser.js

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

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultValue = exports.device = void 0;
+exports.generateEnvironmentSDRN = generateEnvironmentSDRN;
+const pulse_utils_1 = require("@schibsted/pulse-utils");
+/**
+ * Generate a well-formed environment SDRN from an ID
+ * @param id
+ * @internal
+ */
+function generateEnvironmentSDRN(id) {
+    return `sdrn:schibsted:environment:${id}`;
+}
+function formatDeviceInput(input) {
+    if ((0, pulse_utils_1.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
+ */
+const device = (defaultValueHandler) => (input) => {
+    const { device: deviceInput } = input || {};
+    if (!deviceInput) {
+        return undefined;
+    }
+    const formattedInput = (0, pulse_utils_1.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);
+};
+exports.device = device;
+/**
+ * @internal
+ */
+const defaultValue = () => ({});
+exports.defaultValue = defaultValue;
+/**
+ * Builder for Device objects.
+ */
+exports.default = (0, exports.device)(exports.defaultValue);

package/dist/cjs/builders/device.js

@@ -0,0 +1,23 @@
+"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 __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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+__exportStar(require("./device-node"), exports);
+var device_node_1 = require("./device-node");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(device_node_1).default; } });

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anonymousTrackerEvent = exports.anonymousEngagementEvent = void 0;
+var events_anonymous_node_1 = require("./events-anonymous-node");
+Object.defineProperty(exports, "anonymousEngagementEvent", { enumerable: true, get: function () { return events_anonymous_node_1.anonymousEngagementEvent; } });
+Object.defineProperty(exports, "anonymousTrackerEvent", { enumerable: true, get: function () { return events_anonymous_node_1.anonymousTrackerEvent; } });