@streamlayer/feature-advertisement 1.1.1-rc.8.pd3aefe41 → 1.2.0

package/lib/cjs/units/ssai-creative.js

@@ -1,136 +0,0 @@
-'use strict';
-
-var ssaiProviders = require('./ssai-providers.js');
-
-/**
- * Per-instance cache + impression-firing wrapper around a SsaiCreativeProvider.
- * Caches resolved creatives by creativeId so repeated active-ad polls and pod
- * repeats don't refetch. In-flight fetches are cancellable via AbortController.
- */
-class SsaiCreativeCache {
-    provider;
-    cache = new Map();
-    inflight = new Map();
-    constructor(provider) {
-        this.provider = provider;
-    }
-    /**
-     * The already-resolved creative, or undefined — synchronous on purpose: a
-     * prefetched creative lets the ad break flip straight to 'ready' with no
-     * async gap (which the UI would render as a blink between two ads of a pod).
-     */
-    peek = (creativeId) => this.cache.get(creativeId);
-    resolve = (creativeId) => {
-        const cached = this.cache.get(creativeId);
-        if (cached) {
-            return Promise.resolve(cached);
-        }
-        const existing = this.inflight.get(creativeId);
-        if (existing) {
-            return existing.promise;
-        }
-        const controller = new AbortController();
-        const promise = this.provider
-            .resolve(creativeId, controller.signal)
-            .then((creative) => {
-            this.cache.set(creativeId, creative);
-            this.inflight.delete(creativeId);
-            return creative;
-        })
-            .catch((error) => {
-            this.inflight.delete(creativeId);
-            throw error;
-        });
-        this.inflight.set(creativeId, { promise, controller });
-        return promise;
-    };
-    /**
-     * Cancel an in-flight fetch (e.g. the break ended before it resolved).
-     */
-    cancel = (creativeId) => {
-        const existing = this.inflight.get(creativeId);
-        if (existing) {
-            existing.controller.abort();
-            this.inflight.delete(creativeId);
-        }
-    };
-    /**
-     * Fire the impression for a creative. Delegates to the provider's
-     * `fireImpression` when present, otherwise the shared default (first
-     * trackingEvent named 'impression' via sendBeacon/fetch). Called once per
-     * visible appearance of the bar (the UI dedupes the ~250ms active-poll so a
-     * single continuous appearance fires exactly one impression). Each genuine pod
-     * insertion of the same creative is a distinct impression and re-fires.
-     */
-    fireImpression = (creative) => {
-        if (this.provider.fireImpression) {
-            this.provider.fireImpression(creative);
-            return;
-        }
-        ssaiProviders.fireDefaultImpression(creative);
-    };
-    /**
-     * Fire the impression for an already-resolved creativeId. No-op if the
-     * creative isn't cached yet (the bar only renders once resolved, so by the
-     * time the UI calls this the creative is present).
-     */
-    fireImpressionById = (creativeId) => {
-        const creative = this.cache.get(creativeId);
-        if (creative) {
-            this.fireImpression(creative);
-        }
-    };
-    /**
-     * Fire a lifecycle / click beacon. Delegates to the provider's `fireTracking`
-     * when it defines one, otherwise fires every matching `trackingEvents` URL.
-     */
-    fireTracking = (creative, event) => {
-        if (this.provider.fireTracking) {
-            this.provider.fireTracking(creative, event);
-            return;
-        }
-        ssaiProviders.fireTrackingEvents(creative, event);
-    };
-    /**
-     * Fire a beacon for a creativeId that may still be resolving.
-     *
-     * `start` in particular lands the instant the break opens, which is usually
-     * BEFORE the metadata request has come back — dropping it would silently lose
-     * the first beacon of every ad. Resolution is already in flight by then and
-     * `resolve` returns that same promise, so this attaches to it rather than
-     * issuing a second request. A creative that never resolves fires nothing,
-     * which is the correct outcome: there are no URLs to fire.
-     */
-    fireTrackingById = (creativeId, event) => {
-        const cached = this.cache.get(creativeId);
-        if (cached) {
-            this.fireTracking(cached, event);
-            return;
-        }
-        this.resolve(creativeId)
-            .then((creative) => this.fireTracking(creative, event))
-            .catch(() => undefined);
-    };
-    /**
-     * Fire the companion's `clickTracking` beacons. Separate from
-     * {@link fireTracking} because these live on the companion, not in
-     * `trackingEvents` — a provider's `fireTracking` override has no say over them.
-     */
-    fireCompanionClickById = (creativeId) => {
-        const companion = this.cache.get(creativeId)?.companion;
-        if (!companion) {
-            return;
-        }
-        for (const url of companion.clickTracking) {
-            ssaiProviders.fireBeacon(url);
-        }
-    };
-    destroy = () => {
-        this.inflight.forEach((entry) => entry.controller.abort());
-        this.inflight.clear();
-        this.cache.clear();
-    };
-}
-
-exports.DEFAULT_CREATIVE_API_BASE = ssaiProviders.DEFAULT_CREATIVE_API_BASE;
-exports.SsaiCreativeCache = SsaiCreativeCache;

package/lib/cjs/units/ssai-detector.d.ts

@@ -1,180 +0,0 @@
-import type { SsaiProgressEvent } from './ssai-creative.js';
-export type SsaiDateRange = {
-    id: string;
-    creativeId: string;
-    startMs: number;
-    durationSec: number;
-    endMs: number;
-    /**
-     * Exact program times of lifecycle events, when the stream's tracking markers
-     * state them (Synamedia dialect). `updateProgress` prefers these over fractions
-     * of the window — the markers are the ad server's own quartile schedule, and
-     * they stay honest even while the window's end is still provisional.
-     */
-    progressAtMs?: Partial<Record<SsaiProgressEvent, number>>;
-};
-/** hls.js `Level`, structurally: `uri` is a string, legacy `url` a string[]. */
-type HlsLikeLevel = {
-    uri?: string;
-    url?: string | string[];
-} & Record<string, unknown>;
-export type HlsLike = {
-    on: (event: string, handler: (...args: unknown[]) => void) => void;
-    off: (event: string, handler: (...args: unknown[]) => void) => void;
-    media?: HTMLVideoElement | null;
-    /**
-     * hls.js' level list and level selection, used only to resolve the active
-     * media playlist's URL for the supplemental live-edge poll (see
-     * `LIVE_EDGE_POLL_MS`). All optional — a minimal host player simply gets no
-     * supplement.
-     */
-    levels?: HlsLikeLevel[] | null;
-    currentLevel?: number;
-    loadLevel?: number;
-    /**
-     * hls.js' own PROGRAM-DATE-TIME of the frame on screen right now. When the host
-     * exposes it this is the best answer available — hls.js derives it from the
-     * playlist it is actually playing, so it needs no origin of ours and cannot
-     * drift as the live window slides.
-     */
-    playingDate?: Date | null;
-    /**
-     * hls.js live-latency diagnostics. Never used for detection — only surfaced by
-     * `getDebugSnapshot` so the debug window can cross-check the program clock
-     * against the player's own view of how far behind live it is. All optional:
-     * a minimal host player (or the e2e stub) simply reports them as unavailable.
-     */
-    latency?: number;
-    drift?: number;
-    liveSyncPosition?: number | null;
-    targetLatency?: number | null;
-};
-export type SsaiDetectorOptions = {
-    player?: HlsLike;
-    videoRef?: HTMLVideoElement;
-    manifestUrl?: string;
-    /**
-     * A creative id was seen in the manifest for the first time — typically
-     * seconds before its break starts, since the viewer's playhead trails the
-     * live edge. This is the prefetch hook: resolve the creative and warm its
-     * artwork here and the bar can show the instant the break begins.
-     */
-    onAdDiscovered?: (creativeId: string) => void;
-    onBreakStart: (range: SsaiDateRange) => void;
-    onCreativeChange: (range: SsaiDateRange) => void;
-    /**
-     * The active ad's window ends within `AD_ENDING_LEAD_MS`. Fired once per
-     * airing while a break is active — the UI's cue to start its closing
-     * animation early enough to complete at the boundary. Purely presentational:
-     * beacons and break bookkeeping are unaffected.
-     */
-    onAdEnding?: (range: SsaiDateRange) => void;
-    onBreakEnd: () => void;
-    /**
-     * Playback reached a lifecycle milestone of the given ad. Fires at most once
-     * per event per playthrough, in order, and is INDEPENDENT of whether the
-     * overlay is on screen — the ad is stitched into the stream, so it plays (and
-     * must be reported) whether or not the viewer dismissed the bar.
-     */
-    onProgress?: (range: SsaiDateRange, event: SsaiProgressEvent) => void;
-};
-/** One `X-AD-EVENT-TYPE` marker: an instant in program time, not a window. */
-export type SsaiTrackingMarker = {
-    id: string;
-    adId: string;
-    event: string;
-    timeMs: number;
-    /** Per-session beacon from `X-AD-URL`, kept for diagnostics. */
-    url?: string;
-};
-/** A `com.synamedia.dai.adbreak` range — the whole break, with no ad identity. */
-type SsaiAdBreakWindow = {
-    id: string;
-    startMs: number;
-    endMs: number;
-};
-/**
- * Reconstruct one ad window per AIRING of an `X-AD-ID` from its tracking
- * markers: earliest marker (impression/start) to latest (complete).
- *
- * `breaks` separates re-airings of the same creative (see above) and is the
- * fallback end: until the `complete` marker shows up, an airing whose markers
- * all share one timestamp would fold to a zero-length window and never display;
- * when an enclosing adbreak range covers it, its end is used instead, and the
- * window tightens on the refresh that brings `complete` in.
- *
- * Exported for unit tests only — production code reaches it through the
- * detector.
- */
-export declare const foldTrackingMarkers: (markers: SsaiTrackingMarker[], breaks: SsaiAdBreakWindow[]) => SsaiDateRange[];
-/** Which source `currentProgramTimeMs()` is answering from right now. */
-export type SsaiClockSource = 'playingDate' | 'pdt-origin' | 'waiting-for-pdt' | 'wall-clock';
-export type SsaiDebugEvent = {
-    wallMs: number;
-    /** Program time at the moment of the event (NaN while the clock is unmapped). */
-    programMs: number;
-    type: string;
-    detail?: string;
-};
-export type SsaiDebugRange = SsaiDateRange & {
-    /** 'daterange' = explicit creative DATERANGE; 'markers' = window folded from tracking markers. */
-    source: 'daterange' | 'markers';
-};
-export type SsaiDebugSnapshot = {
-    wallMs: number;
-    /** Program time of the on-screen frame per the detector's clock (NaN while unmapped). */
-    programMs: number;
-    clockSource: SsaiClockSource;
-    /** How the detector is attached: hls.js events, native manifest polling, or nothing. */
-    attachMode: 'hls' | 'manifest-poll' | 'none';
-    /** hls.js `playingDate`, NaN when the host doesn't expose it. */
-    playingDateMs: number;
-    /** The alternate mapping `programTimeOriginMs + video.currentTime` — cross-check against playingDate. */
-    pdtOriginProgramMs: number;
-    programTimeOriginMs: number;
-    hls: {
-        latencySec: number;
-        driftSec: number;
-        liveSyncPositionSec: number;
-        targetLatencySec: number;
-    } | null;
-    video: {
-        currentTimeSec: number;
-        bufferedEndSec: number;
-        seekableEndSec: number;
-        paused: boolean;
-        playbackRate: number;
-        readyState: number;
-    } | null;
-    /** Every ad window the detector knows, sorted by start. */
-    ranges: SsaiDebugRange[];
-    markerCount: number;
-    adBreakCount: number;
-    breakActive: boolean;
-    breakSuppressed: boolean;
-    activeRangeId: string | null;
-    activeCreativeId: string | null;
-    progress: {
-        rangeId: string;
-        creativeId: string;
-        fired: SsaiProgressEvent[];
-    } | null;
-    /** Ring buffer (newest last, capped) of detector edges: discovery, drops, start/end, beacons. */
-    events: SsaiDebugEvent[];
-};
-export type SsaiDetector = {
-    destroy: () => void;
-    /**
-     * Mark the currently active break as user-dismissed: the detector keeps
-     * tracking it (so it knows when it ends) but stops re-showing the bar on
-     * creative changes until the break ends. A subsequent break shows again.
-     */
-    dismissActiveBreak: () => void;
-    /**
-     * Read-only timing introspection for the debug window. Safe to call at any
-     * frequency; never affects detection.
-     */
-    getDebugSnapshot: () => SsaiDebugSnapshot;
-};
-export declare const createSsaiDetector: (options: SsaiDetectorOptions) => SsaiDetector;
-export {};