@streamlayer/feature-advertisement 1.0.0 → 1.1.1-rc.10.p6eb7304a

package/lib/classic/units/pause-ad.js

@@ -0,0 +1,70 @@
+import { asyncToGenerator as _asyncToGenerator } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { createLogger } from '@streamlayer/sdk-web-logger/classic';
+import { atom } from 'nanostores';
+import '@streamlayer/sdk-web-api/classic';
+import '@streamlayer/sdk-web-core/classic/store';
+import { Feed } from '@streamlayer/sl-eslib/interactive/feed/interactive.feed_pb';
+import { parsePauseAdCards } from './pause-ad-card.js';
+
+const log = createLogger('advertisement:pause-ad');
+const pauseAdListStore = instance => {
+  const $slStreamId = instance.stores.slStreamId.getAtomStore();
+  return ($enabled, options) => {
+    const {
+      client,
+      queryKey
+    } = instance.transport.createPromiseClient(Feed, {
+      method: 'pauseAdList',
+      params: [$slStreamId, $enabled]
+    });
+    const $list = instance.transport.nanoquery.createFetcherStore(queryKey, {
+      dedupeTime: 0,
+      revalidateInterval: options.refetchInterval > 0 ? options.refetchInterval : 0,
+      fetcher: function () {
+        var _ref = _asyncToGenerator(function* (_, __, eventId, isEnabled) {
+          var _res$data;
+          if (!eventId || typeof eventId !== 'string' || !isEnabled) {
+            return [];
+          }
+          log.debug({
+            eventId
+          }, 'fetching pause ad list');
+          const res = yield client.pauseAdList({
+            eventId
+          });
+          const cards = parsePauseAdCards((_res$data = res.data) !== null && _res$data !== void 0 ? _res$data : []);
+          log.debug({
+            count: cards.length
+          }, 'parsed %d fullbleed pause ad cards');
+          return cards;
+        });
+        return function fetcher(_x, _x2, _x3, _x4) {
+          return _ref.apply(this, arguments);
+        };
+      }()
+    });
+    const $index = atom(0);
+    const next = () => {
+      const list = $list.get().data;
+      if (!(list !== null && list !== void 0 && list.length)) return;
+      $index.set(($index.get() + 1) % list.length);
+    };
+    const reset = () => {
+      $index.set(0);
+    };
+    const getCurrent = () => {
+      const list = $list.get().data;
+      if (!(list !== null && list !== void 0 && list.length)) return undefined;
+      return list[$index.get()];
+    };
+    return {
+      $list,
+      $index,
+      next,
+      reset,
+      getCurrent
+    };
+  };
+};
+
+export { pauseAdListStore };

package/lib/classic/units/sponsor-logo.js

@@ -0,0 +1,197 @@
+import 'core-js/modules/es.array.push.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.iterator.map.js';
+
+/**
+ * Sponsor-logo slot selection for a **feature** ad unit (Insight, Prediction and Trivia today;
+ * Poll is the same shape and is a separate ticket).
+ *
+ * Deliberately NOT `selectCompanions` (`./external-ad.ts`). That rule is the *display*-unit rule:
+ * it promotes a companion to the logo slot only when the tag ships an exact 300x75 `<Companion>`
+ * next to at least one other. A feature ad-unit tag is typically a **single** creative — often a
+ * lone NonLinear `<StaticResource>` — where the ad IS the logo, which is exactly the shape that
+ * rule returns nothing for. `selectCompanions` stays untouched: SC-335's three shipped units
+ * depend on its exact behaviour and impression counts are billing-visible.
+ *
+ * Mirrors iOS `SLRVASTSlotRole.logo` + `SLRVASTAssetPool`
+ * (`StreamLayerSDK/Frameworks/SLRGAMFramework/Sources/VASTSlotFiller/`):
+ *
+ * - **Images only.** A video-only tag yields no logo. `<Icon>` is never projected — icons hang off
+ *   the `<Linear>` creative, which this selector does not look at. A `<StaticResource>` the tag
+ *   declares as a non-image `creativeType` is skipped too, so a companion that lists a script
+ *   before its image still resolves to the image (see `isImageResource`).
+ * - **Origin-agnostic.** A lone NonLinear `<StaticResource>` is as valid as a `<Companion>`.
+ * - **Aspect-dominant** toward 1:1: the smallest `|log(assetAspect) - log(1)|` wins, ties broken by
+ *   larger area, then by higher pixel density. Aspect is a *preference, never a filter* — the only
+ *   hard constraint is the asset kind, so a badly shaped asset still wins if it is the only one.
+ * - Assets whose intrinsic size the tag never declared rank last, but still beat nothing.
+ *
+ * The module also hosts iOS's second logo role, `SLRVASTSlotRole.cardLogo` (`selectCardLogo`) —
+ * the same ranking narrowed to `<Companion>` origins, for the hero-card display units.
+ */
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="../module.d.ts" />
+/** `width`/`height` are XML attributes (strings at runtime); 0 and NaN both mean "not declared". */
+const toSize = value => {
+  const size = Number(value);
+  return size > 0 ? size : undefined;
+};
+/**
+ * VAST 4 `<CompanionAds pxratio>`; `@dailymotion/vast-client` defaults it to `'1'` and the
+ * `@types/vast-client` shim does not declare it, hence the loose read.
+ */
+const toPxRatio = variation => {
+  return Number(variation.pxratio) || 1;
+};
+/**
+ * `<StaticResource creativeType>`. The slot draws an `<img>`, so a resource the tag declares as
+ * anything else — the `application/x-shockwave-flash` or `application/javascript` creative a
+ * companion may list beside its image — must never fill it: it would swap the proto logo for a
+ * broken image AND still fire an impression for something nobody ever saw.
+ *
+ * An ABSENT type is not a rejection. VAST requires the attribute but real GAM image companions
+ * routinely omit it, and this module's only hard constraint is the asset kind, so an undeclared
+ * type stays a candidate. `@dailymotion/vast-client` writes `0` for a missing NonLinear
+ * `creativeType` and `null` for a missing companion one; both are falsy, hence the single guard.
+ */
+const isImageResource = creativeType => {
+  if (!creativeType) {
+    return true;
+  }
+  return String(creativeType).toLowerCase().indexOf('image/') === 0;
+};
+/**
+ * The first resource a `<Companion>` declares as an image (or leaves undeclared). NOT
+ * `staticResources[0]`: the order in the tag is the advertiser's, and a non-image resource listed
+ * first must not hide a usable image behind it.
+ */
+const pickCompanionImage = variation => {
+  const resources = variation.staticResources || [];
+  for (let i = 0; i < resources.length; i++) {
+    const resource = resources[i];
+    if (resource && resource.url && isImageResource(resource.creativeType)) {
+      return resource.url;
+    }
+  }
+  return undefined;
+};
+/** Distance from square on a log scale, so 2:1 and 1:2 are equally far from 1:1. */
+const aspectDistance = asset => {
+  if (!asset.width || !asset.height) {
+    // Unknown intrinsic size — rank last, but still a candidate.
+    return Infinity;
+  }
+  return Math.abs(Math.log(asset.width / asset.height));
+};
+const collectAssetsFrom = ad => {
+  const assets = [];
+  for (let i = 0; i < ad.creatives.length; i++) {
+    const creative = ad.creatives[i];
+    if (creative.type === 'companion') {
+      const companionCreative = creative;
+      const variations = companionCreative.variations || [];
+      for (let j = 0; j < variations.length; j++) {
+        const variation = variations[j];
+        const imageUrl = variation && pickCompanionImage(variation);
+        if (imageUrl) {
+          var _variation$companionC;
+          assets.push({
+            imageUrl,
+            clickUrl: (_variation$companionC = variation.companionClickThroughURLTemplate) !== null && _variation$companionC !== void 0 ? _variation$companionC : undefined,
+            width: toSize(variation.width),
+            height: toSize(variation.height),
+            origin: 'companion',
+            creative: companionCreative,
+            variation
+          });
+        }
+      }
+      continue;
+    }
+    if (creative.type === 'nonlinear') {
+      const nonLinearCreative = creative;
+      const variations = nonLinearCreative.variations || [];
+      for (let j = 0; j < variations.length; j++) {
+        const variation = variations[j];
+        // `type` is where the parser puts a `<NonLinear>`'s `creativeType`, and it is written last
+        // from the `<StaticResource>` element, so it describes `staticResource` whenever that is
+        // set. An HTML- or iframe-typed variation carries no `staticResource` and drops out here.
+        const imageUrl = variation && isImageResource(variation.type) ? variation.staticResource : undefined;
+        if (imageUrl) {
+          var _variation$nonlinearC;
+          assets.push({
+            imageUrl,
+            // 6.4.2 emits `nonlinearClickThroughURLTemplate` (lower-case `l`); the shim declares
+            // the upper-case spelling. The runtime one is authoritative — see `getNonLinear`.
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            clickUrl: (_variation$nonlinearC = variation.nonlinearClickThroughURLTemplate) !== null && _variation$nonlinearC !== void 0 ? _variation$nonlinearC : undefined,
+            width: toSize(variation.width),
+            height: toSize(variation.height),
+            origin: 'nonlinear',
+            creative: nonLinearCreative,
+            variation
+          });
+        }
+      }
+    }
+  }
+  return assets;
+};
+/**
+ * The shared ranking both roles use: aspect distance from 1:1, ties broken by larger area, then by
+ * higher pixel density. Aspect is a preference, never a filter — the best of a bad set still wins.
+ */
+const rankBest = assets => {
+  if (!assets.length) {
+    return undefined;
+  }
+  let best = assets[0];
+  let bestDistance = aspectDistance(best);
+  let bestArea = (best.width || 0) * (best.height || 0);
+  let bestPxRatio = toPxRatio(best.variation);
+  for (let i = 1; i < assets.length; i++) {
+    const asset = assets[i];
+    const distance = aspectDistance(asset);
+    const area = (asset.width || 0) * (asset.height || 0);
+    const pxRatio = toPxRatio(asset.variation);
+    const wins = distance !== bestDistance ? distance < bestDistance : area !== bestArea ? area > bestArea : pxRatio > bestPxRatio;
+    if (wins) {
+      best = asset;
+      bestDistance = distance;
+      bestArea = area;
+      bestPxRatio = pxRatio;
+    }
+  }
+  return best;
+};
+/**
+ * Pick the image a parsed VAST ad offers for a sponsor-logo slot, or `undefined` when it offers
+ * none (a video-only tag, or an empty response). A caller that gets `undefined` must fall back to
+ * its own proto/Studio logo rather than suppressing the card.
+ */
+const collectAssets = ad => collectAssetsFrom(ad);
+const selectSponsorLogo = ad => rankBest(collectAssetsFrom(ad));
+/**
+ * iOS `SLRVASTSlotRole.cardLogo` — the sponsor logo of a **hero card** (1:1 / 2:1 / Picture in
+ * Picture / Side-by-Side / Sponsor Frame). Same 1:1 aspect-dominant ranking as `.logo`, plus the
+ * one constraint that distinguishes the two roles:
+ *
+ * - **`requiredOrigin: .companion`.** A NonLinear image is a hero creative, never a logo. iOS's
+ *   reason: a leftover hero-type asset — a second `<NonLinear>` overlay, or a stray image still in
+ *   the pool after the hero role claimed its own — must never leak into the card's logo slot,
+ *   where it would render at logo size as an unreadable smudge of the advertiser's key art.
+ *   `nonlinear_full` is the fixture that pins it: `.logo` takes the 500x500 NonLinear, `.cardLogo`
+ *   must take the 200x200 `<Companion>`.
+ * - **`exclude`** mirrors iOS's **greedy** `pool.select([hero, .cardLogo])`: roles resolve in array
+ *   order and an asset a role claims is removed from the pool for every later role. We have no
+ *   pool object, so the caller passes the assets the hero already claimed and they are filtered
+ *   out here by `imageUrl`.
+ */
+const selectCardLogo = (ad, exclude) => {
+  const claimed = (exclude || []).map(item => item === null || item === void 0 ? void 0 : item.imageUrl).filter(url => !!url);
+  return rankBest(collectAssetsFrom(ad).filter(asset => asset.origin === 'companion' && claimed.indexOf(asset.imageUrl) === -1));
+};
+
+export { collectAssets, selectCardLogo, selectSponsorLogo };

package/lib/classic/units/ssai-ad-break.js

@@ -0,0 +1,9 @@
+import { createSingleStore } from '@streamlayer/sdk-web-interfaces/classic';
+
+/**
+ * Imperative atom driven directly by the detector (no nanoquery — the trigger
+ * is push-based, not request/response).
+ */
+const createSsaiAdBreakStore = () => createSingleStore(null);
+
+export { createSsaiAdBreakStore };

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

@@ -0,0 +1,140 @@
+import { defineProperty as _defineProperty } from '../_virtual/_rollupPluginBabelHelpers.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';
+import { fireDefaultImpression, fireTrackingEvents, fireBeacon } from './ssai-providers.js';
+export { DEFAULT_CREATIVE_API_BASE } from './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 {
+  constructor(provider) {
+    _defineProperty(this, "provider", void 0);
+    _defineProperty(this, "cache", new Map());
+    _defineProperty(this, "inflight", new Map());
+    /**
+     * 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).
+     */
+    _defineProperty(this, "peek", creativeId => this.cache.get(creativeId));
+    _defineProperty(this, "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).
+     */
+    _defineProperty(this, "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.
+     */
+    _defineProperty(this, "fireImpression", creative => {
+      if (this.provider.fireImpression) {
+        this.provider.fireImpression(creative);
+        return;
+      }
+      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).
+     */
+    _defineProperty(this, "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.
+     */
+    _defineProperty(this, "fireTracking", (creative, event) => {
+      if (this.provider.fireTracking) {
+        this.provider.fireTracking(creative, event);
+        return;
+      }
+      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.
+     */
+    _defineProperty(this, "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.
+     */
+    _defineProperty(this, "fireCompanionClickById", creativeId => {
+      var _this$cache$get;
+      const companion = (_this$cache$get = this.cache.get(creativeId)) === null || _this$cache$get === void 0 ? void 0 : _this$cache$get.companion;
+      if (!companion) {
+        return;
+      }
+      for (const url of companion.clickTracking) {
+        fireBeacon(url);
+      }
+    });
+    _defineProperty(this, "destroy", () => {
+      this.inflight.forEach(entry => entry.controller.abort());
+      this.inflight.clear();
+      this.cache.clear();
+    });
+    this.provider = provider;
+  }
+}
+
+export { SsaiCreativeCache };