@guardian/commercial-core 0.0.0-beta-20250716121613

package/dist/cjs/event-timer.d.ts

@@ -0,0 +1,103 @@
+import type { ConnectionType } from './types';
+declare const supportsPerformanceAPI: () => boolean;
+interface EventTimerProperties {
+    type?: ConnectionType;
+    downlink?: number;
+    effectiveType?: string;
+    adSlotsInline?: number;
+    adSlotsTotal?: number;
+    /** the height of the page / the viewport height  */
+    pageHeightVH?: number;
+    gpcSignal?: number;
+    /** distance in percentage of viewport height at which ads are lazy loaded */
+    lazyLoadMarginPercent?: number;
+    hasLabsContainer?: boolean;
+    labsUrl?: string;
+    /** Record whether we've detected an ad blocker. This is intentionally
+     * distinct from the property we pass into commercial metrics, and in the
+     * future _could_ be removed in favour of this property */
+    detectedAdBlocker?: boolean;
+    /** Record whether we've shown the adblock as message */
+    didDisplayAdBlockAsk?: boolean;
+    /** creative ID of a video interscroller for video reporting metrics */
+    videoInterscrollerCreativeId?: number | null | undefined;
+    /** percentage progress of video interscroller on page unload */
+    videoInterscrollerPercentageProgress?: number;
+}
+declare class EventTimer {
+    private _marks;
+    private _measures;
+    properties: EventTimerProperties;
+    /**
+     * Initialise the EventTimer class on page.
+     * Returns the singleton instance of the EventTimer class and binds
+     * to window.guardian.commercialTimer. If it's been previously
+     * initialised and bound it returns the original instance
+     * Note: We save to window.guardian.commercialTimer because
+     * different bundles (DCR / DCP) can use commercial, and we want
+     * all timer events saved to a single instance per-page
+     * @returns {EventTimer} Instance of EventTimer
+     */
+    static init(): EventTimer;
+    /**
+     * Just a helper method to access the singleton instance of EventTimer.
+     * Typical use case is EventTimer.get().trigger
+     */
+    static get(): EventTimer;
+    /**
+     * These are marks that are not triggered by commercial but we are interested in
+     * tracking their performance. For example, CMP-related events.
+     **/
+    private get _externalMarks();
+    /**
+     * Returns all performance marks that should be saved as commercial metrics.
+     */
+    get marks(): {
+        name: string;
+        ts: number;
+    }[];
+    /**
+     * Returns all performance measures that should be saved as commercial metrics.
+     */
+    get measures(): {
+        name: string;
+        duration: number;
+    }[];
+    private constructor();
+    /**
+     * Adds a non timer measurement
+     *
+     * @param {string} name - the property's name
+     * @param value - the property's value
+     */
+    setProperty<T extends keyof EventTimerProperties>(name: T, value: EventTimerProperties[T]): void;
+    /**
+     * Creates a new performance mark, and if the mark ends with 'End' it will
+     * create a performance measure between the start and end marks.
+     *
+     * Marks can  be triggered multiple times, but we only save the first
+     * instance of a mark, as things like ad refreshes can trigger the same mark.
+     *
+     * More info on the performance API:
+     * https://developer.mozilla.org/en-US/docs/Web/API/Performance/mark
+     * https://developer.mozilla.org/en-US/docs/Web/API/Performance/measure
+     *
+     * @todo more strict typing for eventName and origin
+     * @param eventName The short name applied to the mark
+     * @param origin - Either 'page' (default) or the name of the slot
+     */
+    mark(eventName: string, origin?: string): void;
+    /**
+     * Creates a performance measure given the name of the end marks.
+     * The start mark is inferred from the end mark.
+     *
+     * @param endMark - The name of the mark that ends the measure
+     **/
+    private measure;
+}
+declare const _: {
+    slotMarks: readonly ["slotReady", "adRenderStart", "prebidStart", "adOnPage", "viewable"];
+    slotMeasures: readonly ["adRender", "defineSlot", "prepareSlot", "prebid", "fetchAd"];
+    trackedSlots: readonly ["top-above-nav", "inline1", "inline2", "fronts-banner-1", "fronts-banner-2"];
+};
+export { EventTimer, _, supportsPerformanceAPI };

package/dist/cjs/event-timer.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportsPerformanceAPI = exports._ = exports.EventTimer = void 0;
+const libs_1 = require("@guardian/libs");
+const supportsPerformanceAPI = () => typeof window !== 'undefined' &&
+    typeof window.performance !== 'undefined' &&
+    typeof window.performance.mark === 'function';
+exports.supportsPerformanceAPI = supportsPerformanceAPI;
+// Events will be logged using the performance API for all slots, but only these slots will be tracked as commercial metrics and sent to the data lake
+const trackedSlots = [
+    'top-above-nav',
+    'inline1',
+    'inline2',
+    'fronts-banner-1',
+    'fronts-banner-2',
+];
+// marks that we want to save as commercial metrics
+const slotMarks = [
+    'slotReady',
+    'adRenderStart',
+    'prebidStart',
+    'adOnPage',
+    'viewable',
+];
+// measures that we want to save as commercial metrics
+const slotMeasures = [
+    'adRender',
+    'defineSlot',
+    'prepareSlot',
+    'prebid',
+    'fetchAd',
+];
+const pageMarks = ['commercialStart', 'commercialModulesLoaded'];
+// measures that we want to save as commercial metrics
+const pageMeasures = ['commercialBoot', 'googletagInit'];
+// all marks, including the measure start and end marks
+const allSlotMarks = [
+    ...slotMarks,
+    ...slotMeasures.map((measure) => `${measure}Start`),
+    ...slotMeasures.map((measure) => `${measure}End`),
+];
+const externalMarks = [
+    'cmp-init',
+    'cmp-ui-displayed',
+    'cmp-got-consent',
+];
+const shouldSave = (name) => {
+    let [origin, type] = name.split('_');
+    if (!type) {
+        type = origin;
+        origin = 'page';
+    }
+    const shouldSaveMark = (trackedSlots.includes(origin) &&
+        slotMarks.includes(type)) ||
+        (origin === 'page' && pageMarks.includes(type));
+    const shouldSaveMeasure = (trackedSlots.includes(origin) &&
+        slotMeasures.includes(type)) ||
+        (origin === 'page' && pageMeasures.includes(type));
+    return shouldSaveMark || shouldSaveMeasure;
+};
+class EventTimer {
+    _marks;
+    _measures;
+    properties;
+    /**
+     * Initialise the EventTimer class on page.
+     * Returns the singleton instance of the EventTimer class and binds
+     * to window.guardian.commercialTimer. If it's been previously
+     * initialised and bound it returns the original instance
+     * Note: We save to window.guardian.commercialTimer because
+     * different bundles (DCR / DCP) can use commercial, and we want
+     * all timer events saved to a single instance per-page
+     * @returns {EventTimer} Instance of EventTimer
+     */
+    static init() {
+        return (window.guardian.commercialTimer ??= new EventTimer());
+    }
+    /**
+     * Just a helper method to access the singleton instance of EventTimer.
+     * Typical use case is EventTimer.get().trigger
+     */
+    static get() {
+        return this.init();
+    }
+    /**
+     * These are marks that are not triggered by commercial but we are interested in
+     * tracking their performance. For example, CMP-related events.
+     **/
+    get _externalMarks() {
+        if (!supportsPerformanceAPI()) {
+            return new Map();
+        }
+        return externalMarks.reduce((map, mark) => {
+            const entries = window.performance.getEntriesByName(mark);
+            if (entries.length && entries[0]) {
+                map.set(mark, entries[0]);
+            }
+            return map;
+        }, new Map());
+    }
+    /**
+     * Returns all performance marks that should be saved as commercial metrics.
+     */
+    get marks() {
+        return [...this._marks, ...this._externalMarks].map(([name, timer]) => ({
+            name,
+            ts: timer.startTime,
+        }));
+    }
+    /**
+     * Returns all performance measures that should be saved as commercial metrics.
+     */
+    get measures() {
+        return [...this._measures].map(([name, measure]) => ({
+            name,
+            duration: measure.duration,
+        }));
+    }
+    constructor() {
+        this._marks = new Map();
+        this._measures = new Map();
+        this.properties = {};
+        if (window.navigator.connection) {
+            this.properties.type = window.navigator.connection.type;
+            this.properties.downlink = window.navigator.connection.downlink;
+            this.properties.effectiveType =
+                window.navigator.connection.effectiveType;
+        }
+    }
+    /**
+     * Adds a non timer measurement
+     *
+     * @param {string} name - the property's name
+     * @param value - the property's value
+     */
+    setProperty(name, value) {
+        this.properties[name] = value;
+    }
+    /**
+     * Creates a new performance mark, and if the mark ends with 'End' it will
+     * create a performance measure between the start and end marks.
+     *
+     * Marks can  be triggered multiple times, but we only save the first
+     * instance of a mark, as things like ad refreshes can trigger the same mark.
+     *
+     * More info on the performance API:
+     * https://developer.mozilla.org/en-US/docs/Web/API/Performance/mark
+     * https://developer.mozilla.org/en-US/docs/Web/API/Performance/measure
+     *
+     * @todo more strict typing for eventName and origin
+     * @param eventName The short name applied to the mark
+     * @param origin - Either 'page' (default) or the name of the slot
+     */
+    mark(eventName, origin = 'page') {
+        let name = eventName;
+        if (allSlotMarks.includes(eventName) && origin !== 'page') {
+            name = `${origin}_${name}`;
+        }
+        if (!!this._marks.get(name) || !supportsPerformanceAPI()) {
+            return;
+        }
+        const mark = window.performance.mark(name);
+        if (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- browser support is patchy
+        typeof mark?.startTime === 'number' &&
+            // we only want to save the marks that are related to certain slots or the page
+            shouldSave(name)) {
+            this._marks.set(name, mark);
+        }
+        if (name.endsWith('End')) {
+            this.measure(name);
+        }
+    }
+    /**
+     * Creates a performance measure given the name of the end marks.
+     * The start mark is inferred from the end mark.
+     *
+     * @param endMark - The name of the mark that ends the measure
+     **/
+    measure(endMark) {
+        const startMark = endMark.replace('End', 'Start');
+        const measureName = endMark.replace('End', '');
+        const startMarkExists = window.performance.getEntriesByName(startMark).length > 0;
+        if (startMarkExists) {
+            try {
+                const measure = window.performance.measure(measureName, startMark, endMark);
+                // we only want to save the measures that are related to certain slots or the page
+                if (measure && shouldSave(measureName)) {
+                    this._measures.set(measureName, measure);
+                }
+            }
+            catch (e) {
+                (0, libs_1.log)('commercial', `error measuring ${measureName}`, e);
+            }
+        }
+    }
+}
+exports.EventTimer = EventTimer;
+const _ = {
+    slotMarks,
+    slotMeasures,
+    trackedSlots,
+};
+exports._ = _;

package/dist/cjs/geo/country-code.d.ts

@@ -0,0 +1,3 @@
+import type { CountryCode } from '@guardian/libs';
+declare const getCountryCode: () => CountryCode;
+export { getCountryCode };

package/dist/cjs/geo/country-code.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCountryCode = void 0;
+const libs_1 = require("@guardian/libs");
+const editionToCountryCodeMap = {
+    UK: 'GB',
+    US: 'US',
+    AU: 'AU',
+};
+const editionToCountryCode = (editionKey = 'UK') => editionToCountryCodeMap[editionKey];
+const countryCookieName = 'GU_geo_country';
+const countryOverrideName = 'gu.geo.override';
+let locale;
+/*
+   This method can be used as a non async way of getting the country code
+   after init has been called. Returning locale should cover all/most
+   of the cases but if a race condition happen or the cookie is not set,
+   we keep fallbacks to cookie or geo from edition.
+*/
+const getCountryCode = () => {
+    const pageEdition = window.guardian.config.page.edition;
+    const maybeCountryOverride = libs_1.storage.local.get(countryOverrideName);
+    const countryOverride = (0, libs_1.isString)(maybeCountryOverride)
+        ? maybeCountryOverride
+        : null;
+    return (locale ??
+        countryOverride ??
+        (0, libs_1.getCookie)({
+            name: countryCookieName,
+            shouldMemoize: true,
+        }) ??
+        editionToCountryCode(pageEdition));
+};
+exports.getCountryCode = getCountryCode;

package/dist/cjs/geo/geo-utils.d.ts

@@ -0,0 +1,11 @@
+export declare const isInUk: () => boolean;
+export declare const isInUsa: () => boolean;
+export declare const isInCanada: () => boolean;
+export declare const isInAustralia: () => boolean;
+export declare const isInNewZealand: () => boolean;
+export declare const isInUsOrCa: () => boolean;
+export declare const isInAuOrNz: () => boolean;
+export declare const isInRow: () => boolean;
+export declare const _: {
+    resetModule: () => void;
+};

package/dist/cjs/geo/geo-utils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._ = exports.isInRow = exports.isInAuOrNz = exports.isInUsOrCa = exports.isInNewZealand = exports.isInAustralia = exports.isInCanada = exports.isInUsa = exports.isInUk = void 0;
+const country_code_1 = require("./country-code");
+// cache the users location so we only have to look it up once
+let geo;
+const currentGeoLocation = () => {
+    geo = geo ?? (0, country_code_1.getCountryCode)();
+    return geo;
+};
+const isInUk = () => currentGeoLocation() === 'GB';
+exports.isInUk = isInUk;
+const isInUsa = () => currentGeoLocation() === 'US';
+exports.isInUsa = isInUsa;
+const isInCanada = () => currentGeoLocation() === 'CA';
+exports.isInCanada = isInCanada;
+const isInAustralia = () => currentGeoLocation() === 'AU';
+exports.isInAustralia = isInAustralia;
+const isInNewZealand = () => currentGeoLocation() === 'NZ';
+exports.isInNewZealand = isInNewZealand;
+const isInUsOrCa = () => (0, exports.isInUsa)() || (0, exports.isInCanada)();
+exports.isInUsOrCa = isInUsOrCa;
+const isInAuOrNz = () => (0, exports.isInAustralia)() || (0, exports.isInNewZealand)();
+exports.isInAuOrNz = isInAuOrNz;
+const isInRow = () => !(0, exports.isInUk)() && !(0, exports.isInUsOrCa)() && !(0, exports.isInAuOrNz)();
+exports.isInRow = isInRow;
+exports._ = {
+    resetModule: () => {
+        geo = undefined;
+    },
+};

package/dist/cjs/geo/get-locale.d.ts

@@ -0,0 +1,8 @@
+import type { CountryCode } from '@guardian/libs';
+export declare const __resetCachedValue: () => void;
+/**
+ * Fetches the user's current location as an ISO 3166-1 alpha-2 string e.g. 'GB', 'AU' etc
+ * Note: This has been copied from guardian-libs and made syncronous by ommiting the call to
+ * the geolocation API
+ */
+export declare const getLocale: () => CountryCode;

package/dist/cjs/geo/get-locale.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocale = exports.__resetCachedValue = void 0;
+const libs_1 = require("@guardian/libs");
+const KEY = 'GU_geo_country';
+const KEY_OVERRIDE = 'gu.geo.override';
+const COUNTRY_REGEX = /^[A-Z]{2}$/;
+// best guess that we have a valid code, without actually shipping the entire list
+const isValidCountryCode = (country) => (0, libs_1.isString)(country) && COUNTRY_REGEX.test(country);
+// we'll cache any successful lookups so we only have to do this once
+let locale;
+const editionToGeolocationMap = {
+    UK: 'GB',
+    US: 'US',
+    AU: 'AU',
+};
+const editionToGeolocation = (editionKey) => editionToGeolocationMap[editionKey];
+// just used for tests
+const __resetCachedValue = () => (locale = undefined);
+exports.__resetCachedValue = __resetCachedValue;
+/**
+ * Fetches the user's current location as an ISO 3166-1 alpha-2 string e.g. 'GB', 'AU' etc
+ * Note: This has been copied from guardian-libs and made syncronous by ommiting the call to
+ * the geolocation API
+ */
+const getLocale = () => {
+    if (locale)
+        return locale;
+    // return overridden geo from localStorage, used for changing geo only for development purposes
+    const geoOverride = libs_1.storage.local.get(KEY_OVERRIDE);
+    if (isValidCountryCode(geoOverride)) {
+        return (locale = geoOverride);
+    }
+    // return locale from cookie if it exists
+    const stored = (0, libs_1.getCookie)({ name: KEY });
+    if (stored && isValidCountryCode(stored)) {
+        return (locale = stored);
+    }
+    // return locale from edition
+    const editionCountryCode = editionToGeolocation(window.guardian.config.page.edition);
+    return (locale = editionCountryCode);
+};
+exports.getLocale = getLocale;

package/dist/cjs/global.d.ts

@@ -0,0 +1,71 @@
+import type { EventTimer } from './event-timer';
+import type { AdBlockers, Apstag, ArticleCounts, ComscoreGlobals, Confiant, Config, DfpEnv, FetchBidResponse, GoogleTagParams, GoogleTrackConversionObject, HeaderNotification, IasPET, NetworkInformation, NSdkInstance, Ophan, OptOutAdSlot, OptOutInitializeOptions, Permutive, SafeFrameAPI, TeadsAnalytics, Trac } from './types';
+declare global {
+    interface Navigator {
+        readonly connection?: NetworkInformation;
+        readonly cookieDeprecationLabel?: {
+            getValue: () => Promise<string>;
+        };
+    }
+    interface Window {
+        guardian: {
+            ophan?: Ophan;
+            config: Config;
+            queue: Array<() => Promise<void>>;
+            mustardCut?: boolean;
+            polyfilled?: boolean;
+            adBlockers: AdBlockers;
+            css: {
+                onLoad: () => void;
+                loaded: boolean;
+            };
+            articleCounts?: ArticleCounts;
+            commercial?: {
+                dfpEnv?: DfpEnv;
+                a9WinningBids?: FetchBidResponse[];
+            };
+            notificationEventHistory?: HeaderNotification[][];
+            commercialTimer?: EventTimer;
+            offlineCount?: number;
+            modules: {
+                sentry?: {
+                    reportError?: (error: Error, feature: string, tags?: Record<string, string>, extras?: Record<string, unknown>) => void;
+                };
+            };
+        };
+        ootag: {
+            queue: Array<() => void>;
+            initializeOo: (o: OptOutInitializeOptions) => void;
+            addParameter: (key: string, value: string | string[]) => void;
+            addParameterForSlot: (slotId: string, key: string, value: string | string[]) => void;
+            defineSlot: (o: OptOutAdSlot) => void;
+            makeRequests: () => void;
+            refreshSlot: (slotId: string) => void;
+            refreshAllSlots: () => void;
+            logger: (...args: unknown[]) => void;
+        };
+        readonly navigator: Navigator;
+        confiant?: Confiant;
+        apstag?: Apstag;
+        permutive?: Permutive;
+        _comscore?: ComscoreGlobals[];
+        __iasPET?: IasPET;
+        teads_analytics?: TeadsAnalytics;
+        $sf: SafeFrameAPI;
+        conf: unknown;
+        NOLCMB: {
+            getInstance: (apid: string) => NSdkInstance;
+        };
+        nol_t: (pvar: {
+            cid: string;
+            content: string;
+            server: string;
+        }) => Trac;
+        google_trackConversion?: (arg0: GoogleTrackConversionObject) => void;
+        google_tag_params?: GoogleTagParams;
+        _brandmetrics?: Array<{
+            cmd: string;
+            val: Record<string, unknown>;
+        }>;
+    }
+}

package/dist/cjs/global.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.d.ts

@@ -0,0 +1,13 @@
+export { isAdBlockInUse } from './detect-ad-blocker';
+export { EventTimer } from './event-timer';
+export { adSizes } from './ad-sizes';
+export * as constants from './constants';
+export { bypassCommercialMetricsSampling, initCommercialMetrics, } from './send-commercial-metrics';
+export { buildPageTargeting } from './targeting/build-page-targeting';
+export { postMessage } from './messenger/post-message';
+export { buildImaAdTagUrl } from './targeting/youtube-ima';
+export { getPermutivePFPSegments } from './permutive';
+export { isEligibleForTeads } from './targeting/teads-eligibility';
+export type { AdSize, SizeMapping, SlotName } from './ad-sizes';
+export type { PageTargeting } from './targeting/build-page-targeting';
+export type { AdsConfigDisabled, AdsConfigUSNATorAus, AdsConfigTCFV2, } from './types';

package/dist/cjs/index.js

@@ -0,0 +1,46 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEligibleForTeads = exports.getPermutivePFPSegments = exports.buildImaAdTagUrl = exports.buildPageTargeting = exports.initCommercialMetrics = exports.bypassCommercialMetricsSampling = exports.constants = exports.adSizes = exports.EventTimer = exports.isAdBlockInUse = void 0;
+var detect_ad_blocker_1 = require("./detect-ad-blocker");
+Object.defineProperty(exports, "isAdBlockInUse", { enumerable: true, get: function () { return detect_ad_blocker_1.isAdBlockInUse; } });
+var event_timer_1 = require("./event-timer");
+Object.defineProperty(exports, "EventTimer", { enumerable: true, get: function () { return event_timer_1.EventTimer; } });
+var ad_sizes_1 = require("./ad-sizes");
+Object.defineProperty(exports, "adSizes", { enumerable: true, get: function () { return ad_sizes_1.adSizes; } });
+exports.constants = __importStar(require("./constants"));
+var send_commercial_metrics_1 = require("./send-commercial-metrics");
+Object.defineProperty(exports, "bypassCommercialMetricsSampling", { enumerable: true, get: function () { return send_commercial_metrics_1.bypassCommercialMetricsSampling; } });
+Object.defineProperty(exports, "initCommercialMetrics", { enumerable: true, get: function () { return send_commercial_metrics_1.initCommercialMetrics; } });
+var build_page_targeting_1 = require("./targeting/build-page-targeting");
+Object.defineProperty(exports, "buildPageTargeting", { enumerable: true, get: function () { return build_page_targeting_1.buildPageTargeting; } });
+var post_message_1 = require("./messenger/post-message");
+Object.defineProperty(exports, "postMessage", { enumerable: true, get: function () { return post_message_1.postMessage; } });
+var youtube_ima_1 = require("./targeting/youtube-ima");
+Object.defineProperty(exports, "buildImaAdTagUrl", { enumerable: true, get: function () { return youtube_ima_1.buildImaAdTagUrl; } });
+var permutive_1 = require("./permutive");
+Object.defineProperty(exports, "getPermutivePFPSegments", { enumerable: true, get: function () { return permutive_1.getPermutivePFPSegments; } });
+var teads_eligibility_1 = require("./targeting/teads-eligibility");
+Object.defineProperty(exports, "isEligibleForTeads", { enumerable: true, get: function () { return teads_eligibility_1.isEligibleForTeads; } });

package/dist/cjs/messenger/post-message.d.ts

@@ -0,0 +1 @@
+export declare const postMessage: (message: Record<string, unknown>, target: MessageEventSource, targetOrigin?: string) => void;

package/dist/cjs/messenger/post-message.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postMessage = void 0;
+const postMessage = (message, target, targetOrigin = '*') => {
+    target.postMessage(JSON.stringify(message), { targetOrigin });
+};
+exports.postMessage = postMessage;

package/dist/cjs/permutive.d.ts

@@ -0,0 +1,9 @@
+declare const getPermutiveSegments: () => string[];
+declare const getPermutivePFPSegments: () => string[];
+declare const clearPermutiveSegments: () => void;
+export declare const _: {
+    PERMUTIVE_KEY: string;
+    PERMUTIVE_PFP_KEY: string;
+    getSegments: (key: string) => string[];
+};
+export { getPermutiveSegments, getPermutivePFPSegments, clearPermutiveSegments, };

package/dist/cjs/permutive.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearPermutiveSegments = exports.getPermutivePFPSegments = exports.getPermutiveSegments = exports._ = void 0;
+const libs_1 = require("@guardian/libs");
+const PERMUTIVE_KEY = `_papns`;
+const PERMUTIVE_PFP_KEY = `_pdfps`;
+const getSegments = (key) => {
+    try {
+        const rawSegments = libs_1.storage.local.getRaw(key);
+        const segments = rawSegments
+            ? JSON.parse(rawSegments)
+            : null;
+        if (!Array.isArray(segments))
+            return [];
+        return segments
+            .slice(0, 250)
+            .map((s) => Number.parseInt(s, 10))
+            .filter((n) => typeof n === 'number' && !Number.isNaN(n))
+            .map(String);
+    }
+    catch (err) {
+        return [];
+    }
+};
+const getPermutiveSegments = () => getSegments(PERMUTIVE_KEY);
+exports.getPermutiveSegments = getPermutiveSegments;
+const getPermutivePFPSegments = () => getSegments(PERMUTIVE_PFP_KEY);
+exports.getPermutivePFPSegments = getPermutivePFPSegments;
+const clearPermutiveSegments = () => {
+    libs_1.storage.local.remove(PERMUTIVE_KEY);
+    libs_1.storage.local.remove(PERMUTIVE_PFP_KEY);
+};
+exports.clearPermutiveSegments = clearPermutiveSegments;
+exports._ = {
+    PERMUTIVE_KEY,
+    PERMUTIVE_PFP_KEY,
+    getSegments,
+};