@adhese/sdk 0.1.0

package/dist/es/index.js

@@ -0,0 +1,1012 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { debounce, uniqueId, random, round } from "lodash-es";
+import { union, coerce, literal, object, string, unknown, lazy } from "zod";
+async function waitForDomLoad() {
+  return new Promise((resolve) => {
+    function onDomLoad() {
+      resolve();
+      window.removeEventListener("DOMContentLoaded", onDomLoad);
+    }
+    if (document.readyState === "loading")
+      document.addEventListener("DOMContentLoaded", onDomLoad);
+    else
+      resolve();
+  });
+}
+function createEventManager() {
+  const disposables = /* @__PURE__ */ new Set();
+  function dispose() {
+    for (const disposable of disposables)
+      disposable();
+  }
+  return new Proxy({
+    dispose
+  }, {
+    // eslint-disable-next-line ts/explicit-function-return-type
+    get(target, key, receiver) {
+      if (!(key in target) && typeof key === "string") {
+        const event = createEvent();
+        disposables.add(() => {
+          event.listeners.clear();
+        });
+        Reflect.set(target, key, event, receiver);
+      }
+      return Reflect.get(target, key, receiver);
+    }
+  });
+}
+function createEvent() {
+  const listeners = /* @__PURE__ */ new Set();
+  function dispatch(data) {
+    for (const listener of listeners)
+      void listener(data);
+  }
+  async function dispatchAsync(data) {
+    await Promise.allSettled(
+      Array.from(listeners).map((listener) => listener(data))
+    );
+  }
+  function addListener(listener) {
+    listeners.add(listener);
+  }
+  function removeListener(listener) {
+    listeners.delete(listener);
+  }
+  return {
+    listeners,
+    dispatch,
+    dispatchAsync,
+    addListener,
+    removeListener
+  };
+}
+async function findDomSlots(context) {
+  await waitForDomLoad();
+  return (await Promise.all(Array.from(document.querySelectorAll(".adunit")).filter((element) => Boolean(element.dataset.format)).map((element) => createSlot({
+    format: element.dataset.format,
+    containingElement: element,
+    slot: element.dataset.slot,
+    context
+  })))).filter((slot) => {
+    var _a;
+    return !((_a = context.getAll) == null ? void 0 : _a.call(context).some((activeSlot) => activeSlot.getName() === slot.getName()));
+  });
+}
+async function createSlotManager({
+  initialSlots = [],
+  context
+}) {
+  const slots = /* @__PURE__ */ new Map();
+  await Promise.allSettled(initialSlots.map(async (slot) => add({
+    ...slot,
+    lazyLoading: false
+  })));
+  function getAll() {
+    return Array.from(slots).map(([, slot]) => slot);
+  }
+  async function add(options) {
+    var _a, _b;
+    const slot = await createSlot({
+      ...options,
+      onDispose,
+      onNameChange,
+      context
+    });
+    function onDispose() {
+      var _a2, _b2;
+      slots.delete(slot.getName());
+      logger.debug("Slot removed", {
+        slot,
+        slots: Array.from(slots)
+      });
+      (_a2 = context.events) == null ? void 0 : _a2.removeSlot.dispatch(slot);
+      (_b2 = context.events) == null ? void 0 : _b2.changeSlots.dispatch(Array.from(slots.values()));
+    }
+    slots.set(slot.getName(), slot);
+    function onNameChange(newName, previousName) {
+      var _a2;
+      slots.set(newName, slot);
+      slots.delete(previousName);
+      (_a2 = context.events) == null ? void 0 : _a2.changeSlots.dispatch(Array.from(slots.values()));
+    }
+    logger.debug("Slot added", {
+      slot,
+      slots: Array.from(slots.values())
+    });
+    (_a = context.events) == null ? void 0 : _a.addSlot.dispatch(slot);
+    (_b = context.events) == null ? void 0 : _b.changeSlots.dispatch(Array.from(slots.values()));
+    return slot;
+  }
+  async function findDomSlots$1() {
+    var _a;
+    const domSlots = await findDomSlots(
+      context
+    );
+    for (const slot of domSlots) {
+      slots.set(slot.getName(), slot);
+      (_a = context.events) == null ? void 0 : _a.changeSlots.dispatch(Array.from(slots.values()));
+    }
+    return domSlots;
+  }
+  function get(name) {
+    return slots.get(name);
+  }
+  function dispose() {
+    var _a;
+    for (const slot of slots.values())
+      slot.dispose();
+    slots.clear();
+    (_a = context.events) == null ? void 0 : _a.changeSlots.dispatch(Array.from(slots.values()));
+  }
+  return {
+    getAll,
+    add,
+    findDomSlots: findDomSlots$1,
+    get,
+    dispose
+  };
+}
+function onTcfConsentChange(callback) {
+  var _a;
+  (_a = window.__tcfapi) == null ? void 0 : _a.call(window, "addEventListener", 2, callback);
+  return () => {
+    var _a2;
+    return (_a2 = window.__tcfapi) == null ? void 0 : _a2.call(window, "removeEventListener", 2, callback);
+  };
+}
+function createQueryDetector({
+  onChange,
+  queries = {
+    mobile: "(max-width: 768px) and (pointer: coarse)",
+    tablet: "(min-width: 769px) and (max-width: 1024px) and (pointer: coarse)",
+    desktop: "(min-width: 1025px) and (pointer: fine)"
+  }
+} = {}) {
+  const mediaMap = new Map(
+    Object.entries(queries).map(([key, query]) => [key, window.matchMedia(query)])
+  );
+  function getQuery() {
+    for (const [device, query] of Object.entries(queries)) {
+      if (window.matchMedia(query).matches)
+        return device;
+    }
+    return "unknown";
+  }
+  const handleOnChange = debounce(() => {
+    void (onChange == null ? void 0 : onChange(getQuery()));
+    logger.debug(`Change device ${getQuery()}`);
+  }, 50);
+  if (onChange) {
+    for (const query of mediaMap.values())
+      query.addEventListener("change", handleOnChange);
+  }
+  function dispose() {
+    for (const query of mediaMap.values())
+      query.removeEventListener("change", handleOnChange);
+  }
+  return {
+    queries: mediaMap,
+    getQuery,
+    dispose
+  };
+}
+const defaultLogLevels = ["trace", "debug", "info", "warn", "error"];
+function createLogger({
+  scope,
+  logLevels = defaultLogLevels,
+  minLogLevelThreshold = logLevels[2]
+}) {
+  const logs = /* @__PURE__ */ new Set();
+  let currentMinLogLevelThreshold = minLogLevelThreshold;
+  const events = createEventManager();
+  const logFunctions = Object.fromEntries(logLevels.map((level, index) => {
+    const logFunction = (message, attributes) => {
+      logs.add({
+        scope,
+        level,
+        message,
+        attributes,
+        timestamp: Date.now(),
+        id: uniqueId()
+      });
+      events.log.dispatch({
+        scope,
+        level,
+        message,
+        attributes,
+        timestamp: Date.now(),
+        id: uniqueId()
+      });
+      if (index >= logLevels.indexOf(currentMinLogLevelThreshold)) {
+        if (["warn", "error", "trace"].includes(level)) {
+          console[level](...[
+            `%c${scope}`,
+            "color: red; font-weight: bold;",
+            message,
+            attributes
+          ].filter(Boolean));
+        } else {
+          console.log(...[
+            `%c${scope} %c${level.toUpperCase()}`,
+            "color: red; font-weight: bold;",
+            "font-weight: bold;",
+            message,
+            attributes
+          ].filter(Boolean));
+        }
+      }
+    };
+    return [level, logFunction];
+  }));
+  return {
+    ...logFunctions,
+    scope,
+    events,
+    setMinLogLevelThreshold(level) {
+      currentMinLogLevelThreshold = level;
+    },
+    resetMinLogLevelThreshold() {
+      currentMinLogLevelThreshold = minLogLevelThreshold;
+    },
+    getMinLogLevelThreshold() {
+      return currentMinLogLevelThreshold;
+    },
+    getLogs() {
+      return Array.from(logs);
+    },
+    resetLogs() {
+      events.reset.dispatch();
+      logs.clear();
+    }
+  };
+}
+const logger = createLogger({
+  scope: "Adhese SDK"
+});
+function createParameters(options, queryDetector) {
+  const parameters = new MapWithEvents();
+  if (options.logReferrer)
+    parameters.set("re", btoa(document.referrer));
+  if (options.logUrl)
+    parameters.set("ur", btoa(window.location.href));
+  for (const [key, value] of Object.entries({
+    ...options.parameters ?? {},
+    tl: options.consent ? "all" : "none",
+    dt: queryDetector.getQuery(),
+    br: queryDetector.getQuery(),
+    rn: random(1e4).toString()
+  }))
+    parameters.set(key, value);
+  return parameters;
+}
+function setupLogging(mergedOptions) {
+  if (mergedOptions.debug || window.location.search.includes("adhese_debug=true")) {
+    logger.setMinLogLevelThreshold("debug");
+    logger.debug("Debug logging enabled");
+  }
+  logger.debug("Created Adhese SDK instance", {
+    mergedOptions
+  });
+}
+function isPreviewMode() {
+  return window.location.search.includes("adhesePreviewCreativeId");
+}
+class MapWithEvents extends Map {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+  }
+  addEventListener(listener) {
+    this.listeners.add(listener);
+  }
+  removeEventListener(listener) {
+    this.listeners.delete(listener);
+  }
+  set(key, value) {
+    const set = super.set(key, value);
+    this.listeners.forEach((listener) => {
+      listener();
+    });
+    return set;
+  }
+  clear() {
+    super.clear();
+    this.listeners.forEach((listener) => {
+      listener();
+    });
+  }
+  delete(key) {
+    const deleted = super.delete(key);
+    this.listeners.forEach((listener) => {
+      listener();
+    });
+    return deleted;
+  }
+  /**
+   * Remove all listeners and clear the map.
+   */
+  dispose() {
+    this.listeners.clear();
+    super.clear();
+  }
+}
+async function createDevtools(context) {
+  const devtools = await import("./devtools.js");
+  const wrapperElement = document.createElement("div");
+  document.body.appendChild(wrapperElement);
+  const unmount = devtools.createAdheseDevtools(wrapperElement, context);
+  return () => {
+    unmount();
+    wrapperElement.outerHTML = "";
+  };
+}
+async function createAdhese(options) {
+  const mergedOptions = {
+    host: `https://ads-${options.account}.adhese.com`,
+    poolHost: `https://pool-${options.account}.adhese.com`,
+    location: "homepage",
+    requestType: "POST",
+    debug: false,
+    initialSlots: [],
+    findDomSlotsOnLoad: false,
+    consent: false,
+    logReferrer: true,
+    logUrl: true,
+    eagerRendering: false,
+    viewabilityTracking: true,
+    ...options
+  };
+  setupLogging(mergedOptions);
+  const context = new Proxy({
+    location: mergedOptions.location,
+    consent: mergedOptions.consent,
+    debug: mergedOptions.debug,
+    getAll,
+    get,
+    options: mergedOptions,
+    logger
+  }, {});
+  context.events = createEventManager();
+  function getLocation() {
+    return context.location;
+  }
+  function setLocation(newLocation) {
+    var _a;
+    context.location = newLocation;
+    (_a = context.events) == null ? void 0 : _a.locationChange.dispatch(newLocation);
+  }
+  const queryDetector = createQueryDetector({
+    onChange: onQueryChange,
+    queries: mergedOptions.queries
+  });
+  context.parameters = createParameters(mergedOptions, queryDetector);
+  context.parameters.addEventListener(onParametersChange);
+  let unmountDevtools;
+  if (mergedOptions.debug || window.location.search.includes("adhese_debug=true") || isPreviewMode())
+    unmountDevtools = await createDevtools(context);
+  function onParametersChange() {
+    var _a;
+    if (context.parameters)
+      (_a = context.events) == null ? void 0 : _a.parametersChange.dispatch(context.parameters);
+  }
+  async function onQueryChange() {
+    var _a, _b;
+    const query = queryDetector.getQuery();
+    (_a = context.parameters) == null ? void 0 : _a.set("dt", query);
+    (_b = context.parameters) == null ? void 0 : _b.set("br", query);
+    await fetchAndRenderAllSlots();
+  }
+  function getConsent() {
+    return context.consent;
+  }
+  function setConsent(newConsent) {
+    var _a, _b;
+    (_a = context.parameters) == null ? void 0 : _a.set("tl", newConsent ? "all" : "none");
+    context.consent = newConsent;
+    (_b = context.events) == null ? void 0 : _b.consentChange.dispatch(newConsent);
+  }
+  const slotManager = await createSlotManager({
+    initialSlots: mergedOptions.initialSlots,
+    context
+  });
+  function getAll() {
+    return slotManager.getAll();
+  }
+  function get(name) {
+    return slotManager.get(name);
+  }
+  async function addSlot(slotOptions) {
+    const slot = await slotManager.add(slotOptions);
+    if (!slot.lazyLoading) {
+      const ad = await requestAd({
+        slot,
+        host: mergedOptions.host,
+        parameters: context.parameters,
+        account: mergedOptions.account,
+        context
+      });
+      await slot.setAd(ad);
+    }
+    return slot;
+  }
+  async function findDomSlots2() {
+    const domSlots = (await slotManager.findDomSlots()).filter((slot) => !slot.lazyLoading);
+    const ads = await requestAds({
+      host: mergedOptions.host,
+      slots: domSlots,
+      method: mergedOptions.requestType,
+      account: mergedOptions.account,
+      parameters: context.parameters,
+      context
+    });
+    await Promise.allSettled(ads.map((ad) => {
+      var _a;
+      return (_a = slotManager.get(ad.slotName)) == null ? void 0 : _a.setAd(ad);
+    }));
+    return domSlots;
+  }
+  async function toggleDebug() {
+    context.debug = !context.debug;
+    if (context.debug && !unmountDevtools) {
+      unmountDevtools = await createDevtools(context);
+      logger.setMinLogLevelThreshold("debug");
+      logger.debug("Debug mode enabled");
+    } else {
+      logger.debug("Debug mode disabled");
+      unmountDevtools == null ? void 0 : unmountDevtools();
+      unmountDevtools = void 0;
+      logger.setMinLogLevelThreshold("info");
+    }
+    return context.debug;
+  }
+  async function fetchAndRenderAllSlots() {
+    const slots = slotManager.getAll().filter((slot) => !slot.lazyLoading);
+    if (slots.length === 0)
+      return;
+    const ads = await requestAds({
+      host: mergedOptions.host,
+      slots,
+      method: mergedOptions.requestType,
+      account: mergedOptions.account,
+      parameters: context.parameters,
+      context
+    });
+    await Promise.allSettled(ads.map((ad) => {
+      var _a;
+      return (_a = slotManager.get(ad.slotName)) == null ? void 0 : _a.setAd(ad);
+    }));
+  }
+  const disposeOnTcfConsentChange = onTcfConsentChange(async (data) => {
+    var _a, _b;
+    if (!data.tcString)
+      return;
+    logger.debug("TCF v2 consent data received", {
+      data
+    });
+    (_a = context.parameters) == null ? void 0 : _a.set("xt", data.tcString);
+    (_b = context.parameters) == null ? void 0 : _b.delete("tl");
+    await fetchAndRenderAllSlots();
+  });
+  if (slotManager.getAll().length > 0)
+    await fetchAndRenderAllSlots().catch(logger.error);
+  function dispose() {
+    var _a, _b, _c;
+    queryDetector.dispose();
+    slotManager.dispose();
+    queryDetector.dispose();
+    disposeOnTcfConsentChange();
+    (_a = context.parameters) == null ? void 0 : _a.dispose();
+    (_b = context.parameters) == null ? void 0 : _b.clear();
+    logger.resetLogs();
+    (_c = context.events) == null ? void 0 : _c.dispose();
+    unmountDevtools == null ? void 0 : unmountDevtools();
+    logger.info("Adhese instance disposed");
+  }
+  if (mergedOptions.findDomSlotsOnLoad)
+    await slotManager.findDomSlots();
+  return {
+    ...mergedOptions,
+    ...slotManager,
+    parameters: context.parameters,
+    events: context.events,
+    getLocation,
+    setLocation,
+    getConsent,
+    setConsent,
+    addSlot,
+    findDomSlots: findDomSlots2,
+    dispose,
+    toggleDebug
+  };
+}
+function addTrackingPixel(url) {
+  const img = document.createElement("img");
+  img.src = url.toString();
+  img.style.height = "1px";
+  img.style.width = "1px";
+  img.style.margin = "-1px";
+  img.style.border = "0";
+  img.style.position = "absolute";
+  img.style.top = "0";
+  return document.body.appendChild(img);
+}
+function renderIframe(ad, element) {
+  const iframe = document.createElement("iframe");
+  iframe.srcdoc = `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <style>
+            body {
+              margin: 0;
+              padding: 0;
+              overflow: hidden;
+            }
+          </style>
+        </head>
+        <body>
+          ${ad.tag}
+        </body>
+      `.replaceAll(/\s+/g, " ").trim();
+  iframe.style.border = "none";
+  iframe.style.width = ad.width ? `${ad.width}px` : "100%";
+  iframe.style.height = ad.height ? `${ad.height}px` : "100%";
+  element.replaceChildren(iframe);
+}
+function renderInline(ad, element) {
+  element.style.width = ad.width ? `${ad.width}px` : "100%";
+  element.style.height = ad.height ? `${ad.height}px` : "100%";
+  element.innerHTML = ad.tag;
+}
+const renderFunctions = {
+  iframe: renderIframe,
+  inline: renderInline
+};
+async function createSlot(options) {
+  var _a;
+  const {
+    containingElement,
+    slot,
+    context,
+    renderMode = "iframe"
+  } = options;
+  await waitForDomLoad();
+  const parameters = new Map(Object.entries(options.parameters ?? {}));
+  let format;
+  let queryDetector = null;
+  if (typeof options.format === "string") {
+    format = options.format;
+  } else {
+    queryDetector = createQueryDetector({
+      onChange: setFormat,
+      queries: Object.fromEntries(options.format.map((item) => [item.format, item.query]))
+    });
+    format = queryDetector.getQuery();
+  }
+  async function setFormat(newFormat) {
+    var _a2;
+    const oldName = getName();
+    format = newFormat;
+    (_a2 = options.onNameChange) == null ? void 0 : _a2.call(options, getName(), oldName);
+    const newAd = await requestAd({
+      slot: {
+        getName,
+        parameters
+      },
+      account: context.options.account,
+      host: context.options.host,
+      parameters: context.parameters,
+      context
+    });
+    cleanElement();
+    await setAd(newAd);
+  }
+  function getFormat() {
+    return format;
+  }
+  let element = typeof containingElement === "string" || !containingElement ? document.querySelector(`.adunit[data-format="${format}"]#${containingElement}${slot ? `[data-slot="${slot}"]` : ""}`) : containingElement;
+  function getElement() {
+    if (renderMode === "iframe")
+      return (element == null ? void 0 : element.querySelector("iframe")) ?? null;
+    return (element == null ? void 0 : element.innerHTML) ? element.firstElementChild : null;
+  }
+  let impressionTrackingPixelElement = null;
+  let viewabilityTrackingPixelElement = null;
+  let isInViewport = false;
+  let ad = null;
+  function getAd() {
+    return ad;
+  }
+  async function setAd(newAd) {
+    var _a2, _b;
+    ad = newAd;
+    if (isInViewport || context.options.eagerRendering)
+      await render(ad);
+    if (element) {
+      element.style.width = `${ad.width}px`;
+      element.style.height = `${ad.height}px`;
+    }
+    await ((_b = context.events) == null ? void 0 : _b.changeSlots.dispatchAsync(Array.from(((_a2 = context.getAll) == null ? void 0 : _a2.call(context)) ?? [])));
+  }
+  const renderIntersectionObserver = new IntersectionObserver((entries) => {
+    isInViewport = entries.some((entry) => entry.isIntersecting);
+    if (isInViewport) {
+      (async () => {
+        if (!ad && options.lazyLoading)
+          await render();
+        else if (ad)
+          await render(ad);
+      })().catch(logger.error);
+    }
+  }, {
+    rootMargin: ((_a = options.lazyLoadingOptions) == null ? void 0 : _a.rootMargin) ?? "200px",
+    threshold: 0
+  });
+  let timeoutId = null;
+  const {
+    threshold,
+    duration,
+    rootMargin
+  } = {
+    threshold: 0.2,
+    duration: 1e3,
+    rootMargin: "0px",
+    ...context.options.viewabilityTrackingOptions
+  };
+  const viewabilityObserver = new IntersectionObserver(([entry]) => {
+    if (context.options.viewabilityTracking && !viewabilityTrackingPixelElement && ad) {
+      const ratio = round(entry.intersectionRatio, 1);
+      if (ratio >= threshold && !timeoutId) {
+        timeoutId = setTimeout(() => {
+          var _a2, _b;
+          timeoutId = null;
+          if (ad == null ? void 0 : ad.viewableImpressionCounter) {
+            viewabilityTrackingPixelElement = addTrackingPixel(ad.viewableImpressionCounter);
+            logger.debug(`Viewability tracking pixel fired for ${getName()}`);
+            (_b = context.events) == null ? void 0 : _b.changeSlots.dispatch(Array.from(((_a2 = context.getAll) == null ? void 0 : _a2.call(context)) ?? []));
+          }
+        }, duration);
+      } else if (ratio < threshold && timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    }
+  }, {
+    rootMargin,
+    threshold: Array.from({ length: 11 }, (_, i) => i * 0.1)
+  });
+  if (element && context.options.viewabilityTracking)
+    viewabilityObserver.observe(element);
+  if (element)
+    renderIntersectionObserver.observe(element);
+  async function render(adToRender) {
+    var _a2, _b;
+    await waitForDomLoad();
+    ad = adToRender ?? ad ?? await requestAd({
+      slot: {
+        getName,
+        parameters
+      },
+      account: context.options.account,
+      host: context.options.host,
+      parameters: context.parameters,
+      context
+    });
+    if (!element) {
+      const error = `Could not create slot for format ${format}. No element found.`;
+      logger.error(error, options);
+      throw new Error(error);
+    }
+    if (context.debug)
+      element.style.position = "relative";
+    renderFunctions[renderMode](ad, element);
+    if ((ad == null ? void 0 : ad.impressionCounter) && !impressionTrackingPixelElement) {
+      impressionTrackingPixelElement = addTrackingPixel(ad.impressionCounter);
+      logger.debug(`Impression tracking pixel fired for ${getName()}`);
+    }
+    logger.debug("Slot rendered", {
+      renderedElement: element,
+      location: context.location,
+      format,
+      containingElement
+    });
+    renderIntersectionObserver.disconnect();
+    await ((_b = context.events) == null ? void 0 : _b.changeSlots.dispatchAsync(Array.from(((_a2 = context.getAll) == null ? void 0 : _a2.call(context)) ?? [])));
+    return element;
+  }
+  function cleanElement() {
+    if (!element)
+      return;
+    element.innerHTML = "";
+    element.style.position = "";
+    element.style.width = "";
+    element.style.height = "";
+  }
+  function getName() {
+    return `${context.location}${slot ? `${slot}` : ""}-${format}`;
+  }
+  function dispose() {
+    var _a2;
+    cleanElement();
+    impressionTrackingPixelElement == null ? void 0 : impressionTrackingPixelElement.remove();
+    viewabilityTrackingPixelElement == null ? void 0 : viewabilityTrackingPixelElement.remove();
+    element = null;
+    ad = null;
+    renderIntersectionObserver.disconnect();
+    viewabilityObserver.disconnect();
+    (_a2 = options.onDispose) == null ? void 0 : _a2.call(options);
+    queryDetector == null ? void 0 : queryDetector.dispose();
+  }
+  function isViewabilityTracked() {
+    return Boolean(viewabilityTrackingPixelElement);
+  }
+  function isImpressionTracked() {
+    return Boolean(impressionTrackingPixelElement);
+  }
+  return {
+    location: context.location,
+    lazyLoading: options.lazyLoading ?? false,
+    slot,
+    parameters,
+    setFormat,
+    getFormat,
+    render,
+    getElement,
+    getName,
+    getAd,
+    setAd,
+    isViewabilityTracked,
+    isImpressionTracked,
+    dispose
+  };
+}
+const numberLike = union([coerce.string().regex(/^\d+$/), literal("")]).transform((value) => value === "" ? void 0 : Number(value));
+const booleanLike = union([coerce.boolean(), literal("")]);
+const urlLike = union([coerce.string(), literal("")]).transform((value) => {
+  try {
+    return new URL(value);
+  } catch {
+    return void 0;
+  }
+});
+const dateLike = union([coerce.string(), literal("")]).transform((value) => {
+  if (value === "")
+    return void 0;
+  const date = new Date(numberLike.safeParse(value).success ? Number(value) : value);
+  if (Number.isNaN(date.getTime()))
+    return void 0;
+  return date;
+});
+const baseAdResponseScheme = object({
+  adDuration: numberLike.optional(),
+  adDuration2nd: numberLike.optional(),
+  adDuration3rd: numberLike.optional(),
+  adDuration4th: numberLike.optional(),
+  adDuration5th: numberLike.optional(),
+  adDuration6th: numberLike.optional(),
+  adFormat: string().optional(),
+  adType: string(),
+  additionalCreativeTracker: urlLike.optional(),
+  additionalViewableTracker: string().optional(),
+  adspaceEnd: dateLike.optional(),
+  adspaceId: string().optional(),
+  adspaceKey: string().optional(),
+  adspaceStart: dateLike.optional(),
+  advertiserId: string().optional(),
+  altText: string().optional(),
+  auctionable: booleanLike.optional(),
+  body: string().optional(),
+  clickTag: urlLike.optional(),
+  comment: string().optional(),
+  creativeName: string().optional(),
+  deliveryGroupId: string().optional(),
+  deliveryMultiples: string().optional(),
+  dm: string().optional(),
+  ext: string().optional(),
+  extension: object({
+    mediaType: string(),
+    prebid: unknown().optional()
+  }).optional(),
+  extraField1: string().optional(),
+  extraField2: string().optional(),
+  height: numberLike.optional(),
+  height3rd: numberLike.optional(),
+  height4th: numberLike.optional(),
+  height5th: numberLike.optional(),
+  height6th: numberLike.optional(),
+  heightLarge: numberLike.optional(),
+  id: string().optional(),
+  impressionCounter: urlLike.optional(),
+  libId: string().optional(),
+  orderId: string().optional(),
+  orderName: string().optional(),
+  orderProperty: string().optional(),
+  origin: string().optional(),
+  originData: unknown().optional(),
+  poolPath: urlLike.optional(),
+  preview: booleanLike.optional(),
+  priority: numberLike.optional(),
+  share: string().optional(),
+  // eslint-disable-next-line ts/naming-convention
+  slotID: string(),
+  slotName: string(),
+  swfSrc: urlLike.optional(),
+  swfSrc2nd: string().optional(),
+  swfSrc3rd: string().optional(),
+  swfSrc4th: string().optional(),
+  swfSrc5th: string().optional(),
+  swfSrc6th: string().optional(),
+  tag: string(),
+  tagUrl: urlLike.optional(),
+  timeStamp: dateLike.optional(),
+  trackedImpressionCounter: urlLike.optional(),
+  tracker: urlLike.optional(),
+  trackingUrl: urlLike.optional(),
+  url: urlLike.optional(),
+  viewableImpressionCounter: urlLike.optional(),
+  width: numberLike.optional(),
+  width3rd: numberLike.optional(),
+  width4th: numberLike.optional(),
+  width5th: numberLike.optional(),
+  width6th: numberLike.optional(),
+  widthLarge: numberLike.optional()
+});
+const adResponseSchema = baseAdResponseScheme.extend({
+  additionalCreatives: lazy(() => union([adResponseSchema.array(), string()]).optional())
+});
+const adSchema = adResponseSchema.transform(({
+  additionalCreatives,
+  ...data
+}) => {
+  const filteredValue = Object.fromEntries(
+    Object.entries(data).filter(([, value]) => Boolean(value) && JSON.stringify(value) !== "{}" && JSON.stringify(value) !== "[]")
+  );
+  return {
+    ...filteredValue,
+    additionalCreatives: Array.isArray(additionalCreatives) ? additionalCreatives.map((creative) => adSchema.parse(creative)) : additionalCreatives
+  };
+});
+async function requestPreviews(account) {
+  const previewObjects = getPreviewObjects();
+  const list = (await Promise.allSettled(previewObjects.filter((previewObject) => "adhesePreviewCreativeId" in previewObject).map(async (previewObject) => {
+    const endpoint = new URL(`https://${account}-preview.adhese.org/creatives/preview/json/tag.do`);
+    endpoint.searchParams.set(
+      "id",
+      previewObject.adhesePreviewCreativeId
+    );
+    const response = await fetch(endpoint.href, {
+      method: "GET",
+      headers: {
+        accept: "application/json"
+      }
+    });
+    if (!response.ok)
+      return Promise.reject(new Error(`Failed to request preview ad with ID: ${previewObject.adhesePreviewCreativeId}`));
+    return await response.json();
+  }))).filter((response) => {
+    if (response.status === "rejected") {
+      logger.error(response.reason);
+      return false;
+    }
+    return response.status === "fulfilled";
+  }).map((response) => response.value.map((item) => ({
+    ...item,
+    preview: true
+  })));
+  return adSchema.array().parse(list.flat());
+}
+function getPreviewObjects() {
+  const currentUrl = new URL(window.location.href);
+  const previewObjects = [];
+  let currentObject = {};
+  for (const [key, value] of currentUrl.searchParams.entries()) {
+    if (key === "adhesePreviewCreativeId" && Object.keys(currentObject).length > 0) {
+      previewObjects.push(currentObject);
+      currentObject = {};
+    }
+    currentObject[key] = value;
+  }
+  if (Object.keys(currentObject).length > 0)
+    previewObjects.push(currentObject);
+  return previewObjects;
+}
+function requestWithPost({
+  host,
+  ...options
+}) {
+  const payload = {
+    ...options,
+    slots: options.slots.map((slot) => ({
+      slotname: slot.getName(),
+      parameters: parseParameters(slot.parameters)
+    })),
+    parameters: options.parameters && parseParameters(options.parameters)
+  };
+  return fetch(`${new URL(host).href}json`, {
+    method: "POST",
+    body: JSON.stringify(payload),
+    headers: {
+      // eslint-disable-next-line ts/naming-convention
+      "Content-Type": "application/json"
+    }
+  });
+}
+async function requestWithGet(options) {
+  return fetch(new URL(`${options.host}/json/sl${options.slots.map((slot) => slot.getName()).join("/sl")}`), {
+    method: "GET",
+    headers: {
+      // eslint-disable-next-line ts/naming-convention
+      "Content-Type": "application/json"
+    }
+  });
+}
+function parseParameters(parameters) {
+  return Object.fromEntries(Array.from(parameters.entries()).filter(([key]) => {
+    if (key.length === 2)
+      return true;
+    logger.warn(`Invalid parameter key: ${key}. Key should be exactly 2 characters long. Key will be ignored.`);
+    return false;
+  }));
+}
+async function requestAds({
+  method = "POST",
+  context,
+  ...options
+}) {
+  var _a, _b, _c, _d;
+  try {
+    (_a = context.events) == null ? void 0 : _a.requestAd.dispatch({
+      ...options,
+      context,
+      method
+    });
+    const [response, previews] = await Promise.all([(method == null ? void 0 : method.toUpperCase()) === "POST" ? requestWithPost(options) : requestWithGet(options), requestPreviews(options.account)]);
+    logger.debug("Received response", response);
+    if (!response.ok)
+      throw new Error(`Failed to request ad: ${response.status} ${response.statusText}`);
+    const result = adSchema.array().parse(await response.json());
+    logger.debug("Parsed ad", result);
+    if (previews.length > 0)
+      logger.info(`Found ${previews.length} ${previews.length === 1 ? "preview" : "previews"}. Replacing ads in response with preview items`, previews);
+    const matchedPreviews = previews.map(({ slotName, ...preview }) => {
+      const partnerAd = result.find((ad) => ad.libId === preview.libId);
+      return {
+        slotName: `${(partnerAd == null ? void 0 : partnerAd.slotName) ?? slotName}`,
+        ...preview
+      };
+    });
+    if (matchedPreviews.length > 0)
+      (_b = context.events) == null ? void 0 : _b.previewReceived.dispatch(matchedPreviews);
+    const mergedResult = [
+      ...result.filter((ad) => !previews.some((preview) => preview.libId === ad.libId)),
+      ...matchedPreviews
+    ];
+    if (mergedResult.length === 0)
+      throw new Error("No ads found");
+    (_c = context.events) == null ? void 0 : _c.responseReceived.dispatch(mergedResult);
+    return mergedResult;
+  } catch (error) {
+    logger.error(String(error));
+    (_d = context.events) == null ? void 0 : _d.requestError.dispatch(error);
+    throw error;
+  }
+}
+async function requestAd({
+  slot,
+  ...options
+}) {
+  const [ad] = await requestAds({
+    slots: [slot],
+    ...options
+  });
+  return ad;
+}
+export {
+  createAdhese
+};
+//# sourceMappingURL=index.js.map