prebid.js 7.22.0 → 7.24.0

package/libraries/ortbConverter/lib/composer.js

@@ -0,0 +1,43 @@
+const SORTED = new WeakMap();
+
+/**
+ * @typedef {Object} Component
+ * A component function, that can be composed with other compatible functions into one.
+ * Compatible functions take the same arguments; return values are ignored.
+ *
+ * @property {function} fn the component function;
+ * @property {number} priority determines the order in which this function will run when composed with others.
+ */
+
+/**
+ *
+ * @param {Object[string, Component]} components to compose
+ * @param {Object[string, function|boolean]} overrides a map from component name, to a function that should override that component.
+ * Override functions are replacements, except that they get the original function they are overriding as their first argument. If the override
+ * is `false`, the component is disabled.
+ *
+ * @return a function that will run all components in order of priority, with functions from `overrides` taking
+ * precedence over components that match names
+ */
+export function compose(components, overrides = {}) {
+  if (!SORTED.has(components)) {
+    const sorted = Object.entries(components);
+    sorted.sort((a, b) => {
+      a = a[1].priority || 0;
+      b = b[1].priority || 0;
+      return a === b ? 0 : a > b ? -1 : 1
+    });
+    SORTED.set(components, sorted.map(([name, cmp]) => [name, cmp.fn]))
+  }
+  const fns = SORTED.get(components)
+    .filter(([name]) => !overrides.hasOwnProperty(name) || overrides[name])
+    .map(function ([name, fn]) {
+      return overrides.hasOwnProperty(name) ? overrides[name].bind(this, fn) : fn;
+    });
+  return function () {
+    const args = Array.from(arguments);
+    fns.forEach(fn => {
+      fn.apply(this, args);
+    })
+  }
+}

package/libraries/ortbConverter/lib/mergeProcessors.js

@@ -0,0 +1,9 @@
+import {PROCESSOR_TYPES} from '../../../src/pbjsORTB.js';
+
+export function mergeProcessors(...processors) {
+  const left = processors.shift();
+  const right = processors.length > 1 ? mergeProcessors(...processors) : processors[0];
+  return Object.fromEntries(
+    PROCESSOR_TYPES.map(type => [type, Object.assign({}, left[type], right[type])])
+  )
+}

package/libraries/ortbConverter/lib/sizes.js

@@ -0,0 +1,14 @@
+import {parseSizesInput} from '../../../src/utils.js';
+
+export function sizesToFormat(sizes) {
+  sizes = parseSizesInput(sizes);
+
+  // get sizes in form [{ w: <int>, h: <int> }, ...]
+  return sizes.map(size => {
+    const [width, height] = size.split('x');
+    return {
+      w: parseInt(width, 10),
+      h: parseInt(height, 10)
+    };
+  });
+}

package/libraries/ortbConverter/processors/banner.js

@@ -0,0 +1,40 @@
+import {createTrackPixelHtml, deepAccess, inIframe, mergeDeep} from '../../../src/utils.js';
+import {BANNER} from '../../../src/mediaTypes.js';
+import {sizesToFormat} from '../lib/sizes.js';
+
+/**
+ * fill in a request `imp` with banner parameters from `bidRequest`.
+ */
+export function fillBannerImp(imp, bidRequest, context) {
+  if (context.mediaType && context.mediaType !== BANNER) return;
+
+  const bannerParams = deepAccess(bidRequest, 'mediaTypes.banner');
+  if (bannerParams) {
+    const banner = {
+      topframe: inIframe() === true ? 0 : 1
+    };
+    if (bannerParams.sizes) {
+      banner.format = sizesToFormat(bannerParams.sizes);
+    }
+    if (bannerParams.hasOwnProperty('pos')) {
+      banner.pos = bannerParams.pos;
+    }
+
+    imp.banner = mergeDeep(banner, imp.banner);
+  }
+}
+
+export function bannerResponseProcessor({createPixel = (url) => createTrackPixelHtml(decodeURIComponent(url))} = {}) {
+  return function fillBannerResponse(bidResponse, bid) {
+    if (bidResponse.mediaType === BANNER) {
+      if (bid.adm && bid.nurl) {
+        bidResponse.ad = bid.adm;
+        bidResponse.ad += createPixel(bid.nurl);
+      } else if (bid.adm) {
+        bidResponse.ad = bid.adm;
+      } else if (bid.nurl) {
+        bidResponse.adUrl = bid.nurl;
+      }
+    }
+  };
+}

package/libraries/ortbConverter/processors/default.js

@@ -0,0 +1,167 @@
+import {deepSetValue, getDefinedParams, getDNT, mergeDeep} from '../../../src/utils.js';
+import {bannerResponseProcessor, fillBannerImp} from './banner.js';
+import {fillVideoImp, fillVideoResponse} from './video.js';
+import {setResponseMediaType} from './mediaType.js';
+import {fillNativeImp, fillNativeResponse} from './native.js';
+import {BID_RESPONSE, IMP, REQUEST} from '../../../src/pbjsORTB.js';
+import {config} from '../../../src/config.js';
+
+export const DEFAULT_PROCESSORS = {
+  [REQUEST]: {
+    fpd: {
+      // sets initial request to bidderRequest.ortb2
+      priority: 99,
+      fn(ortbRequest, bidderRequest) {
+        mergeDeep(ortbRequest, bidderRequest.ortb2)
+      }
+    },
+    // override FPD app, site, and device with getConfig('app'), etc if defined
+    // TODO: these should be deprecated for v8
+    appFpd: fpdFromTopLevelConfig('app'),
+    siteFpd: fpdFromTopLevelConfig('site'),
+    deviceFpd: fpdFromTopLevelConfig('device'),
+    device: {
+      // sets device w / h / ua / language
+      fn: setDevice
+    },
+    site: {
+      // sets site.domain, page, and ref from refererInfo
+      fn: setSite
+    },
+    props: {
+      // sets request properties id, tmax, test, source.tid
+      fn(ortbRequest, bidderRequest) {
+        Object.assign(ortbRequest, {
+          id: ortbRequest.id || bidderRequest.auctionId,
+          test: ortbRequest.test || 0
+        });
+        const timeout = parseInt(bidderRequest.timeout, 10);
+        if (!isNaN(timeout)) {
+          ortbRequest.tmax = timeout;
+        }
+        deepSetValue(ortbRequest, 'source.tid', ortbRequest.source?.tid || bidderRequest.auctionId);
+      }
+    },
+    coppa: {
+      fn(ortbRequest) {
+        const coppa = config.getConfig('coppa');
+        if (typeof coppa === 'boolean') {
+          deepSetValue(ortbRequest, 'regs.coppa', coppa ? 1 : 0);
+        }
+      }
+    },
+  },
+  [IMP]: {
+    fpd: {
+      // sets initial imp to bidRequest.ortb2Imp
+      priority: 99,
+      fn(imp, bidRequest) {
+        mergeDeep(imp, bidRequest.ortb2Imp);
+      }
+    },
+    id: {
+      // sets imp.id
+      fn(imp, bidRequest) {
+        imp.id = bidRequest.bidId;
+      }
+    },
+    banner: {
+      // populates imp.banner
+      fn: fillBannerImp
+    },
+    video: {
+      // populates imp.video
+      fn: fillVideoImp
+    },
+    pbadslot: {
+      // removes imp.ext.data.pbaslot if it's not a string
+      // TODO: is this needed?
+      fn(imp) {
+        const pbadslot = imp.ext?.data?.pbadslot;
+        if (!pbadslot || typeof pbadslot !== 'string') {
+          delete imp.ext?.data?.pbadslot;
+        }
+      }
+    }
+  },
+  [BID_RESPONSE]: {
+    mediaType: {
+      // sets bidResponse.mediaType from context.mediaType, falling back to seatbid.bid[].mtype
+      priority: 99,
+      fn: setResponseMediaType
+    },
+    banner: {
+      // sets banner response attributes if bidResponse.mediaType === BANNER
+      fn: bannerResponseProcessor(),
+    },
+    video: {
+      // sets video response attributes if bidResponse.mediaType === VIDEO
+      fn: fillVideoResponse
+    },
+    props: {
+      // sets base bidResponse properties common to all types of bids
+      fn(bidResponse, bid, context) {
+        Object.entries({
+          requestId: context.bidRequest?.bidId,
+          seatBidId: bid.id,
+          cpm: bid.price,
+          currency: context.ortbResponse.cur || context.currency,
+          width: bid.w,
+          height: bid.h,
+          dealId: bid.dealid,
+          creative_id: bid.crid,
+          creativeId: bid.crid,
+          burl: bid.burl,
+          ttl: bid.exp || context.ttl,
+          netRevenue: context.netRevenue,
+        }).filter(([k, v]) => typeof v !== 'undefined')
+          .forEach(([k, v]) => bidResponse[k] = v);
+        if (!bidResponse.meta) {
+          bidResponse.meta = {};
+        }
+        if (bid.adomain) {
+          bidResponse.meta.advertiserDomains = bid.adomain;
+        }
+      }
+    }
+  }
+}
+
+if (FEATURES.NATIVE) {
+  DEFAULT_PROCESSORS[IMP].native = {
+    // populates imp.native
+    fn: fillNativeImp
+  }
+  DEFAULT_PROCESSORS[BID_RESPONSE].native = {
+    // populates bidResponse.native if bidResponse.mediaType === NATIVE
+    fn: fillNativeResponse
+  }
+}
+
+function fpdFromTopLevelConfig(prop) {
+  return {
+    priority: 90, // after FPD from 'ortb2', before the rest
+    fn(ortbRequest) {
+      const data = config.getConfig(prop);
+      if (typeof data === 'object') {
+        ortbRequest[prop] = data;
+      }
+    }
+  }
+}
+
+export function setDevice(ortbRequest) {
+  ortbRequest.device = Object.assign({
+    w: window.innerWidth,
+    h: window.innerHeight,
+    dnt: getDNT() ? 1 : 0,
+    ua: window.navigator.userAgent,
+    language: window.navigator.language.split('-').shift()
+  }, ortbRequest.device);
+}
+
+export function setSite(ortbRequest, bidderRequest) {
+  if (bidderRequest.refererInfo) {
+    ortbRequest.site = Object.assign(getDefinedParams(bidderRequest.refererInfo, ['page', 'domain', 'ref']), ortbRequest.site);
+  }
+}

package/libraries/ortbConverter/processors/mediaType.js

@@ -0,0 +1,21 @@
+import {BANNER, NATIVE, VIDEO} from '../../../src/mediaTypes.js';
+
+export const ORTB_MTYPES = {
+  1: BANNER,
+  2: VIDEO,
+  4: NATIVE
+}
+
+/**
+ * Sets response mediaType, using ORTB 2.6 `seatbid.bid[].mtype`.
+ *
+ * Note that this will throw away bids if there is no `mtype` in the response.
+ */
+export function setResponseMediaType(bidResponse, bid, context) {
+  if (bidResponse.mediaType) return;
+  const mediaType = context.mediaType;
+  if (!mediaType && !ORTB_MTYPES.hasOwnProperty(bid.mtype)) {
+    throw new Error('Cannot determine mediaType for response')
+  }
+  bidResponse.mediaType = mediaType || ORTB_MTYPES[bid.mtype];
+}

package/libraries/ortbConverter/processors/native.js

@@ -0,0 +1,37 @@
+import {isPlainObject, logWarn, mergeDeep} from '../../../src/utils.js';
+import {NATIVE} from '../../../src/mediaTypes.js';
+
+export function fillNativeImp(imp, bidRequest, context) {
+  if (context.mediaType && context.mediaType !== NATIVE) return;
+  let nativeReq = bidRequest.nativeOrtbRequest;
+  if (nativeReq) {
+    nativeReq = Object.assign({}, context.nativeRequest, nativeReq);
+    if (nativeReq.assets?.length) {
+      imp.native = mergeDeep({}, {
+        request: JSON.stringify(nativeReq),
+        ver: nativeReq.ver
+      }, imp.native)
+    } else {
+      logWarn('mediaTypes.native is set, but no assets were specified. Native request skipped.', bidRequest)
+    }
+  }
+}
+
+export function fillNativeResponse(bidResponse, bid) {
+  if (bidResponse.mediaType === NATIVE) {
+    let ortb;
+    if (typeof bid.adm === 'string') {
+      ortb = JSON.parse(bid.adm);
+    } else {
+      ortb = bid.adm;
+    }
+
+    if (isPlainObject(ortb) && Array.isArray(ortb.assets)) {
+      bidResponse.native = {
+        ortb,
+      }
+    } else {
+      throw new Error('ORTB native response contained no assets');
+    }
+  }
+}

package/libraries/ortbConverter/processors/video.js

@@ -0,0 +1,66 @@
+import {deepAccess, isEmpty, logWarn, mergeDeep} from '../../../src/utils.js';
+import {VIDEO} from '../../../src/mediaTypes.js';
+import {sizesToFormat} from '../lib/sizes.js';
+
+// parameters that share the same name & semantics between pbjs adUnits and imp.video
+const ORTB_VIDEO_PARAMS = new Set([
+  'pos',
+  'placement',
+  'api',
+  'mimes',
+  'protocols',
+  'playbackmethod',
+  'minduration',
+  'maxduration',
+  'w',
+  'h',
+  'startdelay',
+  'placement',
+  'linearity',
+  'skip',
+  'skipmin',
+  'skipafter',
+  'minbitrate',
+  'maxbitrate',
+  'delivery',
+  'playbackend'
+]);
+
+const PLACEMENT = {
+  'instream': 1,
+}
+
+export function fillVideoImp(imp, bidRequest, context) {
+  if (context.mediaType && context.mediaType !== VIDEO) return;
+
+  const videoParams = deepAccess(bidRequest, 'mediaTypes.video');
+  if (!isEmpty(videoParams)) {
+    const video = Object.fromEntries(
+      Object.entries(videoParams)
+        .filter(([name]) => ORTB_VIDEO_PARAMS.has(name))
+    );
+    if (videoParams.playerSize) {
+      const format = sizesToFormat(videoParams.playerSize);
+      if (format.length > 1) {
+        logWarn('video request specifies more than one playerSize; all but the first will be ignored')
+      }
+      Object.assign(video, format[0]);
+    }
+    const placement = PLACEMENT[videoParams.context];
+    if (placement != null) {
+      video.placement = placement;
+    }
+    imp.video = mergeDeep(video, imp.video);
+  }
+}
+
+export function fillVideoResponse(bidResponse, seatbid, context) {
+  if (bidResponse.mediaType === VIDEO) {
+    if (deepAccess(context.imp, 'video.w') && deepAccess(context.imp, 'video.h')) {
+      [bidResponse.playerWidth, bidResponse.playerHeight] = [context.imp.video.w, context.imp.video.h];
+    }
+
+    if (seatbid.adm) { bidResponse.vastXml = seatbid.adm; }
+    if (seatbid.nurl) { bidResponse.vastUrl = seatbid.nurl; }
+  }
+}

package/libraries/pbsExtensions/pbsExtensions.js

@@ -0,0 +1,12 @@
+import {mergeProcessors} from '../ortbConverter/lib/mergeProcessors.js';
+import {PBS_PROCESSORS} from './processors/pbs.js';
+import {getProcessors, PBS} from '../../src/pbjsORTB.js';
+import {defaultProcessors} from '../ortbConverter/converter.js';
+import {memoize} from '../../src/utils.js';
+
+/**
+ * ORTB converter processor set that understands Prebid Server extensions.
+ *
+ * Pass this as the `processors` option to `ortbConverter` if your backend is a PBS instance.
+ */
+export const pbsExtensions = memoize(() => mergeProcessors(defaultProcessors(), PBS_PROCESSORS, getProcessors(PBS)));

package/libraries/pbsExtensions/processors/aliases.js

@@ -0,0 +1,17 @@
+import adapterManager from '../../../src/adapterManager.js';
+import {deepSetValue} from '../../../src/utils.js';
+
+export function setRequestExtPrebidAliases(ortbRequest, bidderRequest, context, {am = adapterManager} = {}) {
+  if (am.aliasRegistry[bidderRequest.bidderCode]) {
+    const bidder = am.bidderRegistry[bidderRequest.bidderCode];
+    // adding alias only if alias source bidder exists and alias isn't configured to be standalone
+    // pbs adapter
+    if (!bidder || !bidder.getSpec().skipPbsAliasing) {
+      deepSetValue(
+        ortbRequest,
+        `ext.prebid.aliases.${bidderRequest.bidderCode}`,
+        am.aliasRegistry[bidderRequest.bidderCode]
+      );
+    }
+  }
+}

package/libraries/pbsExtensions/processors/mediaType.js

@@ -0,0 +1,23 @@
+import {BANNER, NATIVE, VIDEO} from '../../../src/mediaTypes.js';
+import {ORTB_MTYPES} from '../../ortbConverter/processors/mediaType.js';
+
+export const SUPPORTED_MEDIA_TYPES = {
+  // map from pbjs mediaType to its corresponding imp property
+  [BANNER]: 'banner',
+  [NATIVE]: 'native',
+  [VIDEO]: 'video'
+}
+
+/**
+ * Sets bidResponse.mediaType, using ORTB 2.6 `seatbid.bid[].mtype`, falling back to `ext.prebid.type`, falling back to 'banner'.
+ */
+export function extPrebidMediaType(bidResponse, bid, context) {
+  let mediaType = context.mediaType;
+  if (!mediaType) {
+    mediaType = ORTB_MTYPES.hasOwnProperty(bid.mtype) ? ORTB_MTYPES[bid.mtype] : bid.ext?.prebid?.type
+    if (!SUPPORTED_MEDIA_TYPES.hasOwnProperty(mediaType)) {
+      mediaType = BANNER;
+    }
+  }
+  bidResponse.mediaType = mediaType;
+}

package/libraries/pbsExtensions/processors/params.js

@@ -0,0 +1,22 @@
+import {auctionManager} from '../../../src/auctionManager.js';
+import adapterManager from '../../../src/adapterManager.js';
+import {deepSetValue} from '../../../src/utils.js';
+
+export function setImpBidParams(
+  imp, bidRequest, context,
+  {adUnit, bidderRequests, index = auctionManager.index, bidderRegistry = adapterManager.bidderRegistry} = {}) {
+  let params = bidRequest.params;
+  const adapter = bidderRegistry[bidRequest.bidder];
+  if (adapter && adapter.getSpec().transformBidParams) {
+    adUnit = adUnit || index.getAdUnit(bidRequest);
+    bidderRequests = bidderRequests || [context.bidderRequest];
+    params = adapter.getSpec().transformBidParams(params, true, adUnit, bidderRequests);
+  }
+  if (params) {
+    deepSetValue(
+      imp,
+      `ext.prebid.bidder.${bidRequest.bidder}`,
+      params
+    );
+  }
+}

package/libraries/pbsExtensions/processors/pbs.js

@@ -0,0 +1,99 @@
+import {BID_RESPONSE, IMP, REQUEST, RESPONSE} from '../../../src/pbjsORTB.js';
+import {deepAccess, isPlainObject, isStr, mergeDeep} from '../../../src/utils.js';
+import {extPrebidMediaType} from './mediaType.js';
+import {setRequestExtPrebidAliases} from './aliases.js';
+import {setImpBidParams} from './params.js';
+import {setRequestExtPrebid, setRequestExtPrebidChannel} from './requestExtPrebid.js';
+import {setBidResponseVideoCache} from './video.js';
+
+export const PBS_PROCESSORS = {
+  [REQUEST]: {
+    extPrebid: {
+      // set request.ext.prebid.auctiontimestamp, .debug and .targeting
+      fn: setRequestExtPrebid
+    },
+    extPrebidChannel: {
+      // sets request.ext.prebid.channel
+      fn: setRequestExtPrebidChannel
+    },
+    extPrebidAliases: {
+      // sets ext.prebid.aliases
+      fn: setRequestExtPrebidAliases
+    }
+  },
+  [IMP]: {
+    params: {
+      // sets bid ext.prebid.bidder.[bidderCode] with bidRequest.params, passed through transformBidParams if necessary
+      fn: setImpBidParams
+    },
+  },
+  [BID_RESPONSE]: {
+    mediaType: {
+      // sets bidResponse.mediaType according to context.mediaType, falling back to imp.ext.prebid.type
+      fn: extPrebidMediaType,
+      priority: 99,
+    },
+    videoCache: {
+      // sets response video attributes; in addition, looks at ext.prebid.cache and .targeting to set video cache key and URL
+      fn: setBidResponseVideoCache,
+      priority: -10, // after 'video'
+    },
+    bidderCode: {
+      // sets bidderCode from on seatbid.seat
+      fn(bidResponse, bid, context) {
+        bidResponse.bidderCode = context.seatbid.seat;
+        bidResponse.adapterCode = deepAccess(bid, 'ext.prebid.meta.adaptercode') || context.bidRequest?.bidder || bidResponse.bidderCode;
+      }
+    },
+    pbsBidId: {
+      // sets bidResponse.pbsBidId from ext.prebid.bidid
+      fn(bidResponse, bid) {
+        const bidId = deepAccess(bid, 'ext.prebid.bidid');
+        if (isStr(bidId)) {
+          bidResponse.pbsBidId = bidId;
+        }
+      }
+    },
+    adserverTargeting: {
+      // sets bidResponse.adserverTargeting from ext.prebid.targeting
+      fn(bidResponse, bid) {
+        const targeting = deepAccess(bid, 'ext.prebid.targeting');
+        if (isPlainObject(targeting)) {
+          bidResponse.adserverTargeting = targeting;
+        }
+      }
+    },
+    extPrebidMeta: {
+      // sets bidResponse.meta from ext.prebid.meta
+      fn(bidResponse, bid) {
+        bidResponse.meta = mergeDeep({}, deepAccess(bid, 'ext.prebid.meta'), bidResponse.meta);
+      }
+    },
+    pbsWurl: {
+      // sets bidResponse.pbsWurl from ext.prebid.events.win
+      fn(bidResponse, bid) {
+        const wurl = deepAccess(bid, 'ext.prebid.events.win');
+        if (isStr(wurl)) {
+          bidResponse.pbsWurl = wurl;
+        }
+      }
+    },
+  },
+  [RESPONSE]: {
+    serverSideStats: {
+      // updates bidderRequest and bidRequests with serverErrors from ext.errors and serverResponseTimeMs from ext.responsetimemillis
+      fn(response, ortbResponse, context) {
+        Object.entries({
+          errors: 'serverErrors',
+          responsetimemillis: 'serverResponseTimeMs'
+        }).forEach(([serverName, clientName]) => {
+          const value = deepAccess(ortbResponse, `ext.${serverName}.${context.bidderRequest.bidderCode}`);
+          if (value) {
+            context.bidderRequest[clientName] = value;
+            context.bidRequests.forEach(bid => bid[clientName] = value);
+          }
+        })
+      }
+    },
+  }
+}

package/libraries/pbsExtensions/processors/requestExtPrebid.js

@@ -0,0 +1,30 @@
+import {deepSetValue, mergeDeep} from '../../../src/utils.js';
+import {config} from '../../../src/config.js';
+import {getGlobal} from '../../../src/prebidGlobal.js';
+
+export function setRequestExtPrebid(ortbRequest, bidderRequest) {
+  deepSetValue(
+    ortbRequest,
+    'ext.prebid',
+    mergeDeep(
+      {
+        auctiontimestamp: bidderRequest.auctionStart,
+        targeting: {
+          includewinners: true,
+          includebidderkeys: false
+        }
+      },
+      ortbRequest.ext?.prebid,
+    )
+  );
+  if (config.getConfig('debug')) {
+    ortbRequest.ext.prebid.debug = true;
+  }
+}
+
+export function setRequestExtPrebidChannel(ortbRequest) {
+  deepSetValue(ortbRequest, 'ext.prebid.channel', Object.assign({
+    name: 'pbjs',
+    version: getGlobal().version
+  }, ortbRequest.ext?.prebid?.channel));
+}

package/libraries/pbsExtensions/processors/video.js

@@ -0,0 +1,23 @@
+import {VIDEO} from '../../../src/mediaTypes.js';
+import {deepAccess} from '../../../src/utils.js';
+
+export function setBidResponseVideoCache(bidResponse, bid) {
+  if (bidResponse.mediaType === VIDEO) {
+    // try to get cache values from 'response.ext.prebid.cache'
+    // else try 'bid.ext.prebid.targeting' as fallback
+    let {cacheId: videoCacheKey, url: vastUrl} = deepAccess(bid, 'ext.prebid.cache.vastXml') || {};
+    if (!videoCacheKey || !vastUrl) {
+      const {hb_uuid: uuid, hb_cache_host: cacheHost, hb_cache_path: cachePath} = deepAccess(bid, 'ext.prebid.targeting') || {};
+      if (uuid && cacheHost && cachePath) {
+        videoCacheKey = uuid;
+        vastUrl = `https://${cacheHost}${cachePath}?uuid=${uuid}`;
+      }
+    }
+    if (videoCacheKey && vastUrl) {
+      Object.assign(bidResponse, {
+        videoCacheKey,
+        vastUrl
+      })
+    }
+  }
+}

package/libraries/video/constants/enums.js

@@ -0,0 +1,5 @@
+export const PLAYBACK_MODE = {
+  VOD: 0,
+  LIVE: 1,
+  DVR: 2
+};