@guardian/commercial-core 0.0.0-beta-20250716121613

package/dist/cjs/targeting/youtube-ima.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildImaAdTagUrl = void 0;
+const libs_1 = require("@guardian/libs");
+const build_page_targeting_1 = require("./build-page-targeting");
+/**
+ * @param  {Record<string, MaybeArray<string|number|boolean>>
+ * Follows https://support.google.com/admanager/answer/1080597
+ */
+const encodeCustomParams = (params) => {
+    const encodedParams = Object.entries(params)
+        .map(([key, value]) => {
+        const queryValue = Array.isArray(value)
+            ? value.join(',')
+            : String(value);
+        return `${key}=${encodeURIComponent(queryValue)}`;
+    })
+        .join('&');
+    return encodedParams;
+};
+const mergeCustomParamsWithTargeting = (customParams, consentState, clientSideParticipations, isSignedIn) => {
+    let pageTargeting = {};
+    try {
+        pageTargeting = (0, build_page_targeting_1.buildPageTargeting)({
+            adFree: false,
+            clientSideParticipations,
+            consentState: consentState,
+            isSignedIn: isSignedIn,
+        });
+    }
+    catch (e) {
+        /**
+         * Defensive error handling in case YoutubeAtom is used in an
+         * environment where guardian.config, cookies, localstorage etc
+         * are not available
+         */
+        (0, libs_1.log)('commercial', 'Error building YouTube IMA custom params', e);
+        return customParams;
+    }
+    const mergedCustomParams = {
+        ...customParams,
+        ...pageTargeting,
+    };
+    return mergedCustomParams;
+};
+const buildImaAdTagUrl = ({ adUnit, clientSideParticipations, consentState, customParams, isSignedIn, }) => {
+    const mergedCustomParams = mergeCustomParamsWithTargeting(customParams, consentState, clientSideParticipations, isSignedIn);
+    const queryParams = {
+        iu: adUnit,
+        tfcd: '0',
+        npa: '0',
+        sz: '480x360|480x361|400x300',
+        gdfp_req: '1',
+        output: 'vast',
+        unviewed_position_start: '1',
+        env: 'vp',
+        impl: 's',
+        vad_type: 'linear',
+        vpos: 'preroll',
+        plcmt: '1',
+        description_url: encodeURIComponent(`${window.guardian.config.page.host}/${window.guardian.config.page.pageId}`),
+        /**
+         * cust_params string is encoded
+         * cust_params values are also encoded so they will get double encoded
+         * this ensures any values with separator chars (=&,) do not conflict with the main string
+         */
+        cust_params: encodeURIComponent(encodeCustomParams((0, build_page_targeting_1.filterValues)(mergedCustomParams))),
+    };
+    const queryParamsArray = [];
+    for (const [k, v] of Object.entries(queryParams)) {
+        queryParamsArray.push(`${k}=${v}`);
+    }
+    return ('https://securepubads.g.doubleclick.net/gampad/ads?' +
+        queryParamsArray.join('&'));
+};
+exports.buildImaAdTagUrl = buildImaAdTagUrl;

package/dist/cjs/types.d.ts

@@ -0,0 +1,426 @@
+import type { AdSize, SizeMapping } from './ad-sizes';
+import type { PageTargeting } from './targeting/build-page-targeting';
+type HeaderBiddingSize = AdSize;
+interface Advert {
+    id: string;
+    node: HTMLElement;
+    prebidAdUnit: string;
+    sizes: SizeMapping;
+    headerBiddingSizes: HeaderBiddingSize[] | null;
+    size: AdSize | 'fluid' | null;
+    slot: googletag.Slot;
+    isEmpty: boolean | null;
+    isRendered: boolean;
+    shouldRefresh: boolean;
+    whenSlotReady: Promise<void>;
+    extraNodeClasses: string[];
+    hasPrebidSize: boolean;
+    headerBiddingBidRequest: Promise<unknown> | null;
+    lineItemId: number | null;
+    creativeId: number | null;
+    creativeTemplateId: number | null;
+    testgroup: string | undefined;
+    finishedRendering(isRendered: boolean): void;
+    updateExtraSlotClasses(...newClasses: string[]): Promise<void>;
+    generateSizeMapping(additionalSizeMapping: SizeMapping): SizeMapping;
+    updateSizeMapping(additionalSizeMapping: SizeMapping): void;
+}
+interface DfpEnv {
+    renderStartTime: number;
+    adSlotSelector: string;
+    lazyLoadEnabled: boolean;
+    lazyLoadObserve: boolean;
+    advertsToLoad: Advert[];
+    adverts: Map<Advert['id'], Advert>;
+    shouldLazyLoad: () => boolean;
+}
+type ConnectionType = 'bluetooth' | 'cellular' | 'ethernet' | 'mixed' | 'none' | 'other' | 'unknown' | 'wifi';
+interface NetworkInformation extends EventTarget {
+    readonly type?: ConnectionType;
+    readonly downlink?: number;
+    readonly effectiveType?: string;
+}
+type OphanRecordFunction = (event: Record<string, unknown> & {
+    /**
+     * the experiences key will override previously set values.
+     * Use `recordExperiences` instead.
+     */
+    experiences?: never;
+}, callback?: () => void) => void;
+/**
+ * Generates a type which represents possible indices of this array
+ *
+ * Example usage:
+ * const list = ['foo', 'bar', 'baz'] as const;
+ * type Test = Indices<typeof list>
+ */
+type Indices<T extends readonly unknown[]> = Exclude<Partial<T>['length'], T['length']>;
+type Edition = 'UK' | 'AU' | 'US';
+type AdsConfigDisabled = {
+    disableAds: true;
+};
+type AdsConfigBasic = {
+    adTagParameters: {
+        iu: string;
+        cust_params: string;
+    };
+};
+type AdsConfigUSNATorAus = AdsConfigBasic & {
+    restrictedDataProcessor: boolean;
+};
+type AdsConfigTCFV2 = AdsConfigBasic & {
+    adTagParameters: {
+        cmpGdpr: number;
+        cmpVcd: string;
+        cmpGvcd: string;
+    };
+    nonPersonalizedAd: boolean;
+};
+type AdsConfigEnabled = AdsConfigBasic | AdsConfigUSNATorAus | AdsConfigTCFV2;
+type AdsConfig = AdsConfigEnabled | AdsConfigDisabled;
+type AdTargetingBuilder = () => Promise<AdsConfig>;
+interface Ophan {
+    trackComponentAttention: (name: string, el: Element, visiblityThreshold: number) => void;
+    record: OphanRecordFunction;
+    viewId: string;
+    pageViewId: string;
+}
+type PrebidBreakpoint = 'D' | 'T' | 'M';
+type PrebidIndexSite = {
+    bp: PrebidBreakpoint;
+    id: number;
+};
+interface CommercialPageConfig {
+    pbIndexSites: PrebidIndexSite[];
+    adUnit: string;
+    appNexusPageTargeting?: string;
+    sharedAdTargeting?: Record<string, string | string[]>;
+    shouldHideAdverts: boolean;
+    pageAdTargeting?: PageTargeting;
+    dfpAccountId: string;
+    ipsosTag?: string;
+    a9PublisherId: string;
+    libs?: {
+        googletag?: string;
+    };
+}
+interface PageConfig extends CommercialPageConfig {
+    ajaxUrl?: string;
+    assetsPath: string;
+    author: string;
+    authorIds: string;
+    blogIds: string;
+    commentable: boolean;
+    contentType: string;
+    dcrCouldRender: boolean;
+    edition: Edition;
+    frontendAssetsFullURL?: string;
+    hasPageSkin: boolean;
+    hasShowcaseMainElement: boolean;
+    hasYouTubeAtom: boolean;
+    headline: string;
+    host: string;
+    idApiUrl?: string;
+    idUrl?: string;
+    isbn?: string;
+    isDev: boolean;
+    isFront: boolean;
+    isHosted: boolean;
+    isImmersive?: boolean;
+    isLiveBlog?: boolean;
+    isPaidContent: boolean;
+    isPreview: boolean;
+    isProd: boolean;
+    isSensitive: boolean;
+    isMinuteArticle: boolean;
+    keywordIds: string;
+    keywords: string;
+    lightboxImages?: {
+        images: Array<{
+            src: string;
+        }>;
+    };
+    pageId: string;
+    publication: string;
+    revisionNumber: string;
+    section: string;
+    sectionName: string;
+    sentryHost: string;
+    sentryPublicApiKey: string;
+    series: string;
+    seriesId: string;
+    sharedAdTargeting?: Record<string, string | string[]>;
+    shouldHideReaderRevenue?: boolean;
+    showNewRecipeDesign?: boolean;
+    showRelatedContent?: boolean;
+    source: string;
+    sponsorshipType: string;
+    toneIds: string;
+    tones: string;
+    videoDuration: number;
+    webPublicationDate: number;
+    userAttributesApiUrl?: string;
+}
+type Stage = 'DEV' | 'CODE' | 'PROD';
+interface UserConfig {
+    accountCreatedDate: number;
+    displayName: string;
+    emailVerified: boolean;
+    id: string;
+    rawResponse: string;
+}
+interface Config {
+    commercialMetricsInitialised?: boolean;
+    frontendAssetsFullURL?: string;
+    isDotcomRendering: boolean;
+    ophan: {
+        browserId?: string;
+        pageViewId: string;
+    };
+    page: PageConfig;
+    shouldSendCommercialMetrics?: boolean;
+    stage: Stage;
+    switches: Record<string, boolean | undefined>;
+    tests?: {
+        [key: `${string}Control`]: 'control';
+        [key: `${string}Variant`]: 'variant';
+    };
+    user?: UserConfig;
+}
+type AdBlockers = {
+    active: boolean | undefined;
+    onDetect: Array<(value: boolean | PromiseLike<boolean>) => void>;
+};
+type TagCounts = Record<string, number>;
+type WeeklyArticleLog = {
+    week: number;
+    count: number;
+    tags?: TagCounts;
+};
+type WeeklyArticleHistory = WeeklyArticleLog[];
+interface DailyArticleCount {
+    day: number;
+    count: number;
+}
+type DailyArticleHistory = DailyArticleCount[];
+interface ArticleCounts {
+    weeklyArticleHistory: WeeklyArticleHistory;
+    dailyArticleHistory: DailyArticleHistory;
+}
+type FetchBidSizes = {
+    adSizes: `${number}x${number}`;
+};
+type FetchBidResponse = {
+    amznbid: string;
+    amzniid: string;
+    amznp: string;
+    amznsz: FetchBidSizes;
+    size: FetchBidSizes;
+    slotID: string;
+};
+interface HeaderNotification {
+    id: string;
+    target: string;
+    message: string;
+    ophanLabel: string;
+    logImpression: () => void;
+}
+interface OptOutInitializeOptions {
+    publisher: number;
+    onlyNoConsent?: 0 | 1;
+    alwaysNoConsent?: 0 | 1;
+    consentTimeOutMS?: 5000;
+    noLogging?: 0 | 1;
+    lazyLoading?: {
+        fractionInView?: number;
+        viewPortMargin?: string;
+    };
+    noRequestsOnPageLoad?: 0 | 1;
+    frequencyScript?: string;
+    timeoutFrequencyCappingMS?: number;
+    debug_forceCap?: number;
+}
+interface OptOutResponse {
+    adSlot: string;
+    width: number;
+    height: number;
+    ad: string;
+    creativeId: string;
+    meta: {
+        networkId: string;
+        networkName: string;
+        agencyId: string;
+        agencyName: string;
+        advertiserId: string;
+        advertiserName: string;
+        advertiserDomains: string[];
+    };
+    optOutExt: {
+        noSafeFrame: boolean;
+        tags: string[];
+    };
+}
+type OptOutFilledCallback = (adSlot: OptOutAdSlot, response: OptOutResponse) => void;
+interface OptOutAdSlot {
+    adSlot: string;
+    targetId: string;
+    id: string;
+    filledCallback?: OptOutFilledCallback;
+    emptyCallback?: (adSlot: OptOutAdSlot) => void;
+    adShownCallback?: (adSlot: OptOutAdSlot, response: OptOutResponse) => void;
+}
+interface ImpressionsDfpObject {
+    s: string;
+    ad: string;
+    c: string;
+    I: string;
+    o: string;
+    A: string;
+    y: string;
+    co: string;
+}
+declare enum BlockingType {
+    Manual = 1,// Deprecated
+    Creative = 2,// Creative-based detection
+    ProviderSecurity = 3,// Domain-based detection for unsafe domains
+    BannedDomain = 4,// Domain-based detection for banned domains
+    ProviderIbv = 5,// Domain-based detection for in-banner-video
+    UnsafeJS = 6,// JavaScript-based detection for unsafe ads
+    Hrap = 7
+}
+type ConfiantCallback = (blockingType: BlockingType, blockingId: string, isBlocked: boolean, wrapperId: string, tagId: string, impressionsData?: {
+    prebid?: {
+        adId?: string | null;
+        cpm?: number | null;
+        s?: string;
+    };
+    dfp?: ImpressionsDfpObject;
+}) => void;
+interface Confiant extends Record<string, unknown> {
+    settings: {
+        callback: ConfiantCallback;
+        [key: string]: unknown;
+    };
+}
+interface Permutive {
+    config?: {
+        projectId?: string;
+        apiKey?: string;
+        environment?: string;
+    };
+    q?: Array<{
+        functionName: string;
+        arguments: unknown[];
+    }>;
+    addon?: (name: string, props: Record<string, unknown>) => void;
+    identify?: (user: Array<{
+        id: string;
+        tag: string;
+    }>) => void;
+    track?: (name: string, props: Record<string, unknown>) => void;
+}
+type ApstagInitConfig = {
+    pubID: string;
+    adServer?: string;
+    bidTimeout?: number;
+    blockedBidders?: string[];
+};
+interface A9AdUnitInterface {
+    slotID: string;
+    slotName?: string;
+    sizes: number[][];
+}
+type FetchBidsBidConfig = {
+    slots: A9AdUnitInterface[];
+};
+type Apstag = {
+    init: (arg0: ApstagInitConfig) => void;
+    fetchBids: (arg0: FetchBidsBidConfig, callback: (res: FetchBidResponse[]) => void) => void;
+    setDisplayBids: () => void;
+};
+type ComscoreGlobals = {
+    c1: string;
+    c2: string;
+    cs_ucfr: string;
+    comscorekw?: string;
+    options?: {
+        enableFirstPartyCookie?: boolean;
+    };
+};
+interface IasPETSlot {
+    adSlotId: string;
+    size: Array<[number, number]>;
+    adUnitPath: string;
+}
+interface IasPET {
+    queue?: Array<{
+        adSlots: IasPETSlot[];
+        dataHandler: (targetingJSON: string) => void;
+    }>;
+    pubId?: string;
+}
+interface TeadsAnalytics {
+    analytics_tag_id?: string;
+    share?: () => void;
+    shared_data?: unknown[];
+}
+/**
+ * Types for the IAB Safeframe API
+ *
+ * Note this type definition is incomplete.
+ * These types can be refined as/when they are required
+ */
+interface SafeFrameAPI {
+    ver: string;
+    specVersion: string;
+    lib: {
+        lang: Record<string, unknown>;
+        dom: {
+            iframes: Record<string, unknown>;
+            msghost: Record<string, unknown>;
+        };
+        logger: Record<string, unknown>;
+    };
+    env: {
+        isIE: boolean;
+        ua: Record<string, unknown>;
+    };
+    info: {
+        errs: unknown[];
+        list: unknown[];
+    };
+    host: {
+        Config: {
+            new (o: {
+                renderFile: string;
+                positions: Record<string, unknown>;
+            }): unknown;
+        };
+    };
+}
+/**
+ * Types for IMR Worldwide
+ */
+interface NSdkInstance {
+    ggPM: (type: string, dcrStaticMetadata: {
+        type: string;
+        assetid: unknown;
+        section: string;
+    }) => void;
+    ggInitialize: (nolggGlobalParams: {
+        sfcode: string;
+        apid: string;
+        apn: string;
+    }) => void;
+}
+interface Trac {
+    record: () => this;
+    post: () => this;
+}
+type GoogleTagParams = unknown;
+type GoogleTrackConversionObject = {
+    google_conversion_id: number;
+    google_custom_params: GoogleTagParams;
+    google_remarketing_only: boolean;
+};
+export type { Advert, DfpEnv, ConnectionType, NetworkInformation, OphanRecordFunction, Indices, Edition, AdsConfigDisabled, AdsConfigEnabled, AdsConfigBasic, AdsConfigUSNATorAus, AdsConfigTCFV2, AdsConfig, AdTargetingBuilder, Ophan, Config, AdBlockers, ArticleCounts, FetchBidResponse, HeaderNotification, OptOutInitializeOptions, OptOutAdSlot, Confiant, Permutive, Apstag, ComscoreGlobals, IasPET, TeadsAnalytics, SafeFrameAPI, NSdkInstance, Trac, GoogleTagParams, GoogleTrackConversionObject, };

package/dist/cjs/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var BlockingType;
+(function (BlockingType) {
+    BlockingType[BlockingType["Manual"] = 1] = "Manual";
+    BlockingType[BlockingType["Creative"] = 2] = "Creative";
+    BlockingType[BlockingType["ProviderSecurity"] = 3] = "ProviderSecurity";
+    BlockingType[BlockingType["BannedDomain"] = 4] = "BannedDomain";
+    BlockingType[BlockingType["ProviderIbv"] = 5] = "ProviderIbv";
+    BlockingType[BlockingType["UnsafeJS"] = 6] = "UnsafeJS";
+    BlockingType[BlockingType["Hrap"] = 7] = "Hrap";
+})(BlockingType || (BlockingType = {}));