universal-ad-loader 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1266 @@
+// src/core/events.js
+function createEmitter() {
+  const handlers = {};
+  return {
+    on(evt, fn) {
+      (handlers[evt] = handlers[evt] || []).push(fn);
+      return () => this.off(evt, fn);
+    },
+    off(evt, fn) {
+      handlers[evt] = (handlers[evt] || []).filter((h) => h !== fn);
+    },
+    emit(evt, data) {
+      [...handlers[evt] || [], ...handlers["*"] || []].forEach((h) => {
+        try {
+          h(data, evt);
+        } catch (e) {
+          console.error("[UAL] handler error", evt, e);
+        }
+      });
+    }
+  };
+}
+
+// src/core/utils.js
+var PREFIX = "[UAL]";
+var debugOn = false;
+try {
+  debugOn = /[?&]ual_debug=1/.test(location.search) || localStorage.getItem("ual_debug") === "1";
+} catch (e) {
+}
+function setDebug(v) {
+  debugOn = !!v;
+}
+function isDebug() {
+  return debugOn;
+}
+function log(...a) {
+  if (debugOn) console.log(PREFIX, ...a);
+}
+function warn(...a) {
+  console.warn(PREFIX, ...a);
+}
+function loadScript(src, attrs = {}) {
+  return new Promise((resolve, reject) => {
+    const existing = document.querySelector(`script[data-ual-src="${src}"]`);
+    if (existing) {
+      if (existing.dataset.loaded) return resolve();
+      existing.addEventListener("load", () => resolve());
+      existing.addEventListener("error", reject);
+      return;
+    }
+    const s = document.createElement("script");
+    s.async = true;
+    s.src = src;
+    s.dataset.ualSrc = src;
+    Object.entries(attrs).forEach(([k, v]) => s.setAttribute(k, v));
+    s.onload = () => {
+      s.dataset.loaded = "1";
+      resolve();
+    };
+    s.onerror = () => reject(new Error("Script load failed: " + src));
+    document.head.appendChild(s);
+  });
+}
+function template(str, vars) {
+  return str.replace(/\{([\w.]+)\}/g, (_, path2) => {
+    const v = path2.split(".").reduce((o, k) => o == null ? void 0 : o[k], vars);
+    return v == null ? "" : encodeURIComponent(String(v));
+  });
+}
+function fire(urls) {
+  (urls || []).forEach((u) => {
+    if (!u) return;
+    try {
+      if (navigator.sendBeacon && navigator.sendBeacon(u)) return;
+    } catch (e) {
+    }
+    const img = new Image(1, 1);
+    img.src = u;
+  });
+}
+function withTimeout(promise, ms, fallbackValue) {
+  let t;
+  return Promise.race([
+    promise,
+    new Promise((resolve) => {
+      t = setTimeout(() => resolve(fallbackValue), ms);
+    })
+  ]).finally(() => clearTimeout(t));
+}
+function cb() {
+  return Math.floor(Math.random() * 1e10);
+}
+function deviceType() {
+  const w = window.innerWidth || document.documentElement.clientWidth;
+  return w < 768 ? "mobile" : w < 1024 ? "tablet" : "desktop";
+}
+
+// src/core/config.js
+var DEFAULTS = {
+  site: null,
+  consent: { mode: "tcf", timeoutMs: 4e3, requiredPurposes: [1] },
+  lazy: { enabled: true, fetchMargin: "200px" },
+  viewability: { threshold: 0.5, durationMs: 1e3 },
+  collapseEmpty: true,
+  providerTimeoutMs: 3e3,
+  targeting: {},
+  providers: {},
+  slots: {},
+  pageRules: []
+};
+async function loadConfig(source) {
+  let cfg = source;
+  if (typeof source === "string") {
+    const res = await fetch(source, { credentials: "omit" });
+    if (!res.ok) throw new Error("Config HTTP " + res.status);
+    cfg = await res.json();
+  }
+  return merge(DEFAULTS, cfg || {});
+}
+var CONSENT_MODES = ["optional", "required", "contextual"];
+function validateConfig(cfg, adapters) {
+  const w = (msg) => warn("Config: " + msg);
+  if (!cfg.site) w('manca "site"');
+  for (const [pid, p] of Object.entries(cfg.providers || {})) {
+    if (!p || !p.adapter) {
+      w(`provider "${pid}" senza "adapter"`);
+      continue;
+    }
+    if (adapters && !adapters.has(p.adapter)) w(`provider "${pid}": adapter "${p.adapter}" non registrato (registralo con registerAdapter prima dell'init)`);
+    if (p.consent && !CONSENT_MODES.includes(p.consent)) w(`provider "${pid}": consent "${p.consent}" non valido (${CONSENT_MODES.join("|")})`);
+  }
+  for (const [name, s] of Object.entries(cfg.slots || {})) {
+    if (!s || !Array.isArray(s.providers) || !s.providers.length) {
+      w(`slot "${name}" senza "providers"`);
+      continue;
+    }
+    s.providers.forEach((e) => {
+      const id = typeof e === "string" ? e : e && e.id;
+      if (!id || !cfg.providers[id]) w(`slot "${name}": provider "${id}" non definito in "providers"`);
+    });
+  }
+}
+function merge(a, b) {
+  const out = { ...a };
+  for (const k of Object.keys(b)) {
+    const v = b[k];
+    out[k] = v && typeof v === "object" && !Array.isArray(v) && a[k] && typeof a[k] === "object" && !Array.isArray(a[k]) ? merge(a[k], v) : v;
+  }
+  return out;
+}
+function resolveForPage(cfg, path2 = location.pathname) {
+  const resolved = { ...cfg, slots: JSON.parse(JSON.stringify(cfg.slots)), targeting: { ...cfg.targeting } };
+  for (const rule of cfg.pageRules || []) {
+    let re;
+    try {
+      re = new RegExp(rule.match);
+    } catch (e) {
+      warn("pageRule regex non valida", rule.match);
+      continue;
+    }
+    if (!re.test(path2)) continue;
+    (rule.disable || []).forEach((id) => {
+      if (resolved.slots[id]) resolved.slots[id].enabled = false;
+    });
+    (rule.enable || []).forEach((id) => {
+      if (resolved.slots[id]) resolved.slots[id].enabled = true;
+    });
+    Object.assign(resolved.targeting, rule.targeting || {});
+    Object.entries(rule.slots || {}).forEach(([id, o]) => {
+      resolved.slots[id] = { ...resolved.slots[id], ...o };
+    });
+  }
+  return resolved;
+}
+function sizesFor(slotCfg) {
+  const w = window.innerWidth || document.documentElement.clientWidth;
+  if (Array.isArray(slotCfg.sizeMapping) && slotCfg.sizeMapping.length) {
+    const match = [...slotCfg.sizeMapping].sort((x, y) => y.minWidth - x.minWidth).find((m) => w >= m.minWidth);
+    return match ? match.sizes : [];
+  }
+  return slotCfg.sizes || [];
+}
+
+// src/core/consent.js
+function waitForTcfApi(ms) {
+  return new Promise((resolve) => {
+    if (typeof window.__tcfapi === "function") return resolve(true);
+    const start = Date.now();
+    const iv = setInterval(() => {
+      if (typeof window.__tcfapi === "function") {
+        clearInterval(iv);
+        resolve(true);
+      } else if (Date.now() - start > ms) {
+        clearInterval(iv);
+        resolve(false);
+      }
+    }, 50);
+  });
+}
+function listen(opts, handler) {
+  window.__tcfapi("addEventListener", 2, (tcData, success) => {
+    if (!success || !tcData) return;
+    if (tcData.gdprApplies === false || tcData.eventStatus === "tcloaded" || tcData.eventStatus === "useractioncomplete") {
+      handler(normalize(tcData, opts));
+    }
+  });
+}
+var TIMEOUT = /* @__PURE__ */ Symbol("timeout");
+async function getConsent(cfg = {}, onUpdate) {
+  const opts = {
+    mode: "tcf",
+    // 'tcf' | 'none' (nessuna CMP, consenso considerato non necessario)
+    timeoutMs: 4e3,
+    // attesa massima della scelta utente / CMP
+    cmpWaitMs: 1500,
+    // attesa massima che __tcfapi compaia
+    lateWatchMs: 3e4,
+    // dopo cmpWaitMs, per quanto tempo continuare a cercare una CMP che arriva tardi
+    requiredPurposes: [1],
+    // purpose necessarie per "granted"
+    vendorId: null,
+    // ID GVL del tuo ad server, se registrato
+    ...cfg
+  };
+  if (opts.mode === "none") {
+    return { gdprApplies: false, tcString: "", purposes: {}, granted: true, source: "none" };
+  }
+  const hasApi = await waitForTcfApi(opts.cmpWaitMs);
+  if (!hasApi) {
+    log("Nessuna CMP TCF trovata (continuo a cercarla)");
+    if (onUpdate) {
+      waitForTcfApi(opts.lateWatchMs).then((found) => {
+        if (found) listen(opts, onUpdate);
+      });
+    }
+    return { gdprApplies: void 0, tcString: "", purposes: {}, granted: false, source: "no-cmp" };
+  }
+  let settled = false;
+  const first = new Promise((resolve) => {
+    listen(opts, (c) => {
+      if (!settled) {
+        settled = true;
+        resolve(c);
+      } else if (onUpdate) onUpdate(c);
+    });
+  });
+  const res = await withTimeout(first, opts.timeoutMs, TIMEOUT);
+  settled = true;
+  if (res === TIMEOUT) {
+    return { gdprApplies: true, tcString: "", purposes: {}, granted: false, source: "timeout" };
+  }
+  return res;
+}
+function normalize(tc, opts) {
+  const purposes = tc.purpose && tc.purpose.consents || {};
+  const vendorConsents = tc.vendor && tc.vendor.consents || {};
+  let granted = tc.gdprApplies === false || opts.requiredPurposes.every((p) => purposes[p] === true);
+  if (granted && tc.gdprApplies !== false && opts.vendorId) {
+    granted = vendorConsents[opts.vendorId] === true;
+  }
+  const out = {
+    gdprApplies: tc.gdprApplies,
+    tcString: tc.tcString || "",
+    purposes,
+    vendorConsents,
+    granted,
+    source: "tcf"
+  };
+  log("Consenso", out.granted ? "OK" : "limitato", out);
+  return out;
+}
+
+// src/core/render.js
+var DEFAULT_SANDBOX = "allow-scripts allow-popups allow-popups-to-escape-sandbox";
+var MAX_DIM = 2e3;
+var channelSeq = 0;
+var frames = /* @__PURE__ */ new Map();
+function dim(v) {
+  const n = Math.round(Number(v));
+  return n > 0 && n <= MAX_DIM ? n : 0;
+}
+function safeUrl(u, allowDataImage) {
+  if (typeof u !== "string" || !u) return null;
+  try {
+    const x = new URL(u, location.href);
+    if (x.protocol === "http:" || x.protocol === "https:") return x.href;
+    if (allowDataImage && x.protocol === "data:" && /^data:image\//i.test(x.href)) return x.href;
+  } catch (e) {
+  }
+  return null;
+}
+function cleanList(list) {
+  return (Array.isArray(list) ? list : []).map((u) => safeUrl(u)).filter(Boolean);
+}
+function normalizeAd(raw) {
+  if (!raw || typeof raw !== "object") return { ok: false, reason: "annuncio non valido" };
+  const type = raw.type || (raw.url ? "url" : raw.src ? "image" : "html");
+  const width = dim(raw.width);
+  const height = dim(raw.height);
+  if (!width || !height) return { ok: false, reason: `dimensioni non valide (${raw.width}x${raw.height}, max ${MAX_DIM})` };
+  const t = raw.trackers || {};
+  const ad = {
+    type,
+    width,
+    height,
+    alt: raw.alt == null ? void 0 : String(raw.alt),
+    clickUrl: safeUrl(raw.clickUrl) || "",
+    trackers: { impression: cleanList(t.impression), viewable: cleanList(t.viewable), click: cleanList(t.click) },
+    sandbox: typeof raw.sandbox === "string" ? raw.sandbox : void 0
+  };
+  if (type === "image") {
+    ad.src = safeUrl(raw.src, true);
+    if (!ad.src) return { ok: false, reason: "src immagine non valido (ammessi http, https, data:image)" };
+  } else if (type === "url") {
+    ad.url = safeUrl(raw.url);
+    if (!ad.url) return { ok: false, reason: "url non valido (ammessi solo http e https)" };
+  } else if (type === "html") {
+    if (typeof raw.html !== "string" || !raw.html) return { ok: false, reason: "html mancante" };
+    ad.html = raw.html;
+  } else {
+    return { ok: false, reason: "tipo sconosciuto: " + type };
+  }
+  return { ok: true, ad };
+}
+function tokens(s) {
+  return String(s).split(/\s+/).filter(Boolean);
+}
+function sandboxFor(ad) {
+  const asked = ad.sandbox && ad.sandbox !== "none" ? ad.sandbox : null;
+  if (ad.type === "url") {
+    let same = true;
+    try {
+      same = new URL(ad.url).origin === location.origin;
+    } catch (e) {
+    }
+    if (ad.sandbox === "none" && !same) return null;
+    return tokens(asked || DEFAULT_SANDBOX + " allow-same-origin").filter((t) => t !== "allow-top-navigation" && !(same && t === "allow-same-origin")).join(" ");
+  }
+  return tokens(asked || DEFAULT_SANDBOX).filter((t) => t !== "allow-top-navigation" && t !== "allow-same-origin").join(" ");
+}
+function jsStr(v) {
+  return JSON.stringify(String(v)).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function extScript(channel, clickUrl) {
+  return `<script>(function(){
+var C=${jsStr(channel)};
+function s(m){m.ual=C;parent.postMessage(m,'*');}
+window.clickTag=${jsStr(clickUrl || "")};
+window.UALExt={
+  resize:function(w,h){s({cmd:'resize',w:w,h:h});},
+  expand:function(w,h){s({cmd:'resize',w:w,h:h,expanded:true});},
+  collapse:function(){s({cmd:'collapse'});},
+  close:function(){s({cmd:'close'});},
+  click:function(){s({cmd:'click'});if(window.clickTag)window.open(window.clickTag,'_blank');}
+};
+})();</script>`;
+}
+function escapeAttr(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildSrcdoc(ad, channel) {
+  const base = '<!doctype html><html><head><meta charset="utf-8"><base target="_blank"><style>html,body{margin:0;padding:0;overflow:hidden;background:transparent}img{display:block;border:0;max-width:100%}</style>' + extScript(channel, ad.clickUrl) + "</head><body>";
+  let body = "";
+  if (ad.type === "image") {
+    const img = `<img src="${escapeAttr(ad.src)}" width="${ad.width}" height="${ad.height}" alt="${escapeAttr(ad.alt || "Advertisement")}">`;
+    body = ad.clickUrl ? `<a href="${escapeAttr(ad.clickUrl)}" rel="noopener sponsored" onclick="parent.postMessage({ual:'${channel}',cmd:'click'},'*')">${img}</a>` : img;
+  } else {
+    body = ad.html || "";
+  }
+  return base + body + "</body></html>";
+}
+function renderInFrame(container, ad, { slotId, onClick, onClose } = {}) {
+  ensureListener();
+  const channel = "ual" + ++channelSeq;
+  const iframe = document.createElement("iframe");
+  iframe.title = "Advertisement";
+  iframe.setAttribute("scrolling", "no");
+  iframe.setAttribute("frameborder", "0");
+  iframe.setAttribute("loading", "eager");
+  iframe.setAttribute("referrerpolicy", "strict-origin-when-cross-origin");
+  iframe.style.cssText = `border:0;display:block;margin:0 auto;width:${ad.width}px;height:${ad.height}px;max-width:100%`;
+  iframe.width = ad.width;
+  iframe.height = ad.height;
+  const sb = sandboxFor(ad);
+  if (sb !== null) iframe.setAttribute("sandbox", sb);
+  if (ad.type === "url") iframe.src = ad.url;
+  else iframe.srcdoc = buildSrcdoc(ad, channel);
+  frames.set(channel, {
+    iframe,
+    slotId,
+    ad,
+    original: { w: ad.width, h: ad.height },
+    onClick: () => {
+      fire(ad.trackers && ad.trackers.click);
+      if (onClick) onClick();
+    },
+    onClose
+  });
+  container.innerHTML = "";
+  container.appendChild(iframe);
+  return { iframe, channel, destroy: () => frames.delete(channel) };
+}
+var listening = false;
+function ensureListener() {
+  if (listening) return;
+  listening = true;
+  window.addEventListener("message", onMessage);
+}
+function onMessage(e) {
+  const d = e.data;
+  if (!d || typeof d !== "object" || !d.ual) return;
+  const f = frames.get(d.ual);
+  if (!f || e.source !== f.iframe.contentWindow) return;
+  switch (d.cmd) {
+    case "resize": {
+      const w = Math.min(+d.w || f.original.w, MAX_DIM);
+      const h = Math.min(+d.h || f.original.h, MAX_DIM);
+      f.iframe.style.width = w + "px";
+      f.iframe.style.height = h + "px";
+      break;
+    }
+    case "collapse":
+      f.iframe.style.width = f.original.w + "px";
+      f.iframe.style.height = f.original.h + "px";
+      break;
+    case "close":
+      if (f.onClose) f.onClose();
+      break;
+    case "click":
+      f.onClick();
+      break;
+    default:
+  }
+}
+
+// src/core/viewability.js
+function watchViewability(el, { threshold = 0.5, durationMs = 1e3 } = {}, onViewable) {
+  if (!("IntersectionObserver" in window)) return () => {
+  };
+  let timer = null;
+  let done = false;
+  let inView = false;
+  const start = () => {
+    if (done || timer || document.visibilityState !== "visible") return;
+    timer = setTimeout(() => {
+      done = true;
+      cleanup();
+      onViewable();
+    }, durationMs);
+  };
+  const stop = () => {
+    clearTimeout(timer);
+    timer = null;
+  };
+  const io = new IntersectionObserver((entries) => {
+    entries.forEach((en) => {
+      inView = en.intersectionRatio >= threshold;
+      if (inView) start();
+      else stop();
+    });
+  }, { threshold: [0, threshold, 1] });
+  const onVis = () => document.visibilityState === "visible" && inView ? start() : stop();
+  document.addEventListener("visibilitychange", onVis);
+  io.observe(el);
+  function cleanup() {
+    stop();
+    io.disconnect();
+    document.removeEventListener("visibilitychange", onVis);
+  }
+  return cleanup;
+}
+
+// src/core/engine.js
+var FINAL_STATUS = /* @__PURE__ */ new Set(["unconfigured", "disabled", "closed"]);
+var LARGE_AD_AREA = 242500;
+function createEngine(adapterRegistry) {
+  const bus = createEmitter();
+  let cfg = null;
+  let rawCfg = null;
+  const userTargeting = {};
+  let consent = { gdprApplies: void 0, tcString: "", purposes: {}, granted: false, source: "pending" };
+  let consentReady = Promise.resolve(consent);
+  let ready = false;
+  let initPromise = null;
+  const slots = /* @__PURE__ */ new Map();
+  const providerInit = /* @__PURE__ */ new Map();
+  let seq2 = 0;
+  let lazyIO = null;
+  let mo = null;
+  let pending = /* @__PURE__ */ new Set();
+  let flushTimer = null;
+  function ctx() {
+    return {
+      site: cfg.site,
+      page: { url: location.href, path: location.pathname, ref: document.referrer, title: document.title },
+      device: deviceType(),
+      viewport: { w: window.innerWidth, h: window.innerHeight },
+      targeting: { ...cfg.targeting },
+      consent,
+      debug: isDebug()
+    };
+  }
+  function resolveCfg() {
+    const c = resolveForPage(rawCfg);
+    Object.assign(c.targeting, userTargeting);
+    return c;
+  }
+  function setConsent(c) {
+    const prev = consent;
+    if (prev.granted === c.granted && prev.tcString === c.tcString && prev.source === c.source) return;
+    consent = c;
+    bus.emit("consent", consent);
+    if (!prev.granted && c.granted) {
+      for (const s of [...slots.values()]) if (s.consentSkipped) refreshWhenIdle(s);
+    }
+  }
+  function refreshWhenIdle(s, tries = 20) {
+    if (slots.get(s.instanceId) !== s) return;
+    if (s.status === "loading" || s.status === "queued") {
+      if (tries > 0) setTimeout(() => refreshWhenIdle(s, tries - 1), 250);
+      return;
+    }
+    refreshSlot(s);
+  }
+  function init(source) {
+    if (initPromise) {
+      warn("init gi\xE0 eseguito");
+      return initPromise;
+    }
+    initPromise = doInit(source).catch((e) => {
+      initPromise = null;
+      throw e;
+    });
+    return initPromise;
+  }
+  async function doInit(source) {
+    rawCfg = await loadConfig(source);
+    if (rawCfg.debug) setDebug(true);
+    validateConfig(rawCfg, adapterRegistry);
+    cfg = resolveCfg();
+    log("Config", cfg);
+    consentReady = getConsent(cfg.consent, setConsent).then((c) => {
+      setConsent(c);
+      return c;
+    });
+    if (document.readyState === "loading") {
+      await new Promise((r) => document.addEventListener("DOMContentLoaded", r, { once: true }));
+    }
+    ready = true;
+    setupLazy();
+    scan(document);
+    observeDom();
+    bus.emit("ready", { site: cfg.site });
+  }
+  function scan(root) {
+    const list = [];
+    if (root.nodeType === 1 && root.matches && root.matches("[data-ad-slot]")) list.push(root);
+    if (root.querySelectorAll) root.querySelectorAll("[data-ad-slot]").forEach((el) => list.push(el));
+    list.forEach(maybeRegister);
+  }
+  function maybeRegister(el) {
+    const id = el.dataset.ualId;
+    if (!id) return register(el);
+    if (slots.has(id)) return;
+    if (FINAL_STATUS.has(el.dataset.ualStatus)) return;
+    resetEl(el);
+    register(el);
+  }
+  function resetEl(el) {
+    delete el.dataset.ualId;
+    delete el.dataset.ualStatus;
+    el.querySelectorAll(":scope > .ual-label, :scope > .ual-creative").forEach((n) => n.remove());
+    el.classList.remove("ual-slot", "ual-filled");
+    el.style.display = "";
+    el.style.minHeight = "";
+  }
+  function register(el) {
+    const name = el.getAttribute("data-ad-slot");
+    const slotCfg = cfg.slots[name];
+    el.dataset.ualId = name + "#" + ++seq2;
+    if (!slotCfg) {
+      log("Slot non configurato, ignorato:", name);
+      el.dataset.ualStatus = "unconfigured";
+      return;
+    }
+    if (slotCfg.enabled === false) {
+      log("Slot disabilitato:", name);
+      el.dataset.ualStatus = "disabled";
+      collapse(el, slotCfg);
+      return;
+    }
+    let params = {};
+    try {
+      params = el.dataset.adParams ? JSON.parse(el.dataset.adParams) : {};
+    } catch (e) {
+      warn("data-ad-params non \xE8 JSON valido", el);
+    }
+    const slot = {
+      instanceId: el.dataset.ualId,
+      name,
+      el,
+      cfg: slotCfg,
+      params,
+      status: "idle",
+      cleanup: [],
+      tries: 0,
+      consentSkipped: false
+    };
+    slots.set(slot.instanceId, slot);
+    prepare(slot);
+    bus.emit("slotRegistered", publicSlot(slot));
+    const lazy = slotCfg.lazy !== void 0 ? slotCfg.lazy : cfg.lazy.enabled;
+    if (lazy && lazyIO) lazyIO.observe(el);
+    else enqueue(slot);
+  }
+  function prepare(slot) {
+    const { el, cfg: c } = slot;
+    if (c.minHeight) el.style.minHeight = c.minHeight + "px";
+    el.classList.add("ual-slot");
+    if (c.label) {
+      const l = document.createElement("div");
+      l.className = "ual-label";
+      l.textContent = c.label;
+      l.style.cssText = "font:10px/1.4 sans-serif;color:#888;text-align:center;text-transform:uppercase;letter-spacing:.05em";
+      el.appendChild(l);
+    }
+    const box = document.createElement("div");
+    box.className = "ual-creative";
+    el.appendChild(box);
+    slot.box = box;
+  }
+  function observeDom() {
+    if (!("MutationObserver" in window)) return;
+    mo = new MutationObserver((muts) => {
+      for (const m of muts) {
+        m.removedNodes.forEach((n) => {
+          if (n.nodeType !== 1) return;
+          for (const s of [...slots.values()]) if (n === s.el || n.contains(s.el)) destroySlot(s);
+        });
+        m.addedNodes.forEach((n) => {
+          if (n.nodeType === 1) scan(n);
+        });
+      }
+    });
+    mo.observe(document.body || document.documentElement, { childList: true, subtree: true });
+  }
+  function setupLazy() {
+    if (!("IntersectionObserver" in window)) return;
+    lazyIO = new IntersectionObserver((entries) => {
+      entries.forEach((en) => {
+        if (!en.isIntersecting) return;
+        lazyIO.unobserve(en.target);
+        const s = slots.get(en.target.dataset.ualId);
+        if (s) enqueue(s);
+      });
+    }, { rootMargin: cfg.lazy.fetchMargin });
+  }
+  function enqueue(slot) {
+    if (slot.status === "loading") return;
+    slot.status = "queued";
+    pending.add(slot);
+    clearTimeout(flushTimer);
+    flushTimer = setTimeout(flush, 30);
+  }
+  function flush() {
+    const batch = [...pending];
+    pending = /* @__PURE__ */ new Set();
+    if (batch.length) runTier(batch, 0);
+  }
+  async function runTier(batch, tier) {
+    const groups = /* @__PURE__ */ new Map();
+    const exhausted = [];
+    for (const s of batch) {
+      const entry = (s.cfg.providers || [])[tier];
+      if (!entry) {
+        exhausted.push(s);
+        continue;
+      }
+      const pid = typeof entry === "string" ? entry : entry.id;
+      if (!groups.has(pid)) groups.set(pid, []);
+      groups.get(pid).push(s);
+    }
+    exhausted.forEach(markEmpty);
+    await Promise.all([...groups.entries()].map(async ([pid, group]) => {
+      const unfilled = await runProvider(pid, group, tier);
+      if (unfilled.length) await runTier(unfilled, tier + 1);
+    }));
+  }
+  async function ensureProvider(pid) {
+    const pcfg = cfg.providers[pid];
+    if (!pcfg) throw new Error("Provider non definito: " + pid);
+    const adapter = adapterRegistry.get(pcfg.adapter);
+    if (!adapter) throw new Error("Adapter non registrato: " + pcfg.adapter);
+    if (!providerInit.has(pid)) {
+      providerInit.set(pid, Promise.resolve(adapter.init ? adapter.init(pcfg, ctx()) : null));
+    }
+    await providerInit.get(pid);
+    return { adapter, pcfg };
+  }
+  async function runProvider(pid, group, tier) {
+    const peek = cfg.providers[pid];
+    if (!peek || peek.consent !== "contextual") await consentReady;
+    group = group.filter((s) => slots.get(s.instanceId) === s);
+    if (!group.length) return [];
+    let adapter, pcfg;
+    try {
+      ({ adapter, pcfg } = await ensureProvider(pid));
+    } catch (e) {
+      warn(e.message);
+      bus.emit("error", { provider: pid, error: e });
+      return group;
+    }
+    if (pcfg.consent === "required" && !consent.granted) {
+      log(`Provider ${pid} saltato: consenso non concesso`);
+      group.forEach((s) => {
+        s.consentSkipped = true;
+      });
+      return group;
+    }
+    const c = ctx();
+    const req = group.map((s) => {
+      s.status = "loading";
+      s.provider = pid;
+      const entry = s.cfg.providers[tier];
+      return {
+        id: s.instanceId,
+        name: s.name,
+        el: s.box,
+        sizes: sizesFor(s.cfg),
+        params: { ...typeof entry === "object" ? entry.params : {}, ...s.params },
+        cfg: s.cfg
+      };
+    });
+    req.forEach((r) => bus.emit("slotRequested", { slot: r.name, id: r.id, provider: pid }));
+    log(`Richiesta a ${pid} (${pcfg.adapter})`, req.map((r) => r.name));
+    const timeout = pcfg.timeoutMs || cfg.providerTimeoutMs;
+    const unfilled = [];
+    try {
+      if (adapter.fill) {
+        const res = await withTimeout(adapter.fill(req, pcfg, c), timeout + 2e3, {});
+        group.forEach((s, i) => {
+          const r = res[req[i].id];
+          if (r && r.filled) onFilled(s, { width: r.width, height: r.height, selfRendered: true, meta: r.meta });
+          else {
+            callDestroy(s);
+            clear(s);
+            unfilled.push(s);
+          }
+        });
+      } else {
+        const res = await withTimeout(adapter.request(req, pcfg, c), timeout, {});
+        group.forEach((s, i) => {
+          const raw = res[req[i].id];
+          if (!raw || !raw.html && !raw.src && !raw.url) {
+            unfilled.push(s);
+            return;
+          }
+          const n = normalizeAd(raw);
+          if (!n.ok) {
+            warn(`Annuncio scartato (${pid}, slot ${s.name}): ${n.reason}`);
+            bus.emit("error", { provider: pid, slot: s.name, error: new Error(n.reason) });
+            unfilled.push(s);
+            return;
+          }
+          const ad = n.ad;
+          const handle = renderInFrame(s.box, ad, {
+            slotId: s.instanceId,
+            onClick: () => bus.emit("slotClick", publicSlot(s)),
+            onClose: () => {
+              destroySlot(s);
+              s.el.dataset.ualStatus = "closed";
+              collapse(s.el, s.cfg, true);
+            }
+          });
+          s.cleanup.push(handle.destroy);
+          fire(ad.trackers.impression);
+          onFilled(s, { width: ad.width, height: ad.height, ad });
+        });
+      }
+    } catch (e) {
+      warn(`Errore provider ${pid}`, e);
+      bus.emit("error", { provider: pid, error: e });
+      group.forEach((s) => {
+        if (s.status === "loading") {
+          callDestroy(s);
+          clear(s);
+          unfilled.push(s);
+        }
+      });
+    }
+    return unfilled;
+  }
+  function onFilled(s, info) {
+    s.status = "filled";
+    s.el.dataset.ualStatus = "filled";
+    s.el.classList.add("ual-filled");
+    s.el.style.display = "";
+    bus.emit("slotRendered", { ...publicSlot(s), width: info.width, height: info.height, meta: info.meta });
+    const vcfg = { ...cfg.viewability, ...s.cfg.viewability };
+    const area = (info.width || 0) * (info.height || 0);
+    if (area > LARGE_AD_AREA && !(s.cfg.viewability && s.cfg.viewability.threshold !== void 0)) {
+      vcfg.threshold = Math.min(vcfg.threshold, 0.3);
+    }
+    const target = s.box.firstElementChild || s.box;
+    const stop = watchViewability(target, vcfg, () => {
+      if (info.ad) fire(info.ad.trackers.viewable);
+      bus.emit("slotViewable", publicSlot(s));
+      scheduleRefresh(s);
+    });
+    s.cleanup.push(stop);
+  }
+  function markEmpty(s) {
+    s.status = "empty";
+    s.el.dataset.ualStatus = "empty";
+    clear(s);
+    collapse(s.el, s.cfg);
+    bus.emit("slotEmpty", publicSlot(s));
+  }
+  function collapse(el, c, force) {
+    const doCollapse = force || (c.collapseEmpty !== void 0 ? c.collapseEmpty : cfg && cfg.collapseEmpty);
+    if (doCollapse) {
+      el.style.display = "none";
+      el.style.minHeight = "";
+    }
+  }
+  function clear(s) {
+    s.cleanup.forEach((fn) => {
+      try {
+        fn();
+      } catch (e) {
+      }
+    });
+    s.cleanup = [];
+    if (s.box) s.box.innerHTML = "";
+  }
+  function callDestroy(s) {
+    const pc = s.provider && cfg.providers[s.provider];
+    const adapter = pc && adapterRegistry.get(pc.adapter);
+    if (adapter && adapter.destroy) {
+      try {
+        adapter.destroy({ id: s.instanceId, el: s.box }, pc);
+      } catch (e) {
+      }
+    }
+  }
+  function scheduleRefresh(s) {
+    const sec = s.cfg.refreshSec;
+    if (!sec || s.cfg.maxRefresh && s.tries >= s.cfg.maxRefresh) return;
+    const arm = () => {
+      s.refreshTimer = setTimeout(() => {
+        if (!slots.has(s.instanceId)) return;
+        const r = s.el.getBoundingClientRect();
+        const onScreen = r.bottom > 0 && r.top < window.innerHeight;
+        if (onScreen && document.visibilityState === "visible") {
+          s.tries++;
+          refreshSlot(s);
+        } else arm();
+      }, sec * 1e3);
+    };
+    arm();
+    s.cleanup.push(() => clearTimeout(s.refreshTimer));
+  }
+  function refreshSlot(s) {
+    if (s.status === "loading" || s.status === "queued") return;
+    callDestroy(s);
+    clear(s);
+    s.status = "idle";
+    s.consentSkipped = false;
+    enqueue(s);
+  }
+  function destroySlot(s) {
+    callDestroy(s);
+    clear(s);
+    if (lazyIO) lazyIO.unobserve(s.el);
+    slots.delete(s.instanceId);
+  }
+  function publicSlot(s) {
+    return { slot: s.name, id: s.instanceId, provider: s.provider, status: s.status, el: s.el };
+  }
+  return {
+    init,
+    // true se init è già stato avviato (anche se non ancora completato)
+    isInitialized: () => initPromise !== null,
+    // promessa dell'init in corso o completato (null se mai avviato): permette di attendere senza richiamare init
+    whenReady: () => initPromise,
+    on: bus.on.bind(bus),
+    off: bus.off.bind(bus),
+    registerAdapter: (name, impl) => adapterRegistry.set(name, impl),
+    // Targeting key-value: vale anche se chiamato prima dell'init e resta dopo pageView().
+    // Un valore null/undefined rimuove la chiave.
+    setTargeting(kv) {
+      Object.entries(kv || {}).forEach(([k, v]) => {
+        if (v == null) {
+          delete userTargeting[k];
+          if (cfg) delete cfg.targeting[k];
+        } else {
+          userTargeting[k] = v;
+          if (cfg) cfg.targeting[k] = v;
+        }
+      });
+    },
+    refresh(names) {
+      for (const s of slots.values()) if (!names || names.includes(s.name)) refreshSlot(s);
+    },
+    // Per SPA: chiamare dopo il cambio di route
+    pageView() {
+      if (!ready) return;
+      for (const s of [...slots.values()]) destroySlot(s);
+      document.querySelectorAll("[data-ual-id]").forEach(resetEl);
+      cfg = resolveCfg();
+      scan(document);
+    },
+    getSlots: () => [...slots.values()].map(publicSlot),
+    getConsent: () => consent,
+    debug: setDebug
+  };
+}
+
+// src/adapters/json.js
+var json_default = {
+  name: "json",
+  async request(slots, p, ctx) {
+    const body = {
+      site: ctx.site,
+      page: ctx.page,
+      device: ctx.device,
+      viewport: ctx.viewport,
+      targeting: ctx.targeting,
+      consent: { gdprApplies: ctx.consent.gdprApplies, tcString: ctx.consent.tcString, granted: ctx.consent.granted },
+      slots: slots.map((s) => ({ id: s.id, name: s.name, sizes: s.sizes, params: s.params }))
+    };
+    const res = await fetch(p.endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...p.headers },
+      body: JSON.stringify(body),
+      credentials: p.withCredentials && ctx.consent.granted ? "include" : "omit",
+      keepalive: false
+    });
+    if (res.status === 204) return {};
+    if (!res.ok) throw new Error("decide HTTP " + res.status);
+    let data = await res.json();
+    if (p.map && typeof window[p.map] === "function") data = window[p.map](data, slots);
+    const out = {};
+    (data.ads || []).forEach((ad) => {
+      if (ad && ad.slotId) out[ad.slotId] = ad;
+    });
+    return out;
+  }
+};
+
+// src/adapters/iframe.js
+var iframe_default = {
+  name: "iframe",
+  async request(slots, p, ctx) {
+    const out = {};
+    slots.forEach((s) => {
+      const [w, h] = s.sizes && s.sizes[0] || [s.params.width || 300, s.params.height || 250];
+      const url = template(p.url, {
+        params: s.params,
+        width: w,
+        height: h,
+        site: ctx.site,
+        slot: s.name,
+        device: ctx.device,
+        cb: cb(),
+        page: ctx.page,
+        consent: { tcString: ctx.consent.tcString, gdpr: ctx.consent.gdprApplies ? 1 : 0 }
+      });
+      out[s.id] = { type: "url", url, width: w, height: h, sandbox: p.sandbox || void 0 };
+    });
+    return out;
+  }
+};
+
+// src/adapters/revive.js
+function deliveryBase(p) {
+  return p.server.replace(/\/$/, "") + (p.deliveryPath || "/www/delivery");
+}
+var revive_default = {
+  name: "revive",
+  // modalità iframe
+  async request(slots, p, ctx) {
+    const out = {};
+    slots.forEach((s) => {
+      if (s.params.zoneid == null) {
+        warn(`revive: zoneid mancante per lo slot "${s.name}", slot saltato`);
+        return;
+      }
+      const [w, h] = s.sizes && s.sizes[0] || [300, 250];
+      const q = new URLSearchParams({ zoneid: s.params.zoneid, cb: cb() });
+      if (ctx.page.ref) q.set("referer", ctx.page.ref);
+      Object.entries(s.params.vars || {}).forEach(([k, v]) => q.set(k, v));
+      out[s.id] = { type: "url", url: `${deliveryBase(p)}/afr.php?${q}`, width: w, height: h };
+    });
+    return out;
+  }
+};
+var reviveAsync = {
+  name: "revive-async",
+  async fill(slots, p) {
+    const res = {};
+    const src = `${deliveryBase(p)}/asyncjs.php`;
+    const valid = slots.filter((s) => {
+      if (s.params.zoneid != null) return true;
+      warn(`revive-async: zoneid mancante per lo slot "${s.name}", slot saltato`);
+      res[s.id] = { filled: false };
+      return false;
+    });
+    if (!valid.length) return res;
+    const waits = valid.map((s) => {
+      const ins = document.createElement("ins");
+      ins.setAttribute("data-revive-zoneid", s.params.zoneid);
+      ins.setAttribute("data-revive-id", p.reviveId);
+      Object.entries(s.params.vars || {}).forEach(([k, v]) => ins.setAttribute("data-revive-" + k, v));
+      s.el.appendChild(ins);
+      return new Promise((resolve) => {
+        const done = (filled) => {
+          mo.disconnect();
+          clearTimeout(t);
+          const r = ins.getBoundingClientRect();
+          res[s.id] = { filled, width: Math.round(r.width), height: Math.round(r.height) };
+          resolve();
+        };
+        const mo = new MutationObserver(() => {
+          if (ins.querySelector("img,iframe,a,div,embed")) done(true);
+        });
+        mo.observe(ins, { childList: true, subtree: true });
+        const t = setTimeout(() => done(ins.children.length > 0), p.fillTimeoutMs || 2500);
+      });
+    });
+    const ra = window.reviveAsync && window.reviveAsync[p.reviveId];
+    if (ra && typeof ra.refresh === "function") ra.refresh();
+    else await loadScript(src);
+    await Promise.all(waits);
+    return res;
+  }
+};
+
+// src/adapters/gpt.js
+var seq = 0;
+var gptSlots = /* @__PURE__ */ new Map();
+function path(tpl, vars) {
+  return tpl.replace(/\{([\w.]+)\}/g, (_, k) => {
+    const v = k.split(".").reduce((o, x) => o == null ? void 0 : o[x], vars);
+    return v == null ? "" : String(v);
+  });
+}
+var appliedKeys = /* @__PURE__ */ new Set();
+function applyTargeting(pa, targeting) {
+  const next = targeting || {};
+  appliedKeys.forEach((k) => {
+    if (!(k in next)) {
+      try {
+        pa.clearTargeting(k);
+      } catch (e) {
+      }
+      appliedKeys.delete(k);
+    }
+  });
+  Object.entries(next).forEach(([k, v]) => {
+    pa.setTargeting(k, v);
+    appliedKeys.add(k);
+  });
+}
+var gpt_default = {
+  name: "gpt",
+  async init(p, ctx) {
+    window.googletag = window.googletag || { cmd: [] };
+    const gt = window.googletag;
+    gt.cmd.push(() => {
+      const pa = gt.pubads();
+      if (p.singleRequest !== false) pa.enableSingleRequest();
+      pa.disableInitialLoad();
+      pa.collapseEmptyDivs(false);
+      if (p.nonPersonalizedWithoutConsent && ctx.consent && !ctx.consent.granted) {
+        if (pa.setPrivacySettings) pa.setPrivacySettings({ nonPersonalizedAds: true });
+      }
+      gt.enableServices();
+    });
+    await loadScript(p.src || "https://securepubads.g.doubleclick.net/tag/js/gpt.js", { crossorigin: "anonymous" });
+  },
+  fill(slots, p, ctx) {
+    return new Promise((resolve) => {
+      const gt = window.googletag;
+      const res = {};
+      let left = slots.length;
+      gt.cmd.push(() => {
+        const pa = gt.pubads();
+        applyTargeting(pa, ctx.targeting);
+        const defined = [];
+        const byDiv = {};
+        slots.forEach((s) => {
+          const div = document.createElement("div");
+          div.id = "ual-gpt-" + ++seq;
+          s.el.appendChild(div);
+          const unit = s.params.adUnitPath || path(p.adUnitPath, {
+            network: p.network,
+            site: ctx.site,
+            slot: s.name,
+            section: s.params.section,
+            params: s.params
+          });
+          const sizes = s.sizes.length ? s.sizes : ["fluid"];
+          const slot = gt.defineSlot(unit, sizes, div.id);
+          if (!slot) {
+            res[s.id] = { filled: false };
+            left--;
+            return;
+          }
+          slot.addService(pa);
+          Object.entries(s.params.targeting || {}).forEach(([k, v]) => slot.setTargeting(k, v));
+          gptSlots.set(s.id, slot);
+          byDiv[div.id] = s.id;
+          defined.push(slot);
+          gt.display(div.id);
+        });
+        if (!left) return resolve(res);
+        let guard;
+        const finish = () => {
+          clearTimeout(guard);
+          pa.removeEventListener("slotRenderEnded", onEnd);
+          Object.values(byDiv).forEach((id) => {
+            if (!res[id]) res[id] = { filled: false };
+          });
+          resolve(res);
+        };
+        const onEnd = (e) => {
+          const id = byDiv[e.slot.getSlotElementId()];
+          if (!id || res[id]) return;
+          const [w, h] = Array.isArray(e.size) ? e.size : [0, 0];
+          res[id] = {
+            filled: !e.isEmpty,
+            width: w,
+            height: h,
+            meta: { advertiserId: e.advertiserId, lineItemId: e.lineItemId, creativeId: e.creativeId }
+          };
+          if (--left === 0) finish();
+        };
+        pa.addEventListener("slotRenderEnded", onEnd);
+        guard = setTimeout(finish, p.fillTimeoutMs || 4e3);
+        pa.refresh(defined);
+      });
+    });
+  },
+  destroy(s) {
+    const slot = gptSlots.get(s.id);
+    if (slot && window.googletag && window.googletag.destroySlots) {
+      window.googletag.destroySlots([slot]);
+      gptSlots.delete(s.id);
+    }
+  }
+};
+
+// src/adapters/adsense.js
+var adsense_default = {
+  name: "adsense",
+  async init(p) {
+    await loadScript(
+      `https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=${encodeURIComponent(p.client)}`,
+      { crossorigin: "anonymous" }
+    );
+  },
+  fill(slots, p) {
+    return Promise.all(slots.map((s) => new Promise((resolve) => {
+      const ins = document.createElement("ins");
+      ins.className = "adsbygoogle";
+      ins.setAttribute("data-ad-client", p.client);
+      ins.setAttribute("data-ad-slot", s.params.slot);
+      const [w, h] = s.sizes[0] || [];
+      if (s.params.format || !w) {
+        ins.style.display = "block";
+        ins.setAttribute("data-ad-format", s.params.format || "auto");
+        if (s.params.responsive !== false) ins.setAttribute("data-full-width-responsive", "true");
+      } else {
+        ins.style.cssText = `display:inline-block;width:${w}px;height:${h}px`;
+      }
+      if (p.test) ins.setAttribute("data-adtest", "on");
+      s.el.appendChild(ins);
+      const finish = (filled) => {
+        mo.disconnect();
+        clearTimeout(t);
+        const r = ins.getBoundingClientRect();
+        resolve([s.id, { filled, width: Math.round(r.width), height: Math.round(r.height) }]);
+      };
+      const mo = new MutationObserver(() => {
+        const st = ins.getAttribute("data-ad-status");
+        if (st === "filled") finish(true);
+        else if (st === "unfilled") finish(false);
+      });
+      mo.observe(ins, { attributes: true, attributeFilter: ["data-ad-status"] });
+      const t = setTimeout(() => finish(!!ins.querySelector("iframe")), p.fillTimeoutMs || 4e3);
+      try {
+        (window.adsbygoogle = window.adsbygoogle || []).push({});
+      } catch (e) {
+        finish(false);
+      }
+    }))).then((pairs) => Object.fromEntries(pairs));
+  }
+};
+
+// src/adapters/house.js
+function pick(list) {
+  const total = list.reduce((a, c) => a + (c.weight || 1), 0);
+  let r = Math.random() * total;
+  for (const c of list) {
+    r -= c.weight || 1;
+    if (r <= 0) return c;
+  }
+  return list[list.length - 1];
+}
+var house_default = {
+  name: "house",
+  async request(slots, p, ctx) {
+    const now = Date.now();
+    const out = {};
+    slots.forEach((s) => {
+      const ok = (p.creatives || []).filter((c) => {
+        if (c.slots && !c.slots.includes(s.name)) return false;
+        if (c.devices && !c.devices.includes(ctx.device)) return false;
+        if (c.from && now < Date.parse(c.from)) return false;
+        if (c.to && now > Date.parse(c.to) + 864e5) return false;
+        if (s.sizes.length && !s.sizes.some(([w, h]) => w === c.width && h === c.height)) return false;
+        return true;
+      });
+      if (ok.length) {
+        const c = pick(ok);
+        out[s.id] = { ...c, type: c.type || (c.html ? "html" : "image") };
+      }
+    });
+    return out;
+  }
+};
+
+// src/lib.js
+var version = true ? "0.1.0" : "dev";
+function createUal() {
+  const registry = new Map(Object.entries({
+    json: json_default,
+    iframe: iframe_default,
+    revive: revive_default,
+    "revive-async": reviveAsync,
+    gpt: gpt_default,
+    adsense: adsense_default,
+    house: house_default
+  }));
+  const engine = createEngine(registry);
+  return { ...engine, version };
+}
+var shared = null;
+function getUal() {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    throw new Error("UAL: getUal() funziona solo nel browser. Chiamalo dopo il montaggio (es. dentro useEffect / onMounted).");
+  }
+  if (!shared) shared = createUal();
+  return shared;
+}
+function defineConfig(config) {
+  return config;
+}
+export {
+  createUal,
+  defineConfig,
+  getUal,
+  version
+};