@guardian/commercial-core 7.0.0 → 27.0.0

package/dist/esm/event-timer.js

@@ -1,24 +1,75 @@
-import { trackEvent } from './google-analytics';
-class Event {
-    constructor(name, mark) {
-        this.name = name;
-        this.ts = mark.startTime;
+import { log } from '@guardian/libs';
+const supportsPerformanceAPI = () => typeof window !== 'undefined' &&
+    typeof window.performance !== 'undefined' &&
+    typeof window.performance.mark === 'function';
+// 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 core, and we want
+     * 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() {
-        var _a;
-        return ((_a = window.guardian).commercialTimer || (_a.commercialTimer = new EventTimer()));
+        return (window.guardian.commercialTimer ??= new EventTimer());
     }
     /**
      * Just a helper method to access the singleton instance of EventTimer.
@@ -28,68 +79,42 @@ class EventTimer {
         return this.init();
     }
     /**
-     * Returns all commercial timers. CMP-related timers are not tracked
-     * by EventTimer so they need to be concatenated to EventTimer's private events array.
+     * 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 events() {
-        return typeof window.performance !== 'undefined' &&
-            'getEntriesByName' in window.performance
-            ? [
-                ...this._events,
-                ...EventTimer._externallyDefinedEventNames
-                    .map((eventName) => {
-                    const entry = window.performance.getEntriesByName(eventName)[0];
-                    return entry
-                        ? new Event(eventName, entry)
-                        : undefined;
-                })
-                    .filter((entry) => entry instanceof Event),
-            ]
-            : this._events;
+    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._events = [];
-        this.startTS = window.performance.now();
-        this.triggers = {
-            first: {
-                slotReady: false,
-                prebidStart: false,
-                prebidEnd: false,
-                slotInitialised: false,
-                adOnPage: false,
-            },
-            'top-above-nav': {
-                slotReady: false,
-                prebidStart: false,
-                prebidEnd: false,
-                slotInitialised: false,
-                adOnPage: false,
-            },
-            page: {
-                commercialStart: false,
-                commercialExtraModulesLoaded: false,
-                commercialBaseModulesLoaded: false,
-                commercialModulesLoaded: false,
-            },
-        };
-        this.gaConfig = {
-            logEvents: [
-                {
-                    timingVariable: 'slotReady',
-                },
-                {
-                    timingVariable: 'slotInitialised',
-                },
-                {
-                    timingVariable: 'commercialStart',
-                    timingLabel: 'Commercial start parse time',
-                },
-                {
-                    timingVariable: 'commercialModulesLoaded',
-                    timingLabel: 'Commercial end parse time',
-                },
-            ],
-        };
+        this._marks = new Map();
+        this._measures = new Map();
         this.properties = {};
         if (window.navigator.connection) {
             this.properties.type = window.navigator.connection.type;
@@ -99,7 +124,7 @@ class EventTimer {
         }
     }
     /**
-     * Adds an event timer property
+     * Adds a non timer measurement
      *
      * @param {string} name - the property's name
      * @param value - the property's value
@@ -108,60 +133,67 @@ class EventTimer {
         this.properties[name] = value;
     }
     /**
-     * Creates a new performance mark
-     * For slot events also ensures each TYPE of event event is marked only once for 'first'
-     * (the first time that event is triggered for ANY slot) and once for topAboveNav
+     * 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.
      *
-     * @param {string} eventName - The short name applied to the mark
-     * @param {origin} [origin=page] - Either 'page' (default) or the name of the slot
+     * 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
      */
-    trigger(eventName, origin = 'page') {
-        const TRACKED_SLOT_NAME = 'top-above-nav';
-        if (origin === 'page' &&
-            !this.triggers.page[eventName]) {
-            this.mark(eventName);
-            this.trackInGA(eventName);
-            this.triggers.page[eventName] = true;
+    mark(eventName, origin = 'page') {
+        let name = eventName;
+        if (allSlotMarks.includes(eventName) && origin !== 'page') {
+            name = `${origin}_${name}`;
+        }
+        if (!!this._marks.get(name) || !supportsPerformanceAPI()) {
             return;
         }
-        if (!this.triggers.first[eventName]) {
-            const trackLabel = `first-${eventName}`;
-            this.mark(trackLabel);
-            this.trackInGA(eventName, trackLabel);
-            this.triggers.first[eventName] = true;
+        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 (origin === TRACKED_SLOT_NAME) {
-            if (!this.triggers[TRACKED_SLOT_NAME][eventName]) {
-                const trackLabel = `${TRACKED_SLOT_NAME}-${eventName}`;
-                this.mark(trackLabel);
-                this.trackInGA(eventName, trackLabel);
-                this.triggers[TRACKED_SLOT_NAME][eventName] = true;
-            }
+        if (name.endsWith('End')) {
+            this.measure(name);
         }
     }
-    mark(name) {
-        const longName = `gu.commercial.${name}`;
-        if (typeof window.performance !== 'undefined' &&
-            'mark' in window.performance &&
-            typeof window.performance.mark === 'function') {
-            const mark = window.performance.mark(longName);
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- browser support is patchy
-            if (typeof mark?.startTime === 'number') {
-                this._events.push(new Event(name, mark));
+    /**
+     * 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) {
+                log('commercial', `error measuring ${measureName}`, e);
             }
-        }
-    }
-    trackInGA(eventName, label = '') {
-        const gaEvent = this.gaConfig.logEvents.find((e) => e.timingVariable === eventName);
-        if (gaEvent) {
-            const labelToUse = gaEvent.timingLabel ?? label;
-            trackEvent('Commercial Events', gaEvent.timingVariable, labelToUse);
         }
     }
 }
-EventTimer._externallyDefinedEventNames = [
-    'cmp-init',
-    'cmp-ui-displayed',
-    'cmp-got-consent',
-];
-export { EventTimer };
+const _ = {
+    slotMarks,
+    slotMeasures,
+    trackedSlots,
+};
+export { EventTimer, _, supportsPerformanceAPI };

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

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

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

@@ -0,0 +1,31 @@
+import { getCookie, isString, storage } from '@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 = storage.local.get(countryOverrideName);
+    const countryOverride = isString(maybeCountryOverride)
+        ? maybeCountryOverride
+        : null;
+    return (locale ??
+        countryOverride ??
+        getCookie({
+            name: countryCookieName,
+            shouldMemoize: true,
+        }) ??
+        editionToCountryCode(pageEdition));
+};
+export { getCountryCode };

package/dist/esm/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/esm/geo/geo-utils.js

@@ -0,0 +1,20 @@
+import { getCountryCode } from './country-code';
+// cache the users location so we only have to look it up once
+let geo;
+const currentGeoLocation = () => {
+    geo = geo ?? getCountryCode();
+    return geo;
+};
+export const isInUk = () => currentGeoLocation() === 'GB';
+export const isInUsa = () => currentGeoLocation() === 'US';
+export const isInCanada = () => currentGeoLocation() === 'CA';
+export const isInAustralia = () => currentGeoLocation() === 'AU';
+export const isInNewZealand = () => currentGeoLocation() === 'NZ';
+export const isInUsOrCa = () => isInUsa() || isInCanada();
+export const isInAuOrNz = () => isInAustralia() || isInNewZealand();
+export const isInRow = () => !isInUk() && !isInUsOrCa() && !isInAuOrNz();
+export const _ = {
+    resetModule: () => {
+        geo = undefined;
+    },
+};

package/dist/esm/global.d.ts

@@ -1,23 +1,71 @@
-/// <reference types="google.analytics" />
-import type { GoogleTagParams, GoogleTrackConversionObject, GuardianWindowConfig, NetworkInformation } from './types';
-import type { EventTimer } from '.';
+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>;
         }>;
-        guardian: {
-            commercialTimer?: EventTimer;
-            config: GuardianWindowConfig;
-            offlineCount?: number;
-        };
-        ga: UniversalAnalytics.ga | null;
-        readonly navigator: Navigator;
     }
 }

package/dist/esm/global.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/index.d.ts

@@ -1,43 +1,13 @@
-export { ias } from './third-party-tags/ias';
-export { permutive } from './third-party-tags/permutive';
-export { twitter } from './third-party-tags/twitter-uwt';
-export { inizio } from './third-party-tags/inizio';
-export { remarketing } from './third-party-tags/remarketing';
-export { EventTimer } from './event-timer';
-export { bypassCommercialMetricsSampling, initCommercialMetrics, } from './send-commercial-metrics';
-export type { ThirdPartyTag } from './types';
-export { adSizes, createAdSize, getAdSize, outstreamSizes, slotSizeMappings, standardAdSizes, } from './ad-sizes';
-export { isBreakpoint } from './lib/breakpoint';
-export type { Breakpoint } from './lib/breakpoint';
-export type { SizeKeys, AdSizeString, AdSize, SizeMapping, SlotSizeMappings, SlotName, } from './ad-sizes';
 export { isAdBlockInUse } from './detect-ad-blocker';
-export { clearPermutiveSegments, getPermutiveSegments, getPermutivePFPSegments, } from './permutive';
-export { initTrackScrollDepth } from './track-scroll-depth';
-export { initTrackLabsContainer } from './track-labs-container';
-export { initTrackGpcSignal } from './track-gpc-signal';
-export { buildAdsConfigWithConsent, disabledAds } from './targeting/youtube';
-export { createAdSlot, concatSizeMappings } from './create-ad-slot';
-export type { AdsConfig, AdsConfigBasic, AdsConfigDisabled, AdTargetingBuilder, CustomParams, } from './types';
+export { EventTimer } from './event-timer';
+export { adSizes } from './ad-sizes';
 export * as constants from './constants';
-export type { ContentTargeting } from './targeting/content';
-export { getContentTargeting } from './targeting/content';
-export type { PersonalisedTargeting } from './targeting/personalised';
-export { getPersonalisedTargeting } from './targeting/personalised';
-export type { SessionTargeting } from './targeting/session';
-export { getSessionTargeting } from './targeting/session';
-export type { SharedTargeting } from './targeting/shared';
-export { getSharedTargeting } from './targeting/shared';
-export type { ViewportTargeting } from './targeting/viewport';
-export { getViewportTargeting } from './targeting/viewport';
-export { pickTargetingValues } from './targeting/pick-targeting-values';
-export { init as initMessenger } from './messenger';
-export type { RegisterListener, RegisterPersistentListener, RespondProxy, } from './messenger';
-export { postMessage } from './messenger/post-message';
+export { bypassCommercialMetricsSampling, initCommercialMetrics, } from './send-commercial-metrics';
 export { buildPageTargeting } from './targeting/build-page-targeting';
-export { buildPageTargetingConsentless } from './targeting/build-page-targeting-consentless';
-export type { PageTargeting } from './targeting/build-page-targeting';
-export { a9Apstag } from './__vendor/a9-apstag';
-export { ipsosMoriStub } from './__vendor/ipsos-mori';
-export { launchpad } from './__vendor/launchpad';
-export { pubmatic } from './__vendor/pubmatic';
+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/esm/index.js

@@ -1,35 +1,10 @@
-/* istanbul ignore file -- there's no point check this for test coverage */
-export { ias } from './third-party-tags/ias';
-export { permutive } from './third-party-tags/permutive';
-export { twitter } from './third-party-tags/twitter-uwt';
-export { inizio } from './third-party-tags/inizio';
-export { remarketing } from './third-party-tags/remarketing';
+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 { adSizes, createAdSize, getAdSize, outstreamSizes, slotSizeMappings, standardAdSizes, } from './ad-sizes';
-export { isBreakpoint } from './lib/breakpoint';
-export { isAdBlockInUse } from './detect-ad-blocker';
-export { clearPermutiveSegments, getPermutiveSegments, getPermutivePFPSegments, } from './permutive';
-export { initTrackScrollDepth } from './track-scroll-depth';
-export { initTrackLabsContainer } from './track-labs-container';
-export { initTrackGpcSignal } from './track-gpc-signal';
-export { buildAdsConfigWithConsent, disabledAds } from './targeting/youtube';
-export { createAdSlot, concatSizeMappings } from './create-ad-slot';
-import * as constants_1 from './constants';
-export { constants_1 as constants };
-export { getContentTargeting } from './targeting/content';
-export { getPersonalisedTargeting } from './targeting/personalised';
-export { getSessionTargeting } from './targeting/session';
-export { getSharedTargeting } from './targeting/shared';
-export { getViewportTargeting } from './targeting/viewport';
-export { pickTargetingValues } from './targeting/pick-targeting-values';
-export { init as initMessenger } from './messenger';
-export { postMessage } from './messenger/post-message';
 export { buildPageTargeting } from './targeting/build-page-targeting';
-export { buildPageTargetingConsentless } from './targeting/build-page-targeting-consentless';
-/* -- Vendor JavaScript -- */
-export { a9Apstag } from './__vendor/a9-apstag';
-export { ipsosMoriStub } from './__vendor/ipsos-mori';
-export { launchpad } from './__vendor/launchpad';
-export { pubmatic } from './__vendor/pubmatic';
+export { postMessage } from './messenger/post-message';
 export { buildImaAdTagUrl } from './targeting/youtube-ima';
+export { getPermutivePFPSegments } from './permutive';
+export { isEligibleForTeads } from './targeting/teads-eligibility';

package/dist/esm/send-commercial-metrics.d.ts

@@ -11,6 +11,10 @@ type TimedEvent = {
     name: string;
     ts: number;
 };
+type DurationEvent = {
+    name: string;
+    duration: number;
+};
 type EventProperties = {
     type?: ConnectionType;
     downlink?: number;
@@ -20,6 +24,7 @@ declare enum Endpoints {
     CODE = "//performance-events.code.dev-guardianapis.com/commercial-metrics",
     PROD = "//performance-events.guardianapis.com/commercial-metrics"
 }
+declare const checkConsent: () => Promise<boolean>;
 /**
  * A method to asynchronously send metrics after initialization.
  */
@@ -33,6 +38,7 @@ interface InitCommercialMetricsArgs {
 }
 /**
  * A method to initialise metrics.
+ * Note: this is initialised in the frontend/DCR bundles, not the commercial bundle.
  * @param init.pageViewId - identifies the page view. Usually available on `guardian.config.ophan.pageViewId`. Defaults to `null`
  * @param init.browserId - identifies the browser. Usually available via `getCookie({ name: 'bwid' })`. Defaults to `null`
  * @param init.isDev - used to determine whether to use CODE or PROD endpoints.
@@ -44,9 +50,9 @@ export declare const _: {
     Endpoints: typeof Endpoints;
     setEndpoint: (isDev: boolean) => Endpoints;
     mapEventTimerPropertiesToString: (properties: Array<[string, string | number]>) => Property[];
-    roundTimeStamp: (events: TimedEvent[]) => Metric[];
+    roundTimeStamp: (events: TimedEvent[], measures: DurationEvent[]) => Metric[];
     transformToObjectEntries: (eventTimerProperties: EventProperties) => Array<[string, string | number | undefined]>;
     reset: () => void;
 };
 export type { Property, TimedEvent, Metric };
-export { bypassCommercialMetricsSampling, initCommercialMetrics };
+export { bypassCommercialMetricsSampling, initCommercialMetrics, checkConsent };