nodebb-plugin-ezoic-infinite 1.4.90 → 1.4.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodebb-plugin-ezoic-infinite",
-  "version": "1.4.90",
+  "version": "1.4.91",
   "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
   "main": "library.js",
   "license": "MIT",

package/public/public/client.js

@@ -11,52 +11,33 @@
 
   const WRAP_CLASS = 'ezoic-ad';
   const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
-
-  const MAX_INSERTS_PER_RUN = 2;
+  const MAX_INSERTS_PER_RUN = 3;
 
   const state = {
     pageKey: null,
     cfg: null,
     cfgPromise: null,
-
     poolTopics: [],
     poolPosts: [],
     poolCategories: [],
-
     usedTopics: new Set(),
     usedPosts: new Set(),
     usedCategories: new Set(),
-
-    // wrappers currently on page (FIFO for recycling)
-    liveBetween: [],
-    liveMessage: [],
-    liveCategory: [],
-    usedCategories: new Set(),
-
     lastShowById: new Map(),
-    pendingById: new Set(),
-    retryById: new Map(),
-    retryTimer: null,
-    retryQueue: [],
-    retryQueueSet: new Set(),
-    retryQueueRunning: false,
-    badIds: new Set(),
-    definedIds: new Set(),
-
+    canShowAds: false,
     scheduled: false,
     timer: null,
-
     obs: null,
-    attempts: 0,
   };
 
+  const sessionDefinedIds = new Set();
+
   function normalizeBool(v) {
     return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
   }
 
   function uniqInts(lines) {
-    const out = [];
-    const seen = new Set();
+    const out = [], seen = new Set();
     for (const v of lines) {
       const n = parseInt(v, 10);
       if (Number.isFinite(n) && n > 0 && !seen.has(n)) {
@@ -89,10 +70,6 @@
     if (/^\/topic\//.test(p)) return 'topic';
     if (/^\/category\//.test(p)) return 'categoryTopics';
     if (p === '/' || /^\/categories/.test(p)) return 'categories';
-    // fallback by DOM
-    if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
-    if (document.querySelector(SELECTORS.postItem)) return 'topic';
-    if (document.querySelector(SELECTORS.topicItem)) return 'categoryTopics';
     return 'other';
   }
 
@@ -100,120 +77,67 @@
     return Array.from(document.querySelectorAll(SELECTORS.topicItem));
   }
 
+  function getPostContainers() {
+    return Array.from(document.querySelectorAll(SELECTORS.postItem));
+  }
+
   function getCategoryItems() {
     return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
   }
 
-  function getPostContainers() {
-    const nodes = Array.from(document.querySelectorAll(SELECTORS.postItem));
-    return nodes.filter((el) => {
-      if (!el || !el.isConnected) return false;
-      if (!el.querySelector('[component="post/content"]')) return false;
-      const parentPost = el.parentElement && el.parentElement.closest('[component="post"][data-pid]');
-      if (parentPost && parentPost !== el) return false;
-      if (el.getAttribute('component') === 'post/parent') return false;
-      return true;
-    });
-  }
+  async function fetchConfig() {
+    if (state.cfg) return state.cfg;
+    if (state.cfgPromise) return state.cfgPromise;
 
+    state.cfgPromise = (async () => {
+      try {
+        const res = await fetch('/api/ezoic-infinite/config');
+        if (!res.ok) return null;
+        const cfg = await res.json();
+        state.cfg = cfg;
+        return cfg;
+      } catch (e) {
+        return null;
+      }
+    })();
 
-  function safeRect(el) {
-    try { return el.getBoundingClientRect(); } catch (e) { return null; }
+    return state.cfgPromise;
+  }
+
+  function initPools(cfg) {
+    if (!state.poolTopics.length) state.poolTopics = parsePool(cfg.poolTopics);
+    if (!state.poolPosts.length) state.poolPosts = parsePool(cfg.poolPosts);
+    if (!state.poolCategories.length) state.poolCategories = parsePool(cfg.poolCategories);
   }
 
   function destroyPlaceholderIds(ids) {
     if (!ids || !ids.length) return;
-    // Only destroy ids that were actually "defined" (filled at least once) to avoid Ezoic warnings.
-    const filtered = ids.filter((id) => {
-      try { return state.definedIds && state.definedIds.has(id); } catch (e) { return true; }
-    });
+    const filtered = ids.filter(id => Number.isFinite(id) && id > 0);
     if (!filtered.length) return;
 
-    const call = () => {
-      try {
-        if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
-          window.ezstandalone.destroyPlaceholders(filtered);
-        }
-      } catch (e) {}
-    };
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') call();
-      else window.ezstandalone.cmd.push(call);
-    } catch (e) {}
-  }
-    };
     try {
       window.ezstandalone = window.ezstandalone || {};
       window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') call();
-      else window.ezstandalone.cmd.push(call);
-    } catch (e) {}
-  }
+      
+      const call = () => {
+        if (typeof window.ezstandalone.destroyPlaceholders === 'function') {
+          window.ezstandalone.destroyPlaceholders(filtered);
+        }
+      };
 
-  function getRecyclable(liveArr) {
-    const margin = 1800;
-    for (let i = 0; i < liveArr.length; i++) {
-      const entry = liveArr[i];
-      if (!entry || !entry.wrap || !entry.wrap.isConnected) { liveArr.splice(i, 1); i--; continue; }
-      const r = safeRect(entry.wrap);
-      if (r && r.bottom < -margin) {
-        liveArr.splice(i, 1);
-        return entry;
+      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
+        call();
+      } else {
+        window.ezstandalone.cmd.push(call);
       }
-    }
-    return null;
-  }
-
-  function moveWrapAfter(wrap, target, kindClass, afterPos) {
-    try {
-      wrap.className = `${WRAP_CLASS} ${kindClass}`;
-      wrap.setAttribute('data-ezoic-after', String(afterPos));
-      target.insertAdjacentElement('afterend', wrap);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
 
-  function pickId(pool, liveArr) {
-    if (pool.length) return { id: pool.shift(), recycled: null };
-    const recycled = getRecyclable(liveArr);
-    if (recycled) return { id: recycled.id, recycled };
-    return { id: null, recycled: null };
-  }
-
-
-  function resetPlaceholderInWrap(wrap, id) {
-    try {
-      if (!wrap) return;
-      try { wrap.removeAttribute('data-ezoic-filled'); } catch (e) {}
-      try { if (wrap.__ezoicFillObs) { wrap.__ezoicFillObs.disconnect(); wrap.__ezoicFillObs = null; } } catch (e) {}
-      const old = wrap.querySelector && wrap.querySelector(`#${PLACEHOLDER_PREFIX}${id}`);
-      if (old) old.remove();
-      // Remove any leftover markup inside wrapper
-      wrap.querySelectorAll && wrap.querySelectorAll('iframe, ins').forEach(n => n.remove());
-      const ph = document.createElement('div');
-      ph.id = `${PLACEHOLDER_PREFIX}${id}`;
-      wrap.appendChild(ph);
+      // Recyclage: libérer après 100ms
+      setTimeout(() => {
+        filtered.forEach(id => sessionDefinedIds.delete(id));
+      }, 100);
     } catch (e) {}
   }
 
-  function isAdjacentAd(target) {
-    if (!target || !target.nextElementSibling) return false;
-    const next = target.nextElementSibling;
-    if (next && next.classList && next.classList.contains(WRAP_CLASS)) return true;
-    return false;
-  }
-
-  function isPrevAd(target) {
-    if (!target || !target.previousElementSibling) return false;
-    const prev = target.previousElementSibling;
-    if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) return true;
-    return false;
-  }
-
   function buildWrap(id, kindClass, afterPos) {
     const wrap = document.createElement('div');
     wrap.className = `${WRAP_CLASS} ${kindClass}`;
@@ -233,404 +157,150 @@
   function insertAfter(target, id, kindClass, afterPos) {
     if (!target || !target.insertAdjacentElement) return null;
     if (findWrap(kindClass, afterPos)) return null;
-    const wrap = buildWrap(id, kindClass, afterPos);
-    target.insertAdjacentElement('afterend', wrap);
-    attachFillObserver(wrap, id);
-    return wrap;
-  }
-
-  function destroyUsedPlaceholders() {
-    const ids = [];
-    try {
-      state.usedTopics.forEach((id) => ids.push(id));
-      state.usedPosts.forEach((id) => ids.push(id));
-      state.usedCategories && state.usedCategories.forEach((id) => ids.push(id));
-    } catch (e) {}
-    destroyPlaceholderIds(ids);
-  }
-      } catch (e) {}
-    };
-
-    try {
-      window.ezstandalone = window.ezstandalone || {};
-      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') call();
-      else window.ezstandalone.cmd.push(call);
-    } catch (e) {}
-  }
 
-  function patchShowAds() {
-    // Minimal safety net: batch showAds can be triggered by other scripts; split into individual calls.
     try {
-      window.ezstandalone = window.ezstandalone || {};
-      const ez = window.ezstandalone;
-      if (ez.__nodebbEzoicPatched) return;
-      if (typeof ez.showAds !== 'function') return;
-
-      ez.__nodebbEzoicPatched = true;
-      const orig = ez.showAds;
-
-      ez.showAds = function (arg) {
-        if (Array.isArray(arg)) {
-          const seen = new Set();
-          for (const v of arg) {
-            const id = parseInt(v, 10);
-            if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
-            seen.add(id);
-            try { orig.call(ez, id); } catch (e) {}
-          }
-          return;
-        }
-        return orig.apply(ez, arguments);
-      };
-    } catch (e) {}
-  }
-
-
-
-  function markFilled(wrap) {
-    try {
-      if (!wrap) return;
-      try { wrap.removeAttribute('data-ezoic-filled'); } catch (e) {}
-      try { if (wrap.__ezoicFillObs) { wrap.__ezoicFillObs.disconnect(); wrap.__ezoicFillObs = null; } } catch (e) {}
-      wrap.setAttribute('data-ezoic-filled', '1');
-    } catch (e) {}
-  }
-
-  function isWrapMarkedFilled(wrap) {
-    try { return wrap && wrap.getAttribute && wrap.getAttribute('data-ezoic-filled') === '1'; } catch (e) { return false; }
-  }
-
-  function attachFillObserver(wrap, id) {
-    try {
-      const ph = wrap && wrap.querySelector && wrap.querySelector(`#${PLACEHOLDER_PREFIX}${id}`);
-      if (!ph) return;
-      // Already filled?
-      if (ph.childNodes && ph.childNodes.length > 0) {
-        markFilled(wrap);
-        state.definedIds && state.definedIds.add(id);
-        return;
-      }
-      const obs = new MutationObserver(() => {
-        if (ph.childNodes && ph.childNodes.length > 0) {
-          markFilled(wrap);
-          try { state.definedIds && state.definedIds.add(id); } catch (e) {}
-          try { obs.disconnect(); } catch (e) {}
-        }
-      });
-      obs.observe(ph, { childList: true, subtree: true });
-      // Keep a weak reference on the wrapper so we can disconnect on recycle/remove
-      wrap.__ezoicFillObs = obs;
-    } catch (e) {}
-  }
-
-  function isPlaceholderFilled(id) {
-    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-    if (!ph || !ph.isConnected) return false;
-
-    const wrap = ph.parentElement;
-    if (wrap && isWrapMarkedFilled(wrap)) return true;
-
-    const filled = !!(ph.childNodes && ph.childNodes.length > 0);
-    if (filled) {
-      try { state.definedIds && state.definedIds.add(id); } catch (e) {}
-      try { markFilled(wrap); } catch (e) {}
+      const wrap = buildWrap(id, kindClass, afterPos);
+      target.insertAdjacentElement('afterend', wrap);
+      return wrap;
+    } catch (e) {
+      return null;
     }
-    return filled;
-  }
-    return filled;
   }
 
-  function scheduleRefill(delay = 350) {
-    clearTimeout(state.retryTimer);
-    state.retryTimer = setTimeout(refillUnfilled, delay);
+  function pickId(pool) {
+    if (!pool || !pool.length) return null;
+    return pool.shift();
   }
 
-  function enqueueRetry(id) {
+  function callShowAds(id) {
     if (!id) return;
-    if (state.badIds && state.badIds.has(id)) return;
-    if (state.retryQueueSet.has(id)) return;
-    state.retryQueueSet.add(id);
-    state.retryQueue.push(id);
-    processRetryQueue();
-  }
-
-  function processRetryQueue() {
-    if (state.retryQueueRunning) return;
-    state.retryQueueRunning = true;
-
-    const step = () => {
-      const id = state.retryQueue.shift();
-      if (!id) {
-        state.retryQueueRunning = false;
-    state.badIds = new Set();
-    state.definedIds = new Set();
-        return;
-      }
-      state.retryQueueSet.delete(id);
-      // If this id was previously attempted and still empty, force a full reset before re-requesting.
-      const attempts = (state.retryById.get(id) || 0);
-      const phNow = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
-      const wrapNow = phNow && phNow.parentElement;
-      // If Ezoic already defined this id earlier but the placeholder is empty now, we must destroy+reset before re-showAds.
-      if (wrapNow && wrapNow.isConnected && state.definedIds && state.definedIds.has(id) && !isPlaceholderFilled(id) && !isWrapMarkedFilled(wrapNow)) {
-        destroyPlaceholderIds([id]);
-        resetPlaceholderInWrap(wrapNow, id);
-      }
-      // If this id was previously attempted and still empty, force a full reset before re-requesting.
-      if (attempts > 0 && wrapNow && wrapNow.isConnected && !isPlaceholderFilled(id) && !isWrapMarkedFilled(wrapNow)) {
-        destroyPlaceholderIds([id]);
-        resetPlaceholderInWrap(wrapNow, id);
-      }
-      callShowAdsWhenReady(id);
-      setTimeout(step, 1100);
-    };
-
-    step();
-  }
-
-
-  function refillUnfilled() {
-    const wraps = Array.from(document.querySelectorAll(`.${WRAP_CLASS}`));
-    let scheduledAny = false;
-
-    for (const wrap of wraps) {
-      const ph = wrap.querySelector && wrap.querySelector(`[id^="${PLACEHOLDER_PREFIX}"]`);
-      if (!ph) continue;
-      const id = parseInt(ph.id.replace(PLACEHOLDER_PREFIX, ''), 10);
-      if (!Number.isFinite(id) || id <= 0) continue;
-
-      if (isPlaceholderFilled(id)) {
-        state.retryById.delete(id);
-        continue;
-      }
-      // If wrapper was marked filled, don't try to refill even if placeholder temporarily appears empty.
-      if (isWrapMarkedFilled(wrap)) {
-        state.retryById.delete(id);
-        continue;
-      }
-
-      const tries = (state.retryById.get(id) || 0);
-      if (tries >= 8) { state.badIds && state.badIds.add(id); continue; }
-
-      const r = safeRect(wrap);
-      if (r && (r.top > window.innerHeight + 1200 || r.bottom < -1200)) continue;
-
-      state.retryById.set(id, tries + 1);
-      enqueueRetry(id);
-      scheduledAny = true;
-    }
-
-    if (scheduledAny) scheduleRefill(700);
-  }
-
-  function callShowAdsWhenReady(id) {
-    if (!id) return;
-
-    const now = Date.now();
-    const last = state.lastShowById.get(id) || 0;
-    if (now - last < 3500) return;
-
-    const phId = `${PLACEHOLDER_PREFIX}${id}`;
-
-    const doCall = () => {
-      try {
-        window.ezstandalone = window.ezstandalone || {};
+    
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+      
+      window.ezstandalone.cmd.push(function() {
         if (typeof window.ezstandalone.showAds === 'function') {
-          state.lastShowById.set(id, Date.now());
           window.ezstandalone.showAds(id);
-          return true;
+          sessionDefinedIds.add(id);
         }
-      } catch (e) {}
-      return false;
-    };
-
-    let attempts = 0;
-    (function waitForPh() {
-      attempts += 1;
-      const el = document.getElementById(phId);
-      if (el && el.isConnected) {
-        if (doCall()) return;
-
-        if (state.pendingById.has(id)) return;
-        state.pendingById.add(id);
-
-        window.ezstandalone = window.ezstandalone || {};
-        window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-        window.ezstandalone.cmd.push(() => {
-          try {
-            if (typeof window.ezstandalone.showAds === 'function') {
-              state.pendingById.delete(id);
-              state.lastShowById.set(id, Date.now());
-              window.ezstandalone.showAds(id);
-            }
-          } catch (e) {}
-        });
-
-        let tries = 0;
-        (function tick() {
-          tries += 1;
-          if (doCall() || tries >= 5) {
-            if (tries >= 5) state.pendingById.delete(id);
-            return;
-          }
-          setTimeout(tick, 700);
-        })();
-        return;
-      }
-
-      if (attempts < 50) setTimeout(waitForPh, 50);
-    })();
+      });
+    } catch (e) {}
   }
 
-  function nextId(pool) {
-    // backward compatible: the injector passes the pool array
-    if (Array.isArray(pool) && pool.length) return pool.shift();
-    return null;
-  }
+  function injectBetween(kindClass, items, interval, showFirst, pool, usedSet) {
+    if (!items || items.length === 0) return 0;
 
-  async function fetchConfig() {
-    if (state.cfg) return state.cfg;
-    if (state.cfgPromise) return state.cfgPromise;
-
-    state.cfgPromise = (async () => {
-      try {
-        const res = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
-        if (!res.ok) return null;
-        state.cfg = await res.json();
-        return state.cfg;
-      } catch (e) {
-        return null;
-      } finally {
-        state.cfgPromise = null;
-      }
-    })();
-
-    return state.cfgPromise;
-  }
-
-  function initPools(cfg) {
-    if (state.poolTopics.length === 0) state.poolTopics = parsePool(cfg.placeholderIds);
-    if (state.poolPosts.length === 0) state.poolPosts = parsePool(cfg.messagePlaceholderIds);
-    if (state.poolCategories.length === 0) state.poolCategories = parsePool(cfg.categoryPlaceholderIds);
-  }
+    let inserted = 0;
+    const targets = [];
 
-  function computeTargets(count, interval, showFirst) {
-    const out = [];
-    if (count <= 0) return out;
-    if (showFirst) out.push(1);
-    for (let i = 1; i <= count; i++) {
-      if (i % interval === 0) out.push(i);
+    for (let i = 0; i < items.length; i++) {
+      const afterPos = i + 1;
+      if (afterPos === 1 && !showFirst) continue;
+      if (afterPos % interval !== (showFirst ? 1 : 0)) continue;
+      targets.push(afterPos);
     }
-    return Array.from(new Set(out)).sort((a, b) => a - b);
-  }
 
-  function injectBetween(kindClass, items, interval, showFirst, kindPool, usedSet) {
-    if (!items.length) return 0;
-    const targets = computeTargets(items.length, interval, showFirst);
-
-    let inserted = 0;
     for (const afterPos of targets) {
       if (inserted >= MAX_INSERTS_PER_RUN) break;
 
       const el = items[afterPos - 1];
       if (!el || !el.isConnected) continue;
-
-      // Prevent adjacent ads (DOM-based, robust against virtualization)
-      if (isAdjacentAd(el) || isPrevAd(el)) {
-        continue;
-      }
-
-      // Prevent back-to-back at load
-      const prevWrap = findWrap(kindClass, afterPos - 1);
-      if (prevWrap) continue;
-
       if (findWrap(kindClass, afterPos)) continue;
 
-      const liveArr = (kindClass === 'ezoic-ad-between') ? state.liveBetween
-        : (kindClass === 'ezoic-ad-message') ? state.liveMessage
-        : state.liveCategory;
-
-      const pick = pickId(kindPool, liveArr);
-      const id = pick.id;
+      const id = pickId(pool);
       if (!id) break;
 
-      let wrap = null;
-      if (pick.recycled && pick.recycled.wrap) {
-        // Only destroy if Ezoic has actually defined this placeholder before
-        if (state.definedIds && state.definedIds.has(id)) {
-          destroyPlaceholderIds([id]);
-        }
-        // Remove the old wrapper entirely, then create a fresh wrapper at the new position (same id)
-        const oldWrap = pick.recycled.wrap;
-        try { if (oldWrap && oldWrap.__ezoicFillObs) { oldWrap.__ezoicFillObs.disconnect(); } } catch (e) {}
-        try { oldWrap && oldWrap.remove(); } catch (e) {}
-        wrap = insertAfter(el, id, kindClass, afterPos);
-        if (!wrap) continue;
-        setTimeout(() => { enqueueRetry(id); }, 450);
-      } else {
-        usedSet.add(id);
-        wrap = insertAfter(el, id, kindClass, afterPos);
-        if (!wrap) continue;
-      }
+      const wrap = insertAfter(el, id, kindClass, afterPos);
+      if (!wrap) continue;
 
-      liveArr.push({ id, wrap });
-      // If adjacency ended up happening (e.g. DOM shifts), rollback this placement.
-      if (wrap && (wrap.previousElementSibling && wrap.previousElementSibling.classList && wrap.previousElementSibling.classList.contains(WRAP_CLASS)) || (wrap.nextElementSibling && wrap.nextElementSibling.classList && wrap.nextElementSibling.classList.contains(WRAP_CLASS))) {
-        try { wrap.remove(); } catch (e) {}
-        // Put id back if it was newly consumed (not recycled)
-        if (!(pick.recycled && pick.recycled.wrap)) {
-          try { kindPool.unshift(id); } catch (e) {}
-          try { usedSet.delete(id); } catch (e) {}
-        }
-        inserted -= 0; // no-op
-        continue;
-      }
-      if (!(pick.recycled && pick.recycled.wrap)) {
-        callShowAdsWhenReady(id);
-      }
+      usedSet.add(id);
+      callShowAds(id);
       inserted += 1;
     }
+
     return inserted;
   }
 
-  function enforceNoAdjacentAds() {
-    const ads = Array.from(document.querySelectorAll(`.${WRAP_CLASS}`));
-    for (let i = 0; i < ads.length; i++) {
-      const ad = ads[i];
-      const prev = ad.previousElementSibling;
-      if (prev && prev.classList && prev.classList.contains(WRAP_CLASS)) ad.style.display = 'none';
-      else ad.style.display = '';
+  async function runCore() {
+    if (!state.canShowAds) return;
+
+    const cfg = await fetchConfig();
+    if (!cfg || cfg.excluded) return;
+
+    initPools(cfg);
+
+    const kind = getKind();
+    let inserted = 0;
+
+    if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
+      inserted = injectBetween(
+        'ezoic-ad-message',
+        getPostContainers(),
+        Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
+        normalizeBool(cfg.showFirstMessageAd),
+        state.poolPosts,
+        state.usedPosts
+      );
+    } else if (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
+      inserted = injectBetween(
+        'ezoic-ad-between',
+        getTopicItems(),
+        Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
+        normalizeBool(cfg.showFirstTopicAd),
+        state.poolTopics,
+        state.usedTopics
+      );
+    } else if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
+      inserted = injectBetween(
+        'ezoic-ad-category',
+        getCategoryItems(),
+        Math.max(1, parseInt(cfg.intervalCategories, 10) || 6),
+        normalizeBool(cfg.showFirstCategoryAd),
+        state.poolCategories,
+        state.usedCategories
+      );
     }
   }
 
+  function scheduleRun() {
+    if (state.scheduled) return;
+    state.scheduled = true;
+
+    clearTimeout(state.timer);
+    state.timer = setTimeout(() => {
+      state.scheduled = false;
+      const pk = getPageKey();
+      if (state.pageKey && pk !== state.pageKey) return;
+      runCore().catch(() => {});
+    }, 50);
+  }
+
   function cleanup() {
-    destroyUsedPlaceholders();
+    const allIds = [...state.usedTopics, ...state.usedPosts, ...state.usedCategories];
+    if (allIds.length) destroyPlaceholderIds(allIds);
+
+    document.querySelectorAll('.ezoic-ad').forEach(el => {
+      try { el.remove(); } catch (e) {}
+    });
 
     state.pageKey = getPageKey();
     state.cfg = null;
     state.cfgPromise = null;
-
     state.poolTopics = [];
     state.poolPosts = [];
     state.poolCategories = [];
-    state.poolCategories = [];
     state.usedTopics.clear();
     state.usedPosts.clear();
-    state.usedCategories && state.usedCategories.clear();
-    state.liveBetween = [];
-    state.liveMessage = [];
-    state.liveCategory = [];
     state.usedCategories.clear();
+    state.lastShowById.clear();
+    sessionDefinedIds.clear();
 
-    state.lastShowById = new Map();
-    state.pendingById = new Set();
-
-    state.attempts = 0;
-
-    document.querySelectorAll(`.${WRAP_CLASS}`).forEach(el => el.remove());
+    if (state.obs) {
+      state.obs.disconnect();
+      state.obs = null;
+    }
 
-    if (state.obs) { try { state.obs.disconnect(); } catch (e) {} state.obs = null; }
     state.scheduled = false;
     clearTimeout(state.timer);
     state.timer = null;
@@ -638,139 +308,64 @@
 
   function ensureObserver() {
     if (state.obs) return;
-    state.obs = new MutationObserver(() => scheduleRun('mutation'));
-    try { state.obs.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
-    setTimeout(() => { if (state.obs) { try { state.obs.disconnect(); } catch (e) {} state.obs = null; } }, 15000);
+    state.obs = new MutationObserver(() => scheduleRun());
+    try {
+      state.obs.observe(document.body, { childList: true, subtree: true });
+    } catch (e) {}
   }
 
-  async function runCore() {
-    patchShowAds();
-
-    const cfg = await fetchConfig();
-    if (!cfg || cfg.excluded) return;
-
-    initPools(cfg);
-
+  function waitForContentThenRun() {
     const kind = getKind();
-    let inserted = 0;
+    let selector = SELECTORS.postItem;
+    if (kind === 'categoryTopics') selector = SELECTORS.topicItem;
+    else if (kind === 'categories') selector = SELECTORS.categoryItem;
 
-    if (kind === 'topic') {
-      if (normalizeBool(cfg.enableMessageAds)) {
-        inserted = injectBetween('ezoic-ad-message', getPostContainers(),
-          Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
-          normalizeBool(cfg.showFirstMessageAd),
-          'message',
-          state.usedPosts);
-      }
-    } else if (kind === 'categoryTopics') {
-      if (normalizeBool(cfg.enableBetweenAds)) {
-        inserted = injectBetween('ezoic-ad-between', getTopicItems(),
-          Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
-          normalizeBool(cfg.showFirstTopicAd),
-          'between',
-          state.usedTopics);
-      }
-    } else if (kind === 'categories') {
-      if (normalizeBool(cfg.enableCategoryAds)) {
-        inserted = injectBetween('ezoic-ad-categories', getCategoryItems(),
-          Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
-          normalizeBool(cfg.showFirstCategoryAd),
-          'categories',
-          state.usedCategories);
+    const check = () => {
+      if (document.querySelector(selector)) {
+        scheduleRun();
+      } else {
+        setTimeout(check, 200);
       }
-    }
-
-    enforceNoAdjacentAds();
-    scheduleRefill(250);
-
-    // If nothing inserted and list isn't in DOM yet (first click), retry a bit
-    let count = 0;
-    if (kind === 'topic') count = getPostContainers().length;
-    else if (kind === 'categoryTopics') count = getTopicItems().length;
-    else if (kind === 'categories') count = getCategoryItems().length;
-
-    if (count === 0 && state.attempts < 25) {
-      state.attempts += 1;
-      setTimeout(() => scheduleRun('await-items'), 120);
-      return;
-    }
-
-    if (inserted >= MAX_INSERTS_PER_RUN) setTimeout(() => scheduleRun('continue'), 140);
-  }
-
-  function scheduleRun() {
-    if (state.scheduled) return;
-    state.scheduled = true;
-
-    clearTimeout(state.timer);
-    state.timer = setTimeout(() => {
-      state.scheduled = false;
-      const pk = getPageKey();
-      if (state.pageKey && pk !== state.pageKey) return;
-      runCore().catch(() => {});
-    }, 80);
+    };
+    check();
   }
 
   function bind() {
     if (!$) return;
 
     $(window).off('.ezoicInfinite');
-
     $(window).on('action:ajaxify.start.ezoicInfinite', () => cleanup());
-
     $(window).on('action:ajaxify.end.ezoicInfinite', () => {
       state.pageKey = getPageKey();
       ensureObserver();
+      state.canShowAds = true;
       scheduleRun();
-      setTimeout(scheduleRun, 200);
-      setTimeout(scheduleRun, 700);
     });
 
     $(window).on('action:category.loaded.ezoicInfinite', () => {
       ensureObserver();
-      scheduleRun();
-      setTimeout(scheduleRun, 250);
+      waitForContentThenRun();
     });
 
     $(window).on('action:topics.loaded.ezoicInfinite', () => {
       ensureObserver();
-      scheduleRun();
-      setTimeout(scheduleRun, 150);
-    });
-
-    $(window).on('action:topic.loaded.ezoicInfinite', () => {
-      ensureObserver();
-      scheduleRun();
-      setTimeout(scheduleRun, 200);
-    });
-
-    $(window).on('action:posts.loaded.ezoicInfinite', () => {
-      ensureObserver();
-      scheduleRun();
-      setTimeout(scheduleRun, 150);
+      waitForContentThenRun();
     });
   }
 
-  cleanup();
-  bind();
-  ensureObserver();
-  state.pageKey = getPageKey();
-  scheduleRun();
-  setTimeout(scheduleRun, 250);
-})()
-  function bindScroll() {
-    if (state.__scrollBound) return;
-    state.__scrollBound = true;
-    let ticking = false;
-    window.addEventListener('scroll', () => {
-      if (ticking) return;
-      ticking = true;
-      window.requestAnimationFrame(() => {
-        ticking = false;
-        enforceNoAdjacentAds();
-        scheduleRefill(200);
-      });
-    }, { passive: true });
+  function init() {
+    state.pageKey = getPageKey();
+    state.canShowAds = true;
+    bind();
+    ensureObserver();
+    waitForContentThenRun();
   }
 
-;
+  if ($ && $(document).ready) {
+    $(document).ready(init);
+  } else if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init);
+  } else {
+    init();
+  }
+})();

package/public/public/style.css

@@ -1,13 +1,11 @@
 .ezoic-ad {
   padding: 0 !important;
   margin: 0 !important;
+  min-height: 0 !important;
+  min-width: 0 !important;
 }
 
-/* CRITIQUE: Forcer min-height et min-width à 0 */
-.ezoic-ad,
-.ezoic-ad *,
-span.ezoic-ad,
-span[class*="ezoic"] {
+.ezoic-ad * {
   min-height: 0 !important;
   min-width: 0 !important;
 }