@schibsted/advertory 2.70.1-inv-1385.3 → 2.70.2

package/types/features/glimr/constants.d.ts

@@ -0,0 +1,9 @@
+declare const GLIMR_TAG_STORAGE_KEY = "glimrTags";
+declare const WEATHER_TAGS_PREFIXES: string[];
+declare const GEOFENCE_PREFIX = "glgc_";
+declare const EMPTY_TAGS: {
+    geofenceTags: never[];
+    geoTags: never[];
+    weatherTags: never[];
+};
+export { GLIMR_TAG_STORAGE_KEY, WEATHER_TAGS_PREFIXES, GEOFENCE_PREFIX, EMPTY_TAGS };

package/types/features/glimr/glimr-core-handler.d.ts

@@ -0,0 +1,4 @@
+import { SiteConfig } from 'core/interface/config';
+declare const isGlimrConsentGiven: (consentConfig?: Partial<SiteConfig>) => Promise<boolean>;
+declare const updateGlimr: () => Promise<void>;
+export { updateGlimr, isGlimrConsentGiven };

package/types/features/glimr/glimr-core-handler.test.d.ts

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

package/types/features/glimr/glimr-tag-filters.d.ts

@@ -0,0 +1,5 @@
+import { SiteConfig } from 'core/interface/config';
+declare const getWeatherGlimrTags: (glimrTags?: Array<string>) => Array<string>;
+declare const getGeofenceGlimrTags: (glimrTags?: Array<string>) => Array<string>;
+declare const getGeoGlimrTags: (glimrTags?: Array<string>, customConfig?: Partial<SiteConfig>, addPublisherToGeo?: boolean) => Array<string>;
+export { getWeatherGlimrTags, getGeoGlimrTags, getGeofenceGlimrTags };

package/types/features/glimr/glimr-tag-filters.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @jest-environment jsdom
+ */
+export {};

package/types/features/glimr/glimr-tags-handler.d.ts

@@ -0,0 +1,5 @@
+import { NoGlimrKeywords, SeGlimrKeywords } from 'core/interface/keywords';
+import { GlimrKeywordsOptions } from 'features/interface/glimr';
+import { SiteConfig } from 'core/interface/config';
+declare const getGlimrKeywords: (customConfig: Partial<SiteConfig>, options?: GlimrKeywordsOptions) => Promise<NoGlimrKeywords | SeGlimrKeywords | object>;
+export { getGlimrKeywords };

package/types/features/glimr/glimr-tags-handler.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @jest-environment jsdom
+ */
+export {};

package/types/features/glimr/index.d.ts

@@ -0,0 +1,2 @@
+export { updateGlimr } from './glimr-core-handler';
+export { getGlimrKeywords } from './glimr-tags-handler';

package/types/features/identity/get-identity-object.d.ts

@@ -0,0 +1,3 @@
+import { Identity } from '@schibsted/account-sdk-browser';
+declare const getIdentityObject: () => Promise<Identity | undefined>;
+export { getIdentityObject };

package/types/features/identity/identity-facade.d.ts

@@ -0,0 +1,9 @@
+import { HasSessionSuccessResponse, Identity } from '@schibsted/account-sdk-browser';
+declare class IdentityFacade {
+    private readonly identity;
+    constructor(identity: Identity | undefined);
+    getIdentityUser(): Promise<HasSessionSuccessResponse | null>;
+    isUserLoggedIn(): Promise<boolean>;
+    onIdentityLogout(callback: () => void): void;
+}
+export { IdentityFacade };

package/types/features/identity/identity-facade.test.d.ts

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

package/types/features/identity/user.d.ts

@@ -0,0 +1,5 @@
+import { SiteConfig } from 'core/interface/config';
+declare const getCookie: (cookieName: string) => string | null;
+declare const getAdUserId: (config: Partial<SiteConfig>) => Promise<string | undefined>;
+declare const getUserId: () => string | undefined;
+export { getUserId, getAdUserId, getCookie };

package/types/features/identity/user.test.d.ts

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

package/types/features/interface/ad-native.d.ts

@@ -0,0 +1,134 @@
+import { AstAdObj } from 'core/interface/ast';
+import { Newsroom } from 'core/interface/newsrooms';
+import { Country } from 'core/interface/countries';
+import { PageType } from 'core/interface/page-types';
+import { AppearanceConfig, NativeTrackingConfig, SiteConfig } from 'core/interface/config';
+import { DeviceType } from 'core/interface/device';
+export interface AdNativeData {
+    containerId: string;
+    img: string;
+    imgAltText: string;
+    imgWidth?: number;
+    imgHeight?: number;
+    logo: string;
+    sponsoredBy: string;
+    title: string;
+    url: string;
+    cta: string;
+    description: string;
+    adText: string;
+    adFrom: string;
+    adContent: string;
+    adContentFrom: string;
+    desc2: string;
+    video?: {
+        content: string;
+    };
+    customTitle1?: string;
+    customTitle2?: string;
+    customTitle3?: string;
+    customTitle4?: string;
+    logo2?: string;
+}
+export interface Options {
+    publisher?: Newsroom;
+    video?: {};
+    language?: Country;
+    pageType?: PageType;
+    deviceType?: DeviceType;
+    appearanceConfig?: AppearanceConfig;
+    nativeTrackingConfig?: NativeTrackingConfig;
+    adPlacementFormat?: string;
+    productTag?: string;
+}
+export interface BrandStudioClassicFormatProps {
+    descriptionClassName: string;
+    isAlcoholAd: boolean;
+    adPlacementFormat: string;
+    containerId: string;
+    url: string;
+    adText: string;
+    title: string;
+    img: string;
+    sponsoredBy: string;
+    description: string;
+}
+export interface AdNativeTemplates {
+    [templatesName: string]: (nativeData: AdNativeData, options: Options) => string | null;
+}
+export interface AdNativeTemplatesGrouped {
+    videoTemplates: AdNativeTemplates;
+    displayTemplates: AdNativeTemplates;
+}
+export type InitNativeAdMap = Record<string | 'default', InitNativeAd>;
+export type InitNativeAd = (adObj: AstAdObj, options?: Partial<SiteConfig>) => void;
+export interface VideoPulseEventData {
+    intent?: string;
+    '@type'?: string;
+    position?: number;
+    duration?: number;
+    start?: boolean;
+    provider: string | {
+        productTag: string;
+    };
+    object?: {
+        '@id': string;
+        '@type': string;
+        name: string;
+        muted: boolean;
+        fullscreen: boolean;
+        autoplay: boolean;
+        adSequenceCount: number;
+        adblock: boolean;
+        apiUrl: string;
+    };
+}
+export interface VideoPulseAssets {
+    attributes: {
+        id: number;
+        images: {
+            main: string;
+        };
+        status: string;
+        streamType: string;
+        vendor: string;
+    };
+    rawAsset: {
+        id: number;
+        images: {
+            main: string;
+        };
+        status: string;
+        streamType: string;
+    };
+}
+export interface VideoConfig {
+    id: number;
+    poster?: string;
+    vendor: string;
+    node: string;
+    autoplay?: boolean;
+    autopause?: string;
+    mute?: boolean;
+    skin?: {
+        name?: string;
+        url?: string;
+    };
+    settings?: {
+        jw: {
+            stretching: string;
+            advertising: {
+                client: string;
+                tag: string;
+            };
+        };
+    };
+    pulse?: {
+        provider?: string;
+        productTag?: string;
+        decorator?: (eventData: VideoPulseEventData, asset: VideoPulseAssets) => VideoPulseEventData;
+    };
+}
+export interface CssVariables {
+    [cssVariable: string]: string;
+}

package/types/features/interface/ad-takeover.d.ts

@@ -0,0 +1,7 @@
+export declare const TakeoverVariants: {
+    readonly SPLASH: "splash";
+    readonly WELCOME_PAGE: "welcomePage";
+    readonly TOPSCROLLER: "topscroller";
+    readonly VELVET: "velvet";
+};
+export type TakeoverVariant = (typeof TakeoverVariants)[keyof typeof TakeoverVariants];

package/types/features/interface/alertory.d.ts

@@ -0,0 +1,18 @@
+import { AstAdType, AstKeywords } from 'core/interface/ast';
+import { SiteConfig } from 'core/interface/config';
+export interface AlertoryTag {
+    invCode: string;
+    sizes: Array<Array<number>>;
+    adTypes?: Array<AstAdType>;
+    keywords?: AstKeywords;
+}
+interface XandrConfig {
+    member?: number;
+    keywords: AstKeywords;
+    tags: Array<Array<AlertoryTag>>;
+}
+export interface AlertoryConfig {
+    xandr: XandrConfig;
+    advertory: Partial<SiteConfig>;
+}
+export {};

package/types/features/interface/editable-configuration.d.ts

@@ -0,0 +1,16 @@
+import { Placements, SiteConfig } from 'core/interface/config';
+export interface S3ConfigResponse {
+    keywords: Record<string, string>;
+    batchSize: number;
+    refresh: boolean;
+    placements: Placements;
+    threshold: {
+        desktop: number;
+        tablet: number;
+        mobile: number;
+    };
+}
+export interface ExtendedConfigFromS3 {
+    siteConfig: SiteConfig;
+    configOverrides: S3ConfigResponse;
+}

package/types/features/interface/finn-blink.d.ts

@@ -0,0 +1,42 @@
+import { FinnBlinkPlacementConfig } from 'core/interface/config';
+export type DistributionTypes = 'REALESTATE' | 'REALESTATE_RETARGET' | 'REALESTATE_LEISURE' | 'REALESTATE_LEISURE_RETARGET' | 'REALESTATE_PROJECT' | 'REALESTATE_PROJECT_RETARGET' | 'CAR' | 'JOB';
+export type FinnBlinkFallback = (targetId: string) => void;
+export interface FinnBlinkAdSizes {
+    height: number;
+    width: number;
+}
+export interface FinnBlinkData extends FinnBlinkPlacementConfig {
+    selector: string;
+}
+export interface BlinkConstructorOptions {
+    remote?: string;
+    id?: string;
+    hashed_email?: string;
+    theme?: string;
+}
+export interface BlinkInstance {
+    inject: (options: unknown) => Promise<unknown>;
+}
+export type BlinkConstructor = new (options: BlinkConstructorOptions) => BlinkInstance;
+interface FinnBlinkSelectorConfig {
+    selector: string;
+    position: string;
+    channel: string;
+    uuid: string;
+    id: string;
+    hashed_email: string;
+    theme?: string;
+    distributionTypes?: Array<DistributionTypes>;
+    limit?: number;
+    offset?: number;
+    requireImage?: boolean;
+    rec?: boolean;
+}
+export type FinnBlinkSuccessOptions = (Omit<FinnBlinkPlacementConfig, 'enabled'> & {
+    selector: string;
+    channel: string;
+    uuid?: string;
+    id?: string;
+    hashed_email?: string;
+}) | FinnBlinkSelectorConfig;
+export {};

package/types/features/interface/fullscreen-scroll.d.ts

@@ -0,0 +1,4 @@
+export interface AdSize {
+    width: number;
+    height: number;
+}

package/types/features/interface/glimr.d.ts

@@ -0,0 +1,6 @@
+export interface GlimrData {
+    tags: Array<string>;
+}
+export interface GlimrKeywordsOptions {
+    addPublisherToGeo?: boolean;
+}

package/types/features/interface/player.d.ts

@@ -0,0 +1,9 @@
+import { PlayerConfig } from 'features/player/types';
+export interface PlayerViewCounter {
+    viewable: number;
+}
+export interface RegisterPlayerOptions {
+    playerConfig: PlayerConfig;
+    clickUrl: string;
+    pluginsNames?: Array<string>;
+}

package/types/features/interface/prebid.d.ts

@@ -0,0 +1,56 @@
+import { StandardQueueCallback } from 'core/interface/common';
+import { AstApnTagRequests } from 'core/interface/ast';
+export interface RelevantYield {
+    cmd: RelevantYieldQueue;
+    addPrebidConfig: (config: any) => void;
+    loadPrebid: (config: any) => void;
+}
+export type RelevantYieldQueue = Array<StandardQueueCallback>;
+export interface RelevantYieldEvent {
+    timeout: number;
+    done?: boolean;
+}
+export type RelevantYieldEventName = 'relevantCb' | 'auctionCb';
+export interface RelevantYieldEids {
+    source: string;
+    uids: Array<{
+        id: string;
+        atype: 1;
+        ext: {
+            stype: 'ppuid';
+        };
+    }>;
+}
+export interface RelevantYieldPPIDConfig {
+    userSync: {
+        userIds: Array<{
+            name: 'pubProvidedId';
+            params: RelevantYieldEids;
+        }>;
+    };
+}
+export type RelevantYieldData = Partial<AstApnTagRequests>;
+export interface RelevantYieldKeyValues {
+    ortb2: {
+        id?: string | undefined;
+        site: {
+            ext: {
+                data: Record<string, unknown>;
+            };
+        };
+    };
+}
+export interface PrebidCallContext {
+    getCancel: () => boolean;
+    setCancel: (value: boolean) => void;
+    events: Record<RelevantYieldEventName, RelevantYieldEvent>;
+    failsafeOnTimeout: (event: RelevantYieldEventName) => void;
+    cleanup: () => void;
+}
+export interface PrebidRenderPayload {
+    settings: {
+        bid: object;
+        adDiv: Record<string, unknown>;
+    };
+    renderFn: any;
+}

package/types/features/interface/tracker.d.ts

@@ -0,0 +1,84 @@
+import { AstUserIds } from 'core/interface/ast';
+import { Country } from 'core/interface/countries';
+export interface AdvertisingIdentifiers {
+    xandr?: {
+        ppId1?: string;
+        ppId2?: string;
+    };
+}
+export interface TrackerInstance {
+    getAdvertisingIdentifiers: () => Promise<AdvertisingIdentifiers>;
+    getUserId: () => Promise<undefined | string | number>;
+    getEnvironmentId: () => Promise<undefined | string>;
+    getActor: () => Promise<undefined | unknown>;
+    state?: {
+        pageViewId?: string;
+    };
+}
+export interface PulseInstance extends TrackerInstance {
+    pulseTracker?: TrackerInstance;
+    trackElementView?: (eventInput: unknown) => Promise<void>;
+    trackElementClick?: (eventInput: unknown) => Promise<void>;
+    trackClickUIElement?: (eventInput: unknown) => Promise<void>;
+    trackViewUIElement?: (eventInput: unknown) => Promise<void>;
+    trackLegacyClickUIElement?: (eventInput: unknown) => Promise<void>;
+    trackLegacyViewUIElement?: (eventInput: unknown) => Promise<void>;
+}
+export interface Tracker {
+    clientId: string;
+    instance: TrackerInstance;
+    hasherUrl?: string;
+}
+export interface Pulse {
+    clientId: string;
+    instance: PulseInstance;
+}
+export interface EidsUserSource {
+    id: string;
+    source: string;
+}
+export interface UserIdsObject {
+    userIds: Array<AstUserIds>;
+}
+export interface PPIDLoggedInStatusKeywords {
+    'aa-sch-schuserhash': '1' | '0';
+    'aa-sch-schenvhash': '1' | '0';
+}
+export interface PPIDs {
+    ppid1: string;
+    ppid2: string;
+    idfv?: string | null;
+    anId?: string | null;
+}
+export interface PPIDv2Management {
+    processPPIDs: (tracker: Tracker, timeout: number) => Promise<void>;
+    getPPIDs: () => PPIDs;
+}
+export interface PPIDv3Management {
+    processPPIDs: (tracker: Tracker, country: Country) => Promise<void>;
+    getPPIDs: () => PPIDs;
+}
+export interface HashStorage {
+    plain: string | null;
+    hashed?: string | null;
+}
+export interface PPIDSCacheStorage {
+    clientId: HashStorage;
+    userId: HashStorage;
+    environmentId: HashStorage;
+    trackerType: HashStorage;
+    trackerVersion: HashStorage;
+    idfv?: HashStorage;
+    anId?: HashStorage;
+}
+export interface HasherPayload {
+    clientId: string | null;
+    trackerType: string | null;
+    trackerVersion: string | null;
+    userId: string | null;
+    environmentId: string | null;
+}
+export interface HasherResponse {
+    userId: string | null;
+    environmentId: string | null;
+}

package/types/features/interface/video.d.ts

@@ -0,0 +1,97 @@
+import { Country } from 'core/interface/countries';
+import { DeviceType } from 'core/interface/device';
+import { Keywords } from 'core/interface/ast';
+import { TCFConfig, GlimrConfig } from 'core/interface/config';
+export type ValidPlayerAspectRatios = '1-1' | '16-9' | '9-16' | 'responsive';
+export type ValidInstreamAspectRatios = '1-1' | '16-9' | '9-16' | '3-4';
+export type AdFormatKeywordCreator = (position: string) => string | undefined;
+export type AdFormationInvCodeCreator = (position: string, isUserPresentOnFrontPage?: boolean) => string;
+export interface BaseTag {
+    slug?: string;
+    enabled?: boolean;
+    id: string;
+    title: string;
+    metadata?: [{
+        url: string;
+        type: string;
+    }];
+}
+export interface Tag extends BaseTag {
+    type?: 'descriptor' | 'organization' | 'person' | 'place' | 'location' | 'event';
+}
+export interface VideoSection {
+    title: string;
+    id: string;
+    shortPath: string;
+    metadata: {
+        podcast_author?: string;
+        podcast_categoryTree?: string;
+        actingEditor?: string;
+        afp?: 'true';
+        sponsored?: 'true';
+        [property: string]: unknown;
+    };
+    parent: VideoSection;
+}
+export interface SiteVideoConfig {
+    publisher: string;
+    memberId: number;
+    sectionKeyword: string;
+    frontpageInvCodeTemplate: string;
+    additionalFilterKeys: Array<string>;
+    tcf: TCFConfig;
+    glimr: GlimrConfig;
+    country: Country;
+}
+export interface VideoAdParams {
+    invCode: string;
+    videoOverlayInvCode: string;
+    sections: string;
+}
+export interface GetVideoAdsKeywordsParams {
+    pageAdsKeywords?: Keywords;
+    tags: string;
+    sections: string;
+    isUserLoggedIn: boolean;
+    isUserPresentOnFrontPage: boolean;
+    isInitialVideo: boolean;
+    currentVideoId?: string;
+    instreamAspectRatio: number;
+    playerAspectRatio: number;
+    isApp: boolean;
+    isAndroidApp: boolean;
+    deviceType: DeviceType;
+}
+export type VideoParamsCreator = (section: VideoSection, isLiveStudio: boolean) => VideoAdParams | null;
+export interface ViewportInfo {
+    height: number;
+    width: number;
+}
+export interface VideoAdsConfigParams {
+    aspectRatio?: string;
+    tags: Array<Tag>;
+    assetSection: VideoSection;
+    publisher: string;
+    isApp: boolean;
+    pageAdsKeywords?: Keywords;
+    startMode: 'manual' | 'auto' | 'silent';
+    isUserLoggedIn: boolean;
+    isUsedInOverlayVideoPlayer?: boolean;
+    isLiveStudio: boolean;
+    assetId: string;
+    isAndroidApp: boolean;
+    deviceType: DeviceType;
+}
+export interface VideoStream {
+    attributes?: {
+        id?: number;
+    };
+}
+export interface GatheredAdData {
+    siteConfig: SiteVideoConfig;
+    siteVideoParams: VideoAdParams | null;
+    isUserPresentOnFrontPage: boolean;
+    adsKeywords: Keywords;
+    prerollPlacementFormat: string;
+    playbackMethod: number;
+}

package/types/features/kilkaya/Kilkaya.d.ts

@@ -0,0 +1,4 @@
+import { KilkayaComponentProps } from './types';
+import { ReactNode } from 'react';
+declare const Kilkaya: ({ placementName, slotTag, fallbackTargetId, children, pulseData, htmlAttributes }: KilkayaComponentProps) => ReactNode;
+export { Kilkaya };

package/types/features/kilkaya/index.d.ts

@@ -0,0 +1,4 @@
+import { SiteConfig } from 'core/interface/config';
+import { Kilkaya } from './Kilkaya';
+declare const runKilkaya: (siteConfig: SiteConfig) => Promise<void>;
+export { runKilkaya, Kilkaya };

package/types/features/kilkaya/kilkaya-manager.d.ts

@@ -0,0 +1,10 @@
+import { SiteConfig } from 'core/interface/config';
+declare class KilkayaManager {
+    private handleKilkayaStreamTracking;
+    private injectKilkayaMeta;
+    private observeForKilkayaBackfills;
+    private showBackfill;
+    private loadKilkayaScript;
+    run(siteConfig: SiteConfig): Promise<void>;
+}
+export { KilkayaManager };

package/types/features/kilkaya/pulse-manager/default-pulse-manager.d.ts

@@ -0,0 +1,17 @@
+import { PulseInstance } from 'features/interface/tracker';
+import { PageType } from 'core/interface/page-types';
+import { ElementSourceEventInputTarget, EventType, PulseManager, PulsePageType, Strategy } from '../types';
+declare class DefaultPulseManager implements PulseManager {
+    protected readonly pulse?: PulseInstance | undefined;
+    protected readonly newsroomStrategy?: Strategy | undefined;
+    constructor(pulse?: PulseInstance | undefined, newsroomStrategy?: Strategy | undefined);
+    protected getEventInput(root: HTMLElement, type: EventType): object;
+    protected parseKilkayaData(root: HTMLElement): Record<string, string>;
+    protected mapPageType(pageType?: PageType): PulsePageType;
+    protected getArticleId(): string;
+    protected getEventTarget(root: HTMLElement): ElementSourceEventInputTarget;
+    protected normalizePlacementTitle(title: string): string;
+    trackContentView(root: HTMLElement): Promise<void>;
+    trackContentClick(root: HTMLElement): Promise<void>;
+}
+export { DefaultPulseManager };

package/types/features/kilkaya/pulse-manager/index.d.ts

@@ -0,0 +1,3 @@
+import { NoPulseManager } from './no-pulse-manager';
+import { DefaultPulseManager } from './default-pulse-manager';
+export { NoPulseManager, DefaultPulseManager };

package/types/features/kilkaya/pulse-manager/no-pulse-manager.d.ts

@@ -0,0 +1,16 @@
+import { PulseManager, EventInputObject, EventType, Strategy, ElementSourceEventInputTarget } from '../types';
+import { PulseInstance } from 'features/interface/tracker';
+import { DefaultPulseManager } from './default-pulse-manager';
+import { PageType } from 'core/interface/page-types';
+declare class NoPulseManager extends DefaultPulseManager implements PulseManager {
+    protected readonly pulse?: PulseInstance | undefined;
+    protected readonly newsroomStrategy?: Strategy | undefined;
+    protected readonly pageType?: PageType | undefined;
+    constructor(pulse?: PulseInstance | undefined, newsroomStrategy?: Strategy | undefined, pageType?: PageType | undefined);
+    protected getEventBaseData(root: HTMLElement): EventInputObject;
+    protected getEventTarget(root: HTMLElement): ElementSourceEventInputTarget;
+    protected getEventInput(root: HTMLElement, type: EventType): object;
+    protected getEventPartnerstudioData(root: HTMLElement, type: EventType): object;
+    protected getProviderData(): object;
+}
+export { NoPulseManager };

package/types/features/kilkaya/strategies/default.d.ts

@@ -0,0 +1,7 @@
+import { Strategy } from '../types';
+import { PageType } from 'core/interface/page-types';
+declare class DefaultStrategy implements Strategy {
+    getPulseObjectId(): string;
+    getPulsePageId(pageType: PageType, articleId: string | undefined): string;
+}
+export { DefaultStrategy };

package/types/features/kilkaya/strategies/vg/index.d.ts

@@ -0,0 +1,7 @@
+import { Strategy } from 'features/kilkaya/types';
+declare class VGStrategy implements Strategy {
+    getPulseObjectId(): string;
+    getPulsePageId(): string;
+    getTags(root: HTMLElement | HTMLAnchorElement): Array<string>;
+}
+export { VGStrategy };

package/types/features/kilkaya/stream-tracker.d.ts

@@ -0,0 +1,5 @@
+import { Strategy } from 'features/kilkaya/types';
+import { PulseInstance } from 'features/interface/tracker';
+import { PageType } from 'core/interface/page-types';
+declare const observeKilkayaStreamElements: (pulse: PulseInstance, strategy: Strategy, pageType: PageType) => void;
+export { observeKilkayaStreamElements };