@streamlayer/feature-advertisement 1.0.0 → 1.1.1-rc.1342

package/lib/classic/cjs/units/ssai-preload.js

@@ -0,0 +1,72 @@
+'use strict';
+
+require('core-js/modules/es.array.iterator.js');
+require('core-js/modules/es.promise.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+var classic = require('@streamlayer/sdk-web-logger/classic');
+
+const log = classic.createLogger('ssai:preload');
+/**
+ * How long the overlay is willing to wait for artwork. A slow or dead image host
+ * must never hold the bar back — the ad is already playing, and a bar that shows
+ * late is worse than one that shows without its logo (the logo is hidden on error
+ * anyway). Warming the browser cache is the goal; blocking is not.
+ */
+const DEFAULT_PRELOAD_TIMEOUT_MS = 2000;
+/**
+ * Fetch images into the browser cache and resolve once they are all settled, or
+ * once `timeoutMs` elapses — whichever comes first. Never rejects: a creative
+ * whose artwork fails is still a creative worth showing.
+ */
+const preloadImages = (urls, timeoutMs = DEFAULT_PRELOAD_TIMEOUT_MS) => {
+  const targets = urls.filter(url => !!url);
+  // `Image` is absent in SSR/worker contexts; there is nothing to warm there.
+  if (targets.length === 0 || typeof Image === 'undefined') {
+    return Promise.resolve();
+  }
+  return new Promise(resolve => {
+    let settled = false;
+    let remaining = targets.length;
+    const finish = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      log.debug({
+        remaining
+      }, 'ssai preload timed out, showing anyway');
+      finish();
+    }, timeoutMs);
+    const one = () => {
+      remaining -= 1;
+      if (remaining <= 0) {
+        finish();
+      }
+    };
+    for (const url of targets) {
+      const image = new Image();
+      image.onload = one;
+      image.onerror = one;
+      image.src = url;
+    }
+  });
+};
+/**
+ * Warm every image the creative carries — the overlay's brand logo, and the
+ * companion banner for hosts that render one — so the bar fades in complete
+ * rather than popping its artwork in a beat later.
+ */
+const preloadCreativeAssets = (creative, timeoutMs) => {
+  var _creative$companion;
+  return preloadImages([creative.iconUrl, (_creative$companion = creative.companion) === null || _creative$companion === void 0 ? void 0 : _creative$companion.staticResource], timeoutMs);
+};
+
+exports.DEFAULT_PRELOAD_TIMEOUT_MS = DEFAULT_PRELOAD_TIMEOUT_MS;
+exports.preloadCreativeAssets = preloadCreativeAssets;
+exports.preloadImages = preloadImages;

package/lib/classic/cjs/units/ssai-providers.js

@@ -0,0 +1,299 @@
+'use strict';
+
+var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
+require('core-js/modules/es.error.cause.js');
+require('core-js/modules/es.array.iterator.js');
+require('core-js/modules/es.promise.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.iterator.find.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/web.dom-exception.stack.js');
+var classic = require('@streamlayer/sdk-web-logger/classic');
+var vastClient = require('@dailymotion/vast-client');
+
+const log = classic.createLogger('ssai:provider');
+const DEFAULT_CREATIVE_API_BASE = 'https://hls.next.streamlayer.io/api/creatives/';
+/**
+ * Shared low-level beacon helper. Prefers `navigator.sendBeacon` and falls back
+ * to a no-cors `fetch`. Used by the default impression path and available to
+ * providers that fire URL-based tracking pixels.
+ */
+const fireBeacon = url => {
+  try {
+    if (typeof navigator !== 'undefined' && typeof navigator.sendBeacon === 'function') {
+      navigator.sendBeacon(url);
+    } else {
+      void fetch(url, {
+        mode: 'no-cors'
+      }).catch(error => {
+        log.warn(error, 'ssai beacon failed');
+      });
+    }
+  } catch (error) {
+    log.warn(error, 'ssai beacon failed');
+  }
+};
+const resolveAdvertiser = (advertiser, title) => {
+  if (advertiser) {
+    return advertiser;
+  }
+  if (title) {
+    return title;
+  }
+  return 'Ad';
+};
+const buildCreativeUrl = (base, creativeId) => {
+  const normalizedBase = base.endsWith('/') ? base : `${base}/`;
+  return `${normalizedBase}${encodeURIComponent(creativeId)}`;
+};
+const mapApiResponse = raw => {
+  const trackingEvents = Array.isArray(raw.trackingEvents) ? raw.trackingEvents.filter(entry => Boolean((entry === null || entry === void 0 ? void 0 : entry.event) && (entry === null || entry === void 0 ? void 0 : entry.url))).map(entry => ({
+    event: entry.event,
+    url: entry.url
+  })) : [];
+  const rawCompanion = Array.isArray(raw.companions) ? raw.companions.find(entry => !!(entry !== null && entry !== void 0 && entry.staticResource)) : undefined;
+  const companion = rawCompanion !== null && rawCompanion !== void 0 && rawCompanion.staticResource ? {
+    staticResource: rawCompanion.staticResource,
+    width: Number(rawCompanion.width) || 0,
+    height: Number(rawCompanion.height) || 0,
+    clickThrough: rawCompanion.clickThrough,
+    clickTracking: Array.isArray(rawCompanion.clickTracking) ? rawCompanion.clickTracking.filter(url => typeof url === 'string' && !!url) : []
+  } : undefined;
+  return {
+    creativeId: raw.creativeId,
+    advertiser: resolveAdvertiser(raw.advertiser, raw.title),
+    title: raw.title || resolveAdvertiser(raw.advertiser, raw.title),
+    iconUrl: raw.iconUrl || undefined,
+    clickThroughUrl: raw.clickThroughUrl || undefined,
+    trackingEvents,
+    companion
+  };
+};
+/**
+ * Fire every tracking event with the given name, and report how many went out.
+ *
+ * ALL matches, not the first: the creative contract states that a creative may
+ * repeat an `event` value to carry several URLs, and that consumers must not
+ * assume uniqueness. Today's payloads carry one URL per event, so this is not a
+ * change in what goes on the wire — it just stops being wrong the day a server
+ * sends two.
+ */
+const fireTrackingEvents = (creative, event) => {
+  const matches = creative.trackingEvents.filter(entry => entry.event === event);
+  for (const match of matches) {
+    fireBeacon(match.url);
+  }
+  return matches.length;
+};
+/**
+ * Shared default impression behavior: fire the `impression` tracking events.
+ * Used by the StreamLayer provider and as the fallback in
+ * {@link SsaiCreativeCache} when a provider doesn't override `fireImpression`.
+ * Exported so both call sites share one definition.
+ */
+const fireDefaultImpression = creative => {
+  fireTrackingEvents(creative, 'impression');
+};
+/**
+ * StreamLayer's internal creative provider. Resolves creatives from the JSON
+ * creative API (`GET {creativeApiBase}{encodeURIComponent(creativeId)}`) and
+ * fires impressions from the `'impression'` tracking event via `sendBeacon`.
+ */
+const createStreamLayerProvider = (config = {}) => {
+  var _config$creativeApiBa;
+  const creativeApiBase = (_config$creativeApiBa = config.creativeApiBase) !== null && _config$creativeApiBa !== void 0 ? _config$creativeApiBa : DEFAULT_CREATIVE_API_BASE;
+  return {
+    id: 'streamlayer',
+    resolve: function () {
+      var _ref = _rollupPluginBabelHelpers.asyncToGenerator(function* (creativeId, signal) {
+        const url = buildCreativeUrl(creativeApiBase, creativeId);
+        const response = yield fetch(url, {
+          signal
+        });
+        if (!response.ok) {
+          throw new Error(`creative request failed: ${response.status}`);
+        }
+        const raw = yield response.json();
+        return mapApiResponse(_rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, raw), {}, {
+          creativeId: raw.creativeId || creativeId
+        }));
+      });
+      return function resolve(_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }(),
+    fireImpression: fireDefaultImpression
+  };
+};
+const buildQuortexUrl = (base, tenantName, adId) => {
+  // Deliberately string concatenation rather than `URL`/`URLSearchParams`: this
+  // package ships to 2016-era TV engines (see the chrome-32 classic build).
+  const separator = base.indexOf('?') === -1 ? '?' : '&';
+  const tenant = tenantName ? `TenantName=${encodeURIComponent(tenantName)}&` : '';
+  return `${base}${separator}${tenant}adID=${encodeURIComponent(adId)}&info=1`;
+};
+/**
+ * Quortex / Synamedia DAI ad metadata provider.
+ *
+ * `GET {adApiBase}?TenantName={tenantName}&adID={adId}&info=1` (the `TenantName`
+ * part omitted when `adApiBase` already carries it) — the ad id comes
+ * from the manifest's `X-AD-ID` DATERANGE attribute (see `ssai-detector.ts`, which
+ * reconstructs the ad window from the tracking-marker burst those tags form).
+ *
+ * The response is byte-compatible with the StreamLayer creative API, so the same
+ * `mapApiResponse` normalizes both.
+ *
+ * Known limitation: impressions fire the `impression` tracking event from the API
+ * response, not the per-session beacon the manifest carries in `X-AD-URL`. The two
+ * differ in `trackingid`/`USERID`, so Quortex-side attribution will see the
+ * generic id rather than the viewer's session until the manifest beacons are
+ * plumbed through to the provider.
+ */
+const createQuortexProvider = (config = {}) => {
+  const {
+    adApiBase,
+    tenantName
+  } = config;
+  if (!adApiBase) {
+    // Loud, but not thrown: this runs inside the host's render effect via
+    // `startSsaiMonitoring`, and taking the app down over a config typo is worse
+    // than an overlay that never appears and says why.
+    log.error({
+      adApiBase,
+      tenantName
+    }, 'quortex provider requires `adApiBase`');
+  }
+  return {
+    id: 'quortex',
+    resolve: function () {
+      var _ref2 = _rollupPluginBabelHelpers.asyncToGenerator(function* (adId, signal) {
+        if (!adApiBase) {
+          throw new Error('quortex provider is missing `adApiBase`');
+        }
+        const response = yield fetch(buildQuortexUrl(adApiBase, tenantName, adId), {
+          signal
+        });
+        if (!response.ok) {
+          throw new Error(`quortex creative request failed: ${response.status}`);
+        }
+        const raw = yield response.json();
+        return mapApiResponse(_rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, raw), {}, {
+          creativeId: raw.creativeId || adId
+        }));
+      });
+      return function resolve(_x3, _x4) {
+        return _ref2.apply(this, arguments);
+      };
+    }(),
+    fireImpression: fireDefaultImpression
+  };
+};
+// --- VAST provider ---------------------------------------------------------
+const mapVastResponse = /*#__PURE__*/function () {
+  var _ref3 = _rollupPluginBabelHelpers.asyncToGenerator(function* (creativeId, signal) {
+    var _validAd$advertiser$f;
+    const vastClient$1 = new vastClient.VASTClient();
+    const parsedVAST = yield vastClient$1.get(creativeId, {
+      timeout: 8000
+    });
+    if (signal.aborted) {
+      throw new DOMException('aborted', 'AbortError');
+    }
+    const validAd = parsedVAST.ads.find(ad => ad.creatives.length > 0);
+    if (!validAd) {
+      throw new Error('no_valid_ad');
+    }
+    const advertiserValue = Array.isArray(validAd.advertiser) ? (_validAd$advertiser$f = validAd.advertiser.find(entry => !!(entry !== null && entry !== void 0 && entry.value))) === null || _validAd$advertiser$f === void 0 ? void 0 : _validAd$advertiser$f.value : undefined;
+    const advertiser = resolveAdvertiser(advertiserValue, validAd.title || undefined);
+    let iconUrl;
+    let clickThroughUrl;
+    let companion;
+    for (const creative of validAd.creatives) {
+      if (creative.type === 'linear') {
+        var _linear$icons, _linear$videoClickThr;
+        const linear = creative;
+        iconUrl = iconUrl || ((_linear$icons = linear.icons) === null || _linear$icons === void 0 || (_linear$icons = _linear$icons.find(icon => !!(icon !== null && icon !== void 0 && icon.staticResource))) === null || _linear$icons === void 0 ? void 0 : _linear$icons.staticResource) || undefined;
+        clickThroughUrl = clickThroughUrl || ((_linear$videoClickThr = linear.videoClickThroughURLTemplate) === null || _linear$videoClickThr === void 0 ? void 0 : _linear$videoClickThr.url);
+      }
+      if (creative.type === 'companion') {
+        var _creative$variations, _variation$staticReso;
+        const variation = (_creative$variations = creative.variations) === null || _creative$variations === void 0 ? void 0 : _creative$variations[0];
+        const staticResource = variation === null || variation === void 0 || (_variation$staticReso = variation.staticResources) === null || _variation$staticReso === void 0 || (_variation$staticReso = _variation$staticReso[0]) === null || _variation$staticReso === void 0 ? void 0 : _variation$staticReso.url;
+        if (staticResource && !companion) {
+          var _variation$companionC, _variation$companionC2;
+          companion = {
+            staticResource,
+            width: Number(variation === null || variation === void 0 ? void 0 : variation.width) || 0,
+            height: Number(variation === null || variation === void 0 ? void 0 : variation.height) || 0,
+            clickThrough: variation === null || variation === void 0 || (_variation$companionC = variation.companionClickThroughURLTemplate) === null || _variation$companionC === void 0 ? void 0 : _variation$companionC.url,
+            clickTracking: ((_variation$companionC2 = variation === null || variation === void 0 ? void 0 : variation.companionClickTrackingURLTemplates) !== null && _variation$companionC2 !== void 0 ? _variation$companionC2 : []).map(entry => entry === null || entry === void 0 ? void 0 : entry.url).filter(url => !!url)
+          };
+        }
+      }
+    }
+    return {
+      creativeId,
+      advertiser,
+      title: validAd.title || advertiser,
+      iconUrl,
+      clickThroughUrl,
+      trackingEvents: [],
+      companion
+    };
+  });
+  return function mapVastResponse(_x5, _x6) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+/**
+ * Maps a VAST tag into the normalized SsaiCreative shape.
+ *
+ * Note: `fireImpression` is intentionally left to the shared default for now.
+ * Proper VAST impression/tracking wiring through `VASTTracker` is a documented
+ * follow-up; it requires retaining the parsed ad/tracker per creative.
+ */
+const createVastProvider = (_config = {}) => {
+  return {
+    id: 'vast',
+    resolve: mapVastResponse
+  };
+};
+/** Built-in provider factories keyed by name. */
+const BUILTIN_PROVIDERS = {
+  streamlayer: config => createStreamLayerProvider(config),
+  quortex: config => createQuortexProvider(config),
+  vast: () => createVastProvider()
+};
+const isProviderInstance = option => {
+  return typeof option === 'object' && typeof option.resolve === 'function';
+};
+/**
+ * Resolve a {@link SsaiProviderOption} into a concrete {@link SsaiCreativeProvider}.
+ * Defaults to the StreamLayer provider (using `fallbackConfig`) when no option is
+ * supplied.
+ */
+const resolveProvider = (option, fallbackConfig) => {
+  var _option$config;
+  if (!option) {
+    return createStreamLayerProvider(fallbackConfig);
+  }
+  if (typeof option === 'string') {
+    return BUILTIN_PROVIDERS[option](fallbackConfig);
+  }
+  if (isProviderInstance(option)) {
+    return option;
+  }
+  return BUILTIN_PROVIDERS[option.name]((_option$config = option.config) !== null && _option$config !== void 0 ? _option$config : fallbackConfig);
+};
+
+exports.BUILTIN_PROVIDERS = BUILTIN_PROVIDERS;
+exports.DEFAULT_CREATIVE_API_BASE = DEFAULT_CREATIVE_API_BASE;
+exports.createQuortexProvider = createQuortexProvider;
+exports.createStreamLayerProvider = createStreamLayerProvider;
+exports.createVastProvider = createVastProvider;
+exports.fireBeacon = fireBeacon;
+exports.fireDefaultImpression = fireDefaultImpression;
+exports.fireTrackingEvents = fireTrackingEvents;
+exports.resolveProvider = resolveProvider;

package/lib/classic/cjs/units/vast-tracker.js

@@ -0,0 +1,81 @@
+'use strict';
+
+var vastClient = require('@dailymotion/vast-client');
+
+/**
+ * One place that constructs a `VASTTracker`.
+ *
+ * Every StreamLayer surface that reports VAST beacons — the GAM video player, both pause-ad
+ * renderers and the Standard Ad sidebar — needs the same `(ad, creative, variation)` triple, and
+ * each was assembling it by hand behind its own `@ts-ignore`. The parsed shapes those triples
+ * come from (`AdData` / `AdCompanion` / `AdNonLinear`) are defined in this package, so the
+ * mapping belongs here too.
+ *
+ * Deliberately *only* construction: when a beacon may fire, and how a surface de-duplicates its
+ * impression, stays with that surface. Those policies differ on purpose (per-ad-id in module
+ * scope for the sidebar, per component instance for the pause ads, per tracker identity for the
+ * player) and they are billing-visible, so collapsing them here would silently change counts.
+ */
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="../module.d.ts" />
+const createVastTracker = ({
+  ad,
+  creative,
+  variation
+}) =>
+// The first argument is the `VASTClient` the tracker may update; every surface here drives
+// playback itself and only wants the beacons, so it is always `null`.
+//
+// The type shim declares the 3rd argument as `VastCreativeLinear` and the 4th as another
+// *creative*. At runtime `vast-client` accepts any creative in the 3rd and expects the
+// `<Companion>` / `<NonLinear>` *variation* in the 4th. The casts encode that runtime contract
+// once here rather than at every call site.
+new vastClient.VASTTracker(null, ad, creative, variation);
+/**
+ * A tracker for a single `<Companion>`. A `<CompanionAds>` creative has no creative-level
+ * `<TrackingEvents>` — each variation owns its own `creativeView` — so a companion is reported
+ * through its own tracker. `undefined` when the companion was parsed without them (nothing to
+ * report against).
+ */
+const createCompanionTracker = (ad, companion) => companion.creative && companion.variation ? createVastTracker({
+  ad,
+  creative: companion.creative,
+  variation: companion.variation
+}) : undefined;
+/**
+ * The creative a parsed ad reports its impression / playback beacons through, in the order the
+ * shells draw them: the `<Linear>` creative first, then the `<NonLinear>` still, then — for a tag
+ * whose only creative is `<CompanionAds>` — the companion that was actually drawn.
+ *
+ * `drawnCompanion` is a parameter rather than `adData.companion` because only the rendering shell
+ * knows which companion reached the screen, and reporting one that did not is a false view.
+ */
+const resolveVastTrackerTarget = (adData, drawnCompanion) => {
+  // `AdData.creative` is not optional in the type but `getCreative` can return nothing: a
+  // programmatic tag does not have to carry a `<Linear>` creative.
+  if (adData.creative) {
+    return {
+      ad: adData.ad,
+      creative: adData.creative
+    };
+  }
+  if (adData.nonLinear) {
+    return {
+      ad: adData.ad,
+      creative: adData.nonLinear.creative,
+      variation: adData.nonLinear.variation
+    };
+  }
+  if (drawnCompanion !== null && drawnCompanion !== void 0 && drawnCompanion.creative && drawnCompanion.variation) {
+    return {
+      ad: adData.ad,
+      creative: drawnCompanion.creative,
+      variation: drawnCompanion.variation
+    };
+  }
+  return undefined;
+};
+
+exports.createCompanionTracker = createCompanionTracker;
+exports.createVastTracker = createVastTracker;
+exports.resolveVastTrackerTarget = resolveVastTrackerTarget;

package/lib/classic/index.js

@@ -0,0 +1,28 @@
+import { Advertisement } from './advertisement.js';
+export { isFullbleedVideoTemplate } from './units/external-pause-ad.js';
+export { INSIGHT_BODY_MAX_LENGTH } from './units/pause-ad-card.js';
+export { gam } from './units/gam.js';
+export { createCompanionTracker, createVastTracker, resolveVastTrackerTarget } from './units/vast-tracker.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+export { BUILTIN_PROVIDERS, DEFAULT_CREATIVE_API_BASE, createQuortexProvider, createStreamLayerProvider, createVastProvider, fireBeacon, fireTrackingEvents, resolveProvider } from './units/ssai-providers.js';
+export { DEFAULT_PRELOAD_TIMEOUT_MS, preloadCreativeAssets, preloadImages } from './units/ssai-preload.js';
+
+const advertisement = (instance, _opts, done) => {
+  instance.sdk.advertisement = new Advertisement(instance);
+  instance.sdk.onMount({
+    name: 'advertisement'
+  }, () => {
+    instance.sdk.advertisement.connect();
+    return () => {
+      instance.sdk.advertisement.disconnect();
+    };
+  });
+  done();
+};
+
+export { advertisement };