nodebb-plugin-ezoic-infinite 1.6.97 → 1.6.99

package/library.js

@@ -7,60 +7,124 @@ const db = require.main.require('./src/database');
 const SETTINGS_KEY = 'ezoic-infinite';
 const plugin = {};
 
-async function getSettings() {
-    return await meta.settings.get(SETTINGS_KEY);
+function normalizeExcludedGroups(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return String(value).split(',').map(s => s.trim()).filter(Boolean);
 }
 
-async function isUserExcluded(uid, excludedGroups) {
-    if (!uid || uid <= 0) return false;
-    if (!excludedGroups || !excludedGroups.length) return false;
-    const userGroups = await groups.getUserGroupsNames([uid]);
-    return excludedGroups.some(g => userGroups[0].includes(g));
+function parseBool(v, def = false) {
+  if (v === undefined || v === null || v === '') return def;
+  if (typeof v === 'boolean') return v;
+  const s = String(v).toLowerCase();
+  return s === '1' || s === 'true' || s === 'on' || s === 'yes';
 }
 
 async function getAllGroups() {
-    let names = await db.getSortedSetRange('groups:createtime', 0, -1);
-    const data = await groups.getGroupsData(names);
-    return data.filter(g => g && g.name).map(g => ({ name: g.name }));
+  let names = await db.getSortedSetRange('groups:createtime', 0, -1);
+  if (!names || !names.length) {
+    names = await db.getSortedSetRange('groups:visible:createtime', 0, -1);
+  }
+  const filtered = names.filter(name => !groups.isPrivilegeGroup(name));
+  const data = await groups.getGroupsData(filtered);
+  // Filter out nulls (groups deleted between the sorted-set read and getGroupsData)
+  const valid = data.filter(g => g && g.name);
+  valid.sort((a, b) => String(a.name).localeCompare(String(b.name), undefined, { sensitivity: 'base' }));
+  return valid;
 }
+let _settingsCache = null;
+let _settingsCacheAt = 0;
+const SETTINGS_TTL = 30000; // 30s
 
-plugin.init = async ({ router, middleware }) => {
-    async function render(req, res) {
-        const settings = await getSettings();
-        const allGroups = await getAllGroups();
-        res.render('admin/plugins/ezoic-infinite', {
-            ...settings,
-            allGroups,
-        });
-    }
-
-    router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, render);
-    router.get('/api/admin/plugins/ezoic-infinite', render);
-
-    router.get('/api/plugins/ezoic-infinite/config', async (req, res) => {
-        const settings = await getSettings();
-        const excluded = await isUserExcluded(req.uid, settings.excludedGroups || []);
-        res.json({
-            excluded,
-            enableCategoryAds: settings.enableCategoryAds === 'on',
-            showFirstCategoryAd: settings.showFirstCategoryAd === 'on',
-            categoryPlaceholderIds: settings.categoryPlaceholderIds,
-            intervalCategories: parseInt(settings.intervalCategories, 10) || 5,
-            enableBetweenAds: settings.enableBetweenAds === 'on',
-            showFirstTopicAd: settings.showFirstTopicAd === 'on',
-            placeholderIds: settings.placeholderIds,
-            intervalPosts: parseInt(settings.intervalPosts, 10) || 10,
-            enableMessageAds: settings.enableMessageAds === 'on',
-            showFirstMessageAd: settings.showFirstMessageAd === 'on',
-            messagePlaceholderIds: settings.messagePlaceholderIds,
-            messageIntervalPosts: parseInt(settings.messageIntervalPosts, 10) || 10,
-        });
-    });
+async function getSettings() {
+  const now = Date.now();
+  if (_settingsCache && (now - _settingsCacheAt) < SETTINGS_TTL) return _settingsCache;
+  const s = await meta.settings.get(SETTINGS_KEY);
+  _settingsCacheAt = Date.now();
+  _settingsCache = {
+    // Between-post ads (simple blocks) in category topic list
+    enableBetweenAds: parseBool(s.enableBetweenAds, true),
+    showFirstTopicAd: parseBool(s.showFirstTopicAd, false),
+    placeholderIds: (s.placeholderIds || '').trim(),
+    intervalPosts: Math.max(1, parseInt(s.intervalPosts, 10) || 6),
+
+    // Home/categories list ads (between categories on / or /categories)
+    enableCategoryAds: parseBool(s.enableCategoryAds, false),
+    showFirstCategoryAd: parseBool(s.showFirstCategoryAd, false),
+    categoryPlaceholderIds: (s.categoryPlaceholderIds || '').trim(),
+    intervalCategories: Math.max(1, parseInt(s.intervalCategories, 10) || 4),
+
+    // "Ad message" between replies (looks like a post)
+    enableMessageAds: parseBool(s.enableMessageAds, false),
+    showFirstMessageAd: parseBool(s.showFirstMessageAd, false),
+    messagePlaceholderIds: (s.messagePlaceholderIds || '').trim(),
+    messageIntervalPosts: Math.max(1, parseInt(s.messageIntervalPosts, 10) || 3),
+
+    excludedGroups: normalizeExcludedGroups(s.excludedGroups),
+  };
+  return _settingsCache;
+}
+
+async function isUserExcluded(uid, excludedGroups) {
+  if (!uid || !excludedGroups.length) return false;
+  const userGroups = await groups.getUserGroups([uid]);
+  return (userGroups[0] || []).some(g => excludedGroups.includes(g.name));
+}
+
+plugin.onSettingsSet = function (data) {
+  // Invalider le cache dès que les settings de ce plugin sont sauvegardés via l'ACP
+  if (data && data.hash === SETTINGS_KEY) {
+    _settingsCache = null;
+  }
 };
 
 plugin.addAdminNavigation = async (header) => {
-    header.plugins.push({ route: '/plugins/ezoic-infinite', icon: 'fa-ad', name: 'Ezoic Infinite' });
-    return header;
+  header.plugins = header.plugins || [];
+  header.plugins.push({
+    route: '/plugins/ezoic-infinite',
+    icon: 'fa-ad',
+    name: 'Ezoic Infinite Ads'
+  });
+  return header;
+};
+
+plugin.init = async ({ router, middleware }) => {
+  async function render(req, res) {
+    const settings = await getSettings();
+    const allGroups = await getAllGroups();
+
+    res.render('admin/plugins/ezoic-infinite', {
+      title: 'Ezoic Infinite Ads',
+      ...settings,
+      enableBetweenAds_checked: settings.enableBetweenAds ? 'checked' : '',
+      enableMessageAds_checked: settings.enableMessageAds ? 'checked' : '',
+      allGroups,
+    });
+  }
+
+  router.get('/admin/plugins/ezoic-infinite', middleware.admin.buildHeader, render);
+  router.get('/api/admin/plugins/ezoic-infinite', render);
+
+  router.get('/api/plugins/ezoic-infinite/config', async (req, res) => {
+    const settings = await getSettings();
+    const excluded = await isUserExcluded(req.uid, settings.excludedGroups);
+
+    res.json({
+      excluded,
+      enableBetweenAds: settings.enableBetweenAds,
+      showFirstTopicAd: settings.showFirstTopicAd,
+      placeholderIds: settings.placeholderIds,
+      intervalPosts: settings.intervalPosts,
+      enableCategoryAds: settings.enableCategoryAds,
+      showFirstCategoryAd: settings.showFirstCategoryAd,
+      categoryPlaceholderIds: settings.categoryPlaceholderIds,
+      intervalCategories: settings.intervalCategories,
+      enableMessageAds: settings.enableMessageAds,
+      showFirstMessageAd: settings.showFirstMessageAd,
+      messagePlaceholderIds: settings.messagePlaceholderIds,
+      messageIntervalPosts: settings.messageIntervalPosts,
+    });
+  });
 };
 
-module.exports = plugin;
+module.exports = plugin;

package/package.json

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

package/public/client.js

@@ -1,135 +1,823 @@
+/**
+ * NodeBB Ezoic Infinite Ads — client.js (v18)
+ *
+ * Corrections majeures vs v17 :
+ *  1. ANCRAGE PAR pid/tid (data-pid, data-index) au lieu d'ordinalMap fragile.
+ *     → Le même post garde toujours le même ID de wrap, quelle que soit la virtualisation.
+ *  2. CLEANUP COMPLET à chaque navigation ajaxify (wraps + curseurs + état pools).
+ *     → Supprime les fantômes qui se réaffichaient après scroll up/down.
+ *  3. DEDUPLICATION par ancrage : on vérifie `data-ezoic-anchor` avant d'insérer.
+ *     → Empêche la création de doublons lors de multiples passes DOM.
+ *  4. PAS de recyclage de wraps (moveWrapAfter supprimé).
+ *     → La cause n°1 des pubs "qui sautent n'importe où".
+ *  5. pruneOrphanWraps simplifié : suppression réelle (remove) au lieu de hide.
+ *     → Un wrap orphelin = mort, pas caché. Libère l'id dans le curseur.
+ *  6. Déduplication de l'id Ezoic par wrap : un id ne peut être monté qu'une fois.
+ *  7. V17 pile-fix SUPPRIMÉ (was conflicting with main logic).
+ *  8. Factorisation : helpers partagés, pas de duplication de logique entre kinds.
+ */
 (function () {
   'use strict';
 
-  if (window.ezInfiniteInjected) return;
-  window.ezInfiniteInjected = true;
-
-  const WRAP_CLASS = 'nodebb-ezoic-wrap';
-  const POOL_ID = 'nodebb-ezoic-placeholder-pool';
-  let config = null;
-  let isInternalChange = false;
-  let activeIds = new Set();
-
-  function getPool() {
-    let p = document.getElementById(POOL_ID);
-    if (!p) {
-      p = document.createElement('div');
-      p.id = POOL_ID;
-      p.style.display = 'none';
-      document.body.appendChild(p);
+  // ─── Constants ────────────────────────────────────────────────────────────
+  const WRAP_CLASS          = 'nodebb-ezoic-wrap';
+  const PLACEHOLDER_PREFIX  = 'ezoic-pub-ad-placeholder-';
+  const ANCHOR_ATTR         = 'data-ezoic-anchor'; // unique key = kind:anchorId
+  const WRAPID_ATTR         = 'data-ezoic-wrapid';
+  const CREATED_ATTR        = 'data-ezoic-created';
+
+  const MAX_INSERTS_PER_RUN = 6;
+  const EMPTY_WRAP_TTL_MS   = 90_000; // 90 s avant de colapser un wrap vide
+  const FILL_WATCH_MS       = 7_000;
+
+  const PRELOAD_MARGIN = {
+    desktop:       '2000px 0px 2000px 0px',
+    mobile:        '3000px 0px 3000px 0px',
+    desktopBoosted:'4500px 0px 4500px 0px',
+    mobileBoosted: '4500px 0px 4500px 0px',
+  };
+  const BOOST_DURATION_MS      = 2500;
+  const BOOST_SPEED_PX_PER_MS  = 2.2;
+  const MAX_INFLIGHT_DESKTOP   = 4;
+  const MAX_INFLIGHT_MOBILE    = 3;
+  const SHOW_THROTTLE_MS       = 900;
+
+  const SELECTORS = {
+    topicItem:    'li[component="category/topic"]',
+    postItem:     '[component="post"][data-pid]',
+    categoryItem: 'li[component="categories/category"]',
+  };
+
+  // ─── Helpers ──────────────────────────────────────────────────────────────
+  const now = () => Date.now();
+  const isMobile = () => { try { return window.innerWidth < 768; } catch (_) { return false; } };
+  const normBool = (v) => v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
+
+  function uniqInts(raw) {
+    const out = [], seen = new Set();
+    for (const v of String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean)) {
+      const n = parseInt(v, 10);
+      if (Number.isFinite(n) && n > 0 && !seen.has(n)) { seen.add(n); out.push(n); }
+    }
+    return out;
+  }
+
+  function isFilledNode(node) {
+    return !!(node?.querySelector?.('iframe, ins, img, video, [data-google-container-id]'));
+  }
+
+  // ─── State ────────────────────────────────────────────────────────────────
+  const state = {
+    pageKey: null,
+    cfg: null,
+
+    // ID pools + curseurs rotatifs
+    pools: { topics: [], posts: [], categories: [] },
+    cursors: { topics: 0, posts: 0, categories: 0 },
+
+    // Suivi des IDs Ezoic actuellement montés dans le DOM (évite les doublons)
+    mountedIds: new Set(),
+
+    // Throttle par id
+    lastShowById: new Map(),
+
+    // Observers
+    domObs: null,
+    io: null,
+    ioMargin: null,
+
+    // Guard contre nos propres mutations
+    internalMutation: 0,
+
+    // File de show
+    inflight: 0,
+    pending: [],
+    pendingSet: new Set(),
+
+    // Scroll boost
+    scrollBoostUntil: 0,
+    lastScrollY: 0,
+    lastScrollTs: 0,
+
+    // Scheduler
+    runQueued: false,
+    burstActive: false,
+    burstDeadline: 0,
+    burstCount: 0,
+    lastBurstReqTs: 0,
+  };
+
+  let blockedUntil = 0;
+  const isBlocked = () => now() < blockedUntil;
+  const isBoosted = () => now() < state.scrollBoostUntil;
+
+  function withInternalMutation(fn) {
+    state.internalMutation++;
+    try { fn(); } finally { state.internalMutation--; }
+  }
+
+  // ─── Config ───────────────────────────────────────────────────────────────
+  async function fetchConfig() {
+    if (state.cfg) return state.cfg;
+    try {
+      const res = await fetch('/api/plugins/ezoic-infinite/config', { credentials: 'same-origin' });
+      if (!res.ok) return null;
+      state.cfg = await res.json();
+    } catch (_) { state.cfg = null; }
+    return state.cfg;
+  }
+
+  function initPools(cfg) {
+    if (!cfg) return;
+    state.pools.topics     = uniqInts(cfg.placeholderIds || '');
+    state.pools.posts      = uniqInts(cfg.messagePlaceholderIds || '');
+    state.pools.categories = uniqInts(cfg.categoryPlaceholderIds || '');
+    // Ne pas réinitialiser les curseurs ici (ils sont remis à 0 dans cleanup).
+  }
+
+  // ─── Page / Kind ──────────────────────────────────────────────────────────
+  function getPageKey() {
+    try {
+      const ax = window.ajaxify?.data;
+      if (ax?.tid) return `topic:${ax.tid}`;
+      if (ax?.cid) return `cid:${ax.cid}:${location.pathname}`;
+    } catch (_) {}
+    return location.pathname;
+  }
+
+  function getKind() {
+    const p = location.pathname;
+    if (/^\/topic\//.test(p))      return 'topic';
+    if (/^\/category\//.test(p))   return 'categoryTopics';
+    if (p === '/' || /^\/categories/.test(p)) return 'categories';
+    if (document.querySelector(SELECTORS.categoryItem)) return 'categories';
+    if (document.querySelector(SELECTORS.postItem))     return 'topic';
+    if (document.querySelector(SELECTORS.topicItem))    return 'categoryTopics';
+    return 'other';
+  }
+
+  // ─── DOM helpers ──────────────────────────────────────────────────────────
+  function getPostContainers() {
+    return Array.from(document.querySelectorAll(SELECTORS.postItem)).filter(el => {
+      if (!el.isConnected) return false;
+      if (!el.querySelector('[component="post/content"]')) return false;
+      const parentPost = el.parentElement?.closest('[component="post"][data-pid]');
+      if (parentPost && parentPost !== el) return false;
+      if (el.getAttribute('component') === 'post/parent') return false;
+      return true;
+    });
+  }
+
+  function getTopicItems()    { return Array.from(document.querySelectorAll(SELECTORS.topicItem)); }
+  function getCategoryItems() { return Array.from(document.querySelectorAll(SELECTORS.categoryItem)); }
+
+  /**
+   * Calcule l'ancre stable d'un élément : on préfère data-pid (posts) puis
+   * data-index, sinon on retombe sur l'index dans le tableau.
+   * La clé est préfixée par kindClass pour éviter les collisions.
+   */
+  function getAnchorKey(kindClass, el, fallbackIndex) {
+    const pid   = el.getAttribute('data-pid');
+    const index = el.getAttribute('data-index') ?? el.getAttribute('data-idx');
+    const id    = pid ?? index ?? String(fallbackIndex);
+    return `${kindClass}:${id}`;
+  }
+
+  function findWrapByAnchor(anchorKey) {
+    return document.querySelector(`.${WRAP_CLASS}[${ANCHOR_ATTR}="${CSS.escape(anchorKey)}"]`);
+  }
+
+  function hasAdjacentWrap(el) {
+    const next = el.nextElementSibling;
+    if (next?.classList?.contains(WRAP_CLASS)) return true;
+    const prev = el.previousElementSibling;
+    if (prev?.classList?.contains(WRAP_CLASS)) return true;
+    return false;
+  }
+
+  // ─── ID pool / rotation ───────────────────────────────────────────────────
+  /**
+   * Retourne le prochain id disponible du pool (non déjà monté dans le DOM),
+   * en avançant le curseur rotatif.
+   */
+  function pickId(poolKey) {
+    const pool = state.pools[poolKey];
+    const n    = pool.length;
+    if (!n) return null;
+
+    for (let tries = 0; tries < n; tries++) {
+      const idx = state.cursors[poolKey] % n;
+      state.cursors[poolKey] = (state.cursors[poolKey] + 1) % n;
+      const id = pool[idx];
+      if (!state.mountedIds.has(id)) return id;
     }
-    return p;
+    return null; // Tous les IDs déjà montés
   }
 
-  function callEzoic(id) {
-    if (typeof window.ezstandalone === 'undefined') return;
-    const pid = parseInt(id, 10);
-    if (isNaN(pid)) return;
+  // ─── Wrap construction ────────────────────────────────────────────────────
+  function buildWrap(id, kindClass, anchorKey) {
+    const wrap = document.createElement('div');
+    wrap.className = `${WRAP_CLASS} ${kindClass}`;
+    wrap.setAttribute(ANCHOR_ATTR, anchorKey);
+    wrap.setAttribute(WRAPID_ATTR, String(id));
+    wrap.setAttribute(CREATED_ATTR, String(now()));
+    wrap.style.cssText = 'width:100%;display:block;';
 
-    window.ezstandalone.cmd.push(function() {
-      window.ezstandalone.define(pid);
-      if (!window.ezstandalone.enabled) {
-        window.ezstandalone.enable();
-        window.ezstandalone.showAds();
+    const ph = document.createElement('div');
+    ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+    ph.setAttribute('data-ezoic-id', String(id));
+    wrap.appendChild(ph);
+
+    return wrap;
+  }
+
+  function insertWrapAfter(el, id, kindClass, anchorKey) {
+    if (!el?.insertAdjacentElement) return null;
+    if (findWrapByAnchor(anchorKey))  return null; // déjà présent
+    if (state.mountedIds.has(id))     return null; // id déjà monté
+
+    const existingPh = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+    if (existingPh?.isConnected) {
+      // Cet id a déjà un placeholder dans le DOM → on ne peut pas le dupliquer
+      return null;
+    }
+
+    const wrap = buildWrap(id, kindClass, anchorKey);
+    withInternalMutation(() => el.insertAdjacentElement('afterend', wrap));
+    state.mountedIds.add(id);
+    return wrap;
+  }
+
+  function removeWrap(wrap) {
+    try {
+      const id = parseInt(wrap.getAttribute(WRAPID_ATTR), 10);
+      if (Number.isFinite(id)) state.mountedIds.delete(id);
+      wrap.remove();
+    } catch (_) {}
+  }
+
+  // ─── Prune & Decluster ────────────────────────────────────────────────────
+  /**
+   * Supprime les wraps dont l'élément-ancre n'est plus dans le DOM.
+   * On supprime proprement (remove) plutôt que de cacher → libère l'id.
+   */
+  function pruneOrphans(kindClass) {
+    const wraps = document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`);
+    let removed = 0;
+
+    wraps.forEach(wrap => {
+      // Ne jamais pruner un wrap tout juste créé (fill lent côté Ezoic)
+      const created = parseInt(wrap.getAttribute(CREATED_ATTR) || '0', 10);
+      if (created && (now() - created) < EMPTY_WRAP_TTL_MS) return;
+
+      const anchorKey = wrap.getAttribute(ANCHOR_ATTR);
+      if (!anchorKey) {
+        withInternalMutation(() => removeWrap(wrap));
+        removed++;
+        return;
+      }
+
+      // L'ancre existe-t-elle encore dans le DOM ?
+      const [, anchorId] = anchorKey.split(':');
+      const isPost = kindClass === 'ezoic-ad-message';
+      let anchorEl = null;
+
+      if (isPost) {
+        anchorEl = document.querySelector(`[component="post"][data-pid="${CSS.escape(anchorId)}"]`);
       } else {
-        window.ezstandalone.showAds(pid);
+        anchorEl = document.querySelector(`${SELECTORS.topicItem}[data-index="${CSS.escape(anchorId)}"]`)
+                ?? document.querySelector(`${SELECTORS.categoryItem}[data-index="${CSS.escape(anchorId)}"]`);
+      }
+
+      if (!anchorEl || !anchorEl.isConnected) {
+        // Ancre disparue → si rempli on garde (scrolling back), si vide on supprime
+        if (!isFilledNode(wrap)) {
+          withInternalMutation(() => removeWrap(wrap));
+          removed++;
+        }
       }
-      activeIds.add(pid);
     });
+
+    return removed;
   }
 
-  function redistribute() {
-    if (!config || config.excluded) return;
+  /**
+   * Si deux wraps se retrouvent consécutifs (sans item entre eux),
+   * on supprime le plus récent des deux s'il est vide.
+   */
+  function decluster(kindClass) {
+    const wraps = Array.from(document.querySelectorAll(`.${WRAP_CLASS}.${kindClass}`));
+    let removed = 0;
 
-    // 1. Accueil / Catégories
-    const categoryItems = document.querySelectorAll('.category-item, [component="categories/category"]');
-    if (config.enableCategoryAds) process(Array.from(categoryItems), 'home', config.intervalCategories, config.showFirstCategoryAd, 'div');
+    for (const wrap of wraps) {
+      let prev = wrap.previousElementSibling;
+      let steps = 0;
+      while (prev && steps < 3) {
+        if (prev.classList?.contains(WRAP_CLASS)) {
+          // Deux wraps consécutifs : supprimer le plus vide/récent
+          const wCreated  = parseInt(wrap.getAttribute(CREATED_ATTR) || '0', 10);
+          const pCreated  = parseInt(prev.getAttribute(CREATED_ATTR) || '0', 10);
+          const wFilled   = isFilledNode(wrap);
+          const pFilled   = isFilledNode(prev);
 
-    // 2. Liste des Topics (Harmony utilise des <li>)
-    const topicItems = document.querySelectorAll('li[component="category/topic"]');
-    if (config.enableBetweenAds) process(Array.from(topicItems), 'topic-list', config.intervalPosts, config.showFirstTopicAd, 'li');
+          if (!wFilled) {
+            withInternalMutation(() => removeWrap(wrap));
+            removed++;
+          } else if (!pFilled) {
+            withInternalMutation(() => removeWrap(prev));
+            removed++;
+          }
+          // Si les deux sont remplis, laisser en place
+          break;
+        }
+        prev = prev.previousElementSibling;
+        steps++;
+      }
+    }
+
+    return removed;
+  }
+
+  // ─── Injection ────────────────────────────────────────────────────────────
+  function computeTargetIndices(count, interval, showFirst) {
+    const targets = new Set();
+    if (showFirst && count > 0) targets.add(0);
+    for (let i = interval - 1; i < count; i += interval) targets.add(i);
+    return [...targets].sort((a, b) => a - b);
+  }
+
+  function injectBetween(kindClass, items, interval, showFirst, poolKey) {
+    if (!items.length) return 0;
+
+    const targets  = computeTargetIndices(items.length, interval, showFirst);
+    const maxIns   = MAX_INSERTS_PER_RUN + (isBoosted() ? 2 : 0);
+    let inserted   = 0;
+
+    for (const idx of targets) {
+      if (inserted >= maxIns) break;
+
+      const el         = items[idx];
+      if (!el?.isConnected) continue;
+      if (hasAdjacentWrap(el)) continue;
+
+      const anchorKey  = getAnchorKey(kindClass, el, idx);
+      if (findWrapByAnchor(anchorKey)) continue; // déjà là
 
-    // 3. Messages (Posts)
-    const postItems = document.querySelectorAll('[component="post"]');
-    if (config.enableMessageAds) process(Array.from(postItems), 'message', config.messageIntervalPosts, config.showFirstMessageAd, 'div');
+      const id = pickId(poolKey);
+      if (!id) break; // pool épuisé pour cette passe
+
+      const wrap = insertWrapAfter(el, id, kindClass, anchorKey);
+      if (!wrap) continue;
+
+      observePlaceholder(id);
+      inserted++;
+    }
+
+    return inserted;
+  }
+
+  // ─── Preload / Show ───────────────────────────────────────────────────────
+  function getPreloadMargin() {
+    const m = isMobile() ? 'mobile' : 'desktop';
+    return PRELOAD_MARGIN[m + (isBoosted() ? 'Boosted' : '')];
   }
 
-  function process(items, kind, interval, showFirst, wrapperTag) {
-    const int = parseInt(interval, 10) || 10;
-    const pool = getPool();
+  function getMaxInflight() {
+    return (isMobile() ? MAX_INFLIGHT_MOBILE : MAX_INFLIGHT_DESKTOP) + (isBoosted() ? 1 : 0);
+  }
 
-    items.forEach((item, index) => {
-      const pos = index + 1;
-      const shouldHaveAd = (pos === 1 && showFirst) || (pos % int === 0);
-      const next = item.nextElementSibling;
+  function ensurePreloadObserver() {
+    const margin = getPreloadMargin();
+    if (state.io && state.ioMargin === margin) return state.io;
 
-      if (shouldHaveAd && !(next && next.classList.contains(WRAP_CLASS))) {
-        const available = pool.querySelector(`[data-kind="${kind}"]`);
-        if (available) {
-          isInternalChange = true;
-          
-          // Création d'un conteneur qui respecte le type de parent (li ou div)
-          const wrapper = document.createElement(wrapperTag);
-          wrapper.className = WRAP_CLASS + ' ezoic-added-content';
-          wrapper.setAttribute('data-kind', kind);
-          wrapper.setAttribute('data-placeholder-id', available.getAttribute('data-placeholder-id'));
-          wrapper.innerHTML = available.innerHTML;
+    state.io?.disconnect();
+    state.io = null;
 
-          item.parentNode.insertBefore(wrapper, item.nextSibling);
-          callEzoic(available.getAttribute('data-placeholder-id'));
-          
-          setTimeout(() => { isInternalChange = false; }, 50);
+    try {
+      state.io = new IntersectionObserver(entries => {
+        for (const ent of entries) {
+          if (!ent.isIntersecting) continue;
+          state.io?.unobserve(ent.target);
+          const id = parseInt(ent.target.getAttribute('data-ezoic-id'), 10);
+          if (Number.isFinite(id) && id > 0) enqueueShow(id);
         }
+      }, { root: null, rootMargin: margin, threshold: 0 });
+      state.ioMargin = margin;
+    } catch (_) { state.io = null; state.ioMargin = null; }
+
+    // Ré-observer les placeholders déjà dans le DOM
+    try {
+      document.querySelectorAll(`[id^="${PLACEHOLDER_PREFIX}"]`).forEach(n => {
+        try { state.io?.observe(n); } catch (_) {}
+      });
+    } catch (_) {}
+
+    return state.io;
+  }
+
+  function observePlaceholder(id) {
+    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+    if (!ph?.isConnected) return;
+    try { state.io?.observe(ph); } catch (_) {}
+
+    // Si déjà proche du viewport → show immédiat
+    try {
+      const r = ph.getBoundingClientRect();
+      const screens = isBoosted() ? 6 : (isMobile() ? 4 : 2.5);
+      if (r.top < window.innerHeight * screens && r.bottom > -window.innerHeight * 2) {
+        enqueueShow(id);
       }
+    } catch (_) {}
+  }
+
+  function enqueueShow(id) {
+    if (!id || isBlocked()) return;
+    const t = now();
+    if (t - (state.lastShowById.get(id) ?? 0) < SHOW_THROTTLE_MS) return;
+
+    if (state.inflight >= getMaxInflight()) {
+      if (!state.pendingSet.has(id)) {
+        state.pending.push(id);
+        state.pendingSet.add(id);
+      }
+      return;
+    }
+    startShow(id);
+  }
+
+  function drainQueue() {
+    if (isBlocked()) return;
+    while (state.inflight < getMaxInflight() && state.pending.length) {
+      const id = state.pending.shift();
+      state.pendingSet.delete(id);
+      startShow(id);
+    }
+  }
+
+  function startShow(id) {
+    if (!id || isBlocked()) return;
+    state.inflight++;
+    let done = false;
+
+    const release = () => {
+      if (done) return;
+      done = true;
+      state.inflight = Math.max(0, state.inflight - 1);
+      drainQueue();
+    };
+
+    const timeout = setTimeout(release, 6500);
+
+    requestAnimationFrame(() => {
+      try {
+        if (isBlocked()) return release();
+        const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+        if (!ph?.isConnected) return release();
+        if (isFilledNode(ph)) { clearTimeout(timeout); return release(); }
+
+        const t = now();
+        if (t - (state.lastShowById.get(id) ?? 0) < SHOW_THROTTLE_MS) return release();
+        state.lastShowById.set(id, t);
+
+        window.ezstandalone = window.ezstandalone || {};
+        const ez = window.ezstandalone;
+
+        const doShow = () => {
+          try { ez.showAds(id); } catch (_) {}
+          scheduleEmptyCheck(id);
+          setTimeout(release, 650);
+        };
+
+        if (Array.isArray(ez.cmd)) ez.cmd.push(doShow);
+        else doShow();
+      } finally { /* timeout covers us */ }
     });
   }
 
-  function init() {
-    fetch('/api/plugins/ezoic-infinite/config')
-      .then(r => r.json())
-      .then(data => {
-        config = data;
-        const pool = getPool();
-        const setup = (raw, kind) => {
-          if (!raw) return;
-          raw.split(/[\s,]+/).filter(Boolean).forEach(id => {
-            const d = document.createElement('div');
-            d.setAttribute('data-kind', kind);
-            d.setAttribute('data-placeholder-id', id);
-            d.innerHTML = `<div id="ezoic-pub-ad-placeholder-${id}"></div>`;
-            pool.appendChild(d);
-          });
+  function scheduleEmptyCheck(id) {
+    setTimeout(() => {
+      try {
+        const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+        if (!ph?.isConnected) return;
+        const wrap = ph.closest(`.${WRAP_CLASS}`);
+        if (!wrap) return;
+
+        const created = parseInt(wrap.getAttribute(CREATED_ATTR) || '0', 10);
+        if (created && (now() - created) < EMPTY_WRAP_TTL_MS) return;
+
+        if (!isFilledNode(ph)) wrap.classList.add('is-empty');
+        else wrap.classList.remove('is-empty');
+      } catch (_) {}
+    }, 15_000);
+  }
+
+  // ─── Patch Ezoic showAds ──────────────────────────────────────────────────
+  function patchShowAds() {
+    const apply = () => {
+      try {
+        window.ezstandalone = window.ezstandalone || {};
+        const ez = window.ezstandalone;
+        if (window.__nodebbEzoicPatched || typeof ez.showAds !== 'function') return;
+
+        window.__nodebbEzoicPatched = true;
+        const orig = ez.showAds.bind(ez);
+
+        ez.showAds = function (...args) {
+          if (isBlocked()) return;
+          const ids = (args.length === 1 && Array.isArray(args[0])) ? args[0] : args;
+          const seen = new Set();
+          for (const v of ids) {
+            const id = parseInt(v, 10);
+            if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
+            const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+            if (!ph?.isConnected) continue;
+            seen.add(id);
+            try { orig(id); } catch (_) {}
+          }
         };
-        setup(config.categoryPlaceholderIds, 'home');
-        setup(config.placeholderIds, 'topic-list');
-        setup(config.messagePlaceholderIds, 'message');
-        
-        redistribute();
-
-        const observer = new MutationObserver(() => {
-          if (!isInternalChange) redistribute();
-        });
-        observer.observe(document.body, { childList: true, subtree: true });
+      } catch (_) {}
+    };
+
+    apply();
+    if (!window.__nodebbEzoicPatched) {
+      window.ezstandalone = window.ezstandalone || {};
+      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+      window.ezstandalone.cmd.push(apply);
+    }
+  }
+
+  // ─── Core run ─────────────────────────────────────────────────────────────
+  async function runCore() {
+    if (isBlocked()) return 0;
+    patchShowAds();
+
+    const cfg = await fetchConfig();
+    if (!cfg || cfg.excluded) return 0;
+    initPools(cfg);
+
+    const kind = getKind();
+    let inserted = 0;
+
+    const run = (kindClass, getItems, cfgEnable, cfgInterval, cfgShowFirst, poolKey) => {
+      if (!normBool(cfgEnable)) return 0;
+      const items = getItems();
+      pruneOrphans(kindClass);
+      const n = injectBetween(kindClass, items, Math.max(1, parseInt(cfgInterval, 10) || 3), normBool(cfgShowFirst), poolKey);
+      if (n) decluster(kindClass);
+      return n;
+    };
+
+    if (kind === 'topic') {
+      inserted += run('ezoic-ad-message', getPostContainers,
+        cfg.enableMessageAds, cfg.messageIntervalPosts, cfg.showFirstMessageAd, 'posts');
+    } else if (kind === 'categoryTopics') {
+      inserted += run('ezoic-ad-between', getTopicItems,
+        cfg.enableBetweenAds, cfg.intervalPosts, cfg.showFirstTopicAd, 'topics');
+    } else if (kind === 'categories') {
+      inserted += run('ezoic-ad-categories', getCategoryItems,
+        cfg.enableCategoryAds, cfg.intervalCategories, cfg.showFirstCategoryAd, 'categories');
+    }
+
+    return inserted;
+  }
+
+  // ─── Scheduler / Burst ────────────────────────────────────────────────────
+  function scheduleRun(delayMs = 0, cb) {
+    if (state.runQueued) return;
+    state.runQueued = true;
+
+    const run = async () => {
+      state.runQueued = false;
+      if (state.pageKey && getPageKey() !== state.pageKey) return;
+      let n = 0;
+      try { n = await runCore(); } catch (_) {}
+      try { cb?.(n); } catch (_) {}
+    };
+
+    const doRun = () => requestAnimationFrame(run);
+    if (delayMs > 0) setTimeout(doRun, delayMs);
+    else doRun();
+  }
+
+  function requestBurst() {
+    if (isBlocked()) return;
+    const t = now();
+    if (t - state.lastBurstReqTs < 100) return;
+    state.lastBurstReqTs = t;
+
+    const pk = getPageKey();
+    state.pageKey = pk;
+    state.burstDeadline = t + 1800;
+
+    if (state.burstActive) return;
+    state.burstActive = true;
+    state.burstCount  = 0;
+
+    const step = () => {
+      if (getPageKey() !== pk)       { state.burstActive = false; return; }
+      if (isBlocked())               { state.burstActive = false; return; }
+      if (now() > state.burstDeadline) { state.burstActive = false; return; }
+      if (state.burstCount >= 8)     { state.burstActive = false; return; }
+
+      state.burstCount++;
+      scheduleRun(0, (n) => {
+        if (!n && !state.pending.length) { state.burstActive = false; return; }
+        setTimeout(step, n > 0 ? 120 : 250);
       });
+    };
+
+    step();
+  }
+
+  // ─── Cleanup (ajaxify navigation) ─────────────────────────────────────────
+  function cleanup() {
+    // Bloquer toute injection pendant la transition
+    blockedUntil = now() + 1500;
+
+    // Supprimer tous les wraps injectés → libère les IDs
+    withInternalMutation(() => {
+      document.querySelectorAll(`.${WRAP_CLASS}`).forEach(removeWrap);
+    });
+
+    // Réinitialiser l'état complet
+    state.cfg         = null;
+    state.pools       = { topics: [], posts: [], categories: [] };
+    state.cursors     = { topics: 0, posts: 0, categories: 0 };
+    state.mountedIds.clear();
+    state.lastShowById.clear();
+    state.inflight    = 0;
+    state.pending     = [];
+    state.pendingSet.clear();
+
+    state.burstActive = false;
+    state.runQueued   = false;
+  }
+
+  // ─── DOM Observer ─────────────────────────────────────────────────────────
+  function shouldReact(mutations) {
+    for (const m of mutations) {
+      if (!m.addedNodes?.length) continue;
+      for (const n of m.addedNodes) {
+        if (n.nodeType !== 1) continue;
+        if (
+          n.matches?.(SELECTORS.postItem)     || n.querySelector?.(SELECTORS.postItem)     ||
+          n.matches?.(SELECTORS.topicItem)    || n.querySelector?.(SELECTORS.topicItem)    ||
+          n.matches?.(SELECTORS.categoryItem) || n.querySelector?.(SELECTORS.categoryItem)
+        ) return true;
+      }
+    }
+    return false;
+  }
+
+  function ensureDomObserver() {
+    if (state.domObs) return;
+    state.domObs = new MutationObserver(mutations => {
+      if (state.internalMutation > 0) return;
+      if (isBlocked()) return;
+      if (!shouldReact(mutations)) return;
+      requestBurst();
+    });
+    try { state.domObs.observe(document.body, { childList: true, subtree: true }); } catch (_) {}
   }
 
-  // GESTION NAVIGATION SANS RECHARGE (SPA)
-  window.addEventListener('action:ajaxify.start', function() {
-    if (typeof window.ezstandalone !== 'undefined' && activeIds.size > 0) {
-      window.ezstandalone.cmd.push(function() {
-        window.ezstandalone.destroyAll();
-        activeIds.clear();
+  // ─── Utilities: console mute + TCF + network warm ─────────────────────────
+  function muteNoisyConsole() {
+    if (window.__nodebbEzoicConsoleMuted) return;
+    window.__nodebbEzoicConsoleMuted = true;
+    const MUTED = [
+      '[EzoicAds JS]: Placeholder Id',
+      'Debugger iframe already exists',
+      'HTML element with id ezoic-pub-ad-placeholder-',
+    ];
+    ['log', 'info', 'warn', 'error'].forEach(m => {
+      const orig = console[m];
+      if (typeof orig !== 'function') return;
+      console[m] = function (...args) {
+        const s = typeof args[0] === 'string' ? args[0] : '';
+        if (MUTED.some(p => s.includes(p))) return;
+        orig.apply(console, args);
+      };
+    });
+  }
+
+  function ensureTcfLocator() {
+    try {
+      if (!window.__tcfapi && !window.__cmp) return;
+      if (document.getElementById('__tcfapiLocator')) return;
+      const f = Object.assign(document.createElement('iframe'), {
+        style: 'display:none', id: '__tcfapiLocator', name: '__tcfapiLocator',
       });
+      (document.body || document.documentElement).appendChild(f);
+    } catch (_) {}
+  }
+
+  const _warmedLinks = new Set();
+  function warmNetwork() {
+    const head = document.head;
+    if (!head) return;
+    const links = [
+      ['preconnect',   'https://g.ezoic.net',                      true],
+      ['preconnect',   'https://go.ezoic.net',                     true],
+      ['preconnect',   'https://securepubads.g.doubleclick.net',   true],
+      ['preconnect',   'https://pagead2.googlesyndication.com',    true],
+      ['dns-prefetch', 'https://g.ezoic.net',                      false],
+      ['dns-prefetch', 'https://securepubads.g.doubleclick.net',   false],
+    ];
+    for (const [rel, href, cors] of links) {
+      const key = `${rel}|${href}`;
+      if (_warmedLinks.has(key)) continue;
+      _warmedLinks.add(key);
+      const link = document.createElement('link');
+      link.rel = rel; link.href = href;
+      if (cors) link.crossOrigin = 'anonymous';
+      head.appendChild(link);
     }
-  });
+  }
+
+  // ─── NodeBB + Scroll bindings ─────────────────────────────────────────────
+  function bindNodeBB() {
+    const $ = window.jQuery;
+    if (!$) return;
+
+    $(window).off('.ezoicInfinite');
+
+    $(window).on('action:ajaxify.start.ezoicInfinite', () => {
+      cleanup();
+    });
 
-  window.addEventListener('action:ajaxify.end', function() {
-    setTimeout(redistribute, 600);
-  });
+    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
+      state.pageKey = getPageKey();
+      blockedUntil  = 0;
+      muteNoisyConsole();
+      ensureTcfLocator();
+      warmNetwork();
+      patchShowAds();
+      ensurePreloadObserver();
+      ensureDomObserver();
+      requestBurst();
+    });
+
+    const burstEvents = [
+      'action:ajaxify.contentLoaded',
+      'action:posts.loaded',
+      'action:topics.loaded',
+      'action:categories.loaded',
+      'action:category.loaded',
+      'action:topic.loaded',
+    ].map(e => `${e}.ezoicInfinite`).join(' ');
+
+    $(window).on(burstEvents, () => { if (!isBlocked()) requestBurst(); });
+
+    // Hooks AMD (NodeBB 4.x)
+    try {
+      require(['hooks'], hooks => {
+        if (typeof hooks?.on !== 'function') return;
+        [
+          'action:ajaxify.end', 'action:ajaxify.contentLoaded',
+          'action:posts.loaded', 'action:topics.loaded',
+          'action:categories.loaded', 'action:category.loaded', 'action:topic.loaded',
+        ].forEach(ev => {
+          try { hooks.on(ev, () => { if (!isBlocked()) requestBurst(); }); } catch (_) {}
+        });
+      });
+    } catch (_) {}
+  }
 
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', init);
-  } else {
-    init();
+  function bindScroll() {
+    let ticking = false;
+    window.addEventListener('scroll', () => {
+      // Scroll boost
+      try {
+        const t  = now();
+        const y  = window.scrollY || window.pageYOffset || 0;
+        if (state.lastScrollTs) {
+          const speed = Math.abs(y - state.lastScrollY) / Math.max(1, t - state.lastScrollTs);
+          if (speed >= BOOST_SPEED_PX_PER_MS) {
+            const wasBoosted = isBoosted();
+            state.scrollBoostUntil = Math.max(state.scrollBoostUntil, t + BOOST_DURATION_MS);
+            if (!wasBoosted) ensurePreloadObserver();
+          }
+        }
+        state.lastScrollY  = y;
+        state.lastScrollTs = t;
+      } catch (_) {}
+
+      if (ticking) return;
+      ticking = true;
+      requestAnimationFrame(() => { ticking = false; requestBurst(); });
+    }, { passive: true });
   }
-})();
+
+  // ─── Boot ─────────────────────────────────────────────────────────────────
+  state.pageKey = getPageKey();
+  muteNoisyConsole();
+  ensureTcfLocator();
+  warmNetwork();
+  patchShowAds();
+  ensurePreloadObserver();
+  ensureDomObserver();
+  bindNodeBB();
+  bindScroll();
+  blockedUntil = 0;
+  requestBurst();
+})();

package/public/style.css

@@ -1,37 +1,89 @@
-/* Isolation et Taille */
+/*
+  NodeBB Ezoic Infinite Ads — style.css (v18)
+  Corrections :
+  - Suppression de line-height:0/font-size:0 global (cassait le texte adjacent)
+  - Ciblage précis pour éviter les effets de bord sur les composants NodeBB
+  - Règles is-empty revues pour ne pas interférer avec les slots en cours de fill
+*/
+
+/* ── Wrapper principal ───────────────────────────────────────────────────── */
 .nodebb-ezoic-wrap {
-    display: block !important;
-    width: 100% !important;
-    min-height: 250px !important;
-    margin: 30px 0 !important;
-    clear: both !important;
-    text-align: center;
-    list-style: none !important; /* Pour les injections en <li> */
+  display: block;
+  width: 100%;
+  margin: 0 !important;
+  padding: 0 !important;
+  overflow: hidden;
+  contain: layout style;  /* isolation des reflows */
+}
+
+/* Placeholder : measurable pour l'IntersectionObserver, invisible si vide */
+.nodebb-ezoic-wrap > [id^="ezoic-pub-ad-placeholder-"] {
+  margin: 0 !important;
+  padding: 0 !important;
+  min-height: 1px;
+  display: block;
 }
 
-/* Fix pour l'accueil Harmony */
-li.nodebb-ezoic-wrap {
-    float: none !important;
-    padding: 20px 0;
-    border-bottom: 1px solid rgba(0,0,0,0.05);
+/* ── Ciblage précis des noeuds Ezoic à l'intérieur de nos wraps ─────────── */
+
+/* Killer du gap "baseline" sous les iframes */
+.nodebb-ezoic-wrap iframe,
+.nodebb-ezoic-wrap div[id$="__container__"] iframe {
+  display: block !important;
+  vertical-align: top !important;
+  line-height: 0 !important;
+  font-size: 0 !important;
 }
 
-/* Éviter que les pubs ne se collent aux messages */
-[component="post"] + .nodebb-ezoic-wrap {
-    background: rgba(0,0,0,0.02);
-    padding: 20px;
-    border-radius: 10px;
+.nodebb-ezoic-wrap div[id$="__container__"] {
+  display: block !important;
+  line-height: 0 !important;
+  font-size: 0 !important;
 }
 
-/* Anti-remontée (Pile-up) */
-.nodebb-ezoic-wrap::before, .nodebb-ezoic-wrap::after {
-    content: "";
-    display: table;
-    clear: both;
+/* Kill de la réserve 400px qu'Ezoic injecte en inline style */
+.nodebb-ezoic-wrap .ezoic-ad,
+.nodebb-ezoic-wrap span.ezoic-ad {
+  margin: 0 !important;
+  padding: 0 !important;
+  min-height: 1px !important;  /* écrase le 400px Ezoic */
+  height: auto !important;
 }
 
-/* Centrage forcé des iframes Ezoic */
+/* Reportline en absolu pour ne pas impacter le layout */
+.nodebb-ezoic-wrap .reportline {
+  position: absolute !important;
+}
+
+/* Neutralise sticky à l'intérieur de nos wraps (évite l'effet "gliding") */
+.nodebb-ezoic-wrap .ezads-sticky-intradiv {
+  position: static !important;
+  top: auto !important;
+}
+
+/* ── État "vide" ─────────────────────────────────────────────────────────── */
+/*
+  is-empty est ajouté 15s après le show si aucun fill détecté.
+  On collapse à 1px (et non 0) pour rester visible à l'IO (évite le déclenchement
+  trop tard si le fill arrive après le collapse).
+*/
+.nodebb-ezoic-wrap.is-empty {
+  display: block !important;
+  height: 1px !important;
+  min-height: 1px !important;
+  max-height: 1px !important;
+  margin: 0 !important;
+  padding: 0 !important;
+  overflow: hidden !important;
+}
+
+/* ── Ezoic global (hors de nos wraps) ───────────────────────────────────── */
 .ezoic-ad {
-    margin: 0 auto !important;
-    display: block !important;
-}
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+/* ── Orphan hidden (compatibilité transitoire) ───────────────────────────── */
+.ez-orphan-hidden {
+  display: none !important;
+}