nodebb-plugin-ezoic-infinite 1.5.6 → 1.5.7

package/library.js

@@ -107,7 +107,7 @@ plugin.init = async ({ router, middleware }) => {
 
   router.get('/api/plugins/ezoic-infinite/config', async (req, res) => {
     const settings = await getSettings();
-    const excluded = await isUserExcluded((req.uid || (req.user && req.user.uid)), settings.excludedGroups);
+    const excluded = await isUserExcluded(req.uid, settings.excludedGroups);
 
     res.json({
       excluded,

package/package.json

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

package/public/client.js

@@ -1,386 +1,477 @@
-'use strict';
-/**
- * Ezoic Infinite Ads for NodeBB 4.x
- * - Event-driven only (ajaxify hooks + MutationObserver + IntersectionObserver)
- * - Hard gate on server config (respects excluded groups BEFORE any injection)
- * - Placeholder Registry: keeps all placeholder elements alive in a hidden pool so ez-standalone never complains
- * - Safe showAds wrapper (array, varargs, single) + tokenized execution across ajaxify navigations
- */
-
 (function () {
-  const CFG_URL = '/api/plugins/ezoic-infinite/config';
-
-  // -------------------------
-  // Utilities
-  // -------------------------
-  const now = () => (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
-  const clamp = (n, a, b) => Math.max(a, Math.min(b, n));
-
-  function on(ev, fn) { document.addEventListener(ev, fn); }
-  function once(ev, fn) {
-    const h = (e) => { document.removeEventListener(ev, h); fn(e); };
-    document.addEventListener(ev, h);
+  'use strict';
+
+  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
+
+  const WRAP_CLASS = 'ezoic-ad';
+  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
+
+  const SELECTORS = {
+    topicItem: 'li[component="category/topic"]',
+    categoryItem: 'li[component="categories/category"]',
+    postItem: '[component="post"][data-pid]',
+    postContent: '[component="post/content"]',
+  };
+
+  // ----------------------------
+  // State
+  // ----------------------------
+  const state = {
+    pageKey: null,
+    pageToken: 0,
+    cfgPromise: null,
+    cfg: null,
+    // throttle per id
+    lastShowAt: new Map(),
+    // observed placeholders -> ids
+    io: null,
+    mo: null,
+    scheduled: false,
+  };
+
+  // ----------------------------
+  // Small utils
+  // ----------------------------
+  function getPageKey() {
+    try {
+      const ax = window.ajaxify;
+      if (ax && ax.data) {
+        if (ax.data.tid) return `topic:${ax.data.tid}`;
+        if (ax.data.cid) return `cid:${ax.data.cid}:${window.location.pathname}`;
+      }
+    } catch (e) {}
+    return window.location.pathname || '';
+  }
+
+  function normalizeBool(v) {
+    return v === true || v === 'true' || v === 1 || v === '1' || v === 'on' || v === 'yes';
   }
 
-  // -------------------------
-  // Global state / navigation token
-  // -------------------------
-  let navToken = 0; // increment on ajaxify.start (page is about to be replaced)
-  let rafScheduled = false;
-
-  // resolved config (or null if failed)
-  let cfgPromise = null;
-  let cfg = null;
-
-  // -------------------------
-  // Placeholder Registry (keeps IDs alive)
-  // -------------------------
-  const Pool = {
-    el: null,
-    ensurePool() {
-      if (this.el && document.body.contains(this.el)) return this.el;
-      const d = document.createElement('div');
-      d.id = 'ezoic-placeholder-pool';
-      d.style.display = 'none';
-      d.setAttribute('aria-hidden', 'true');
-      document.body.appendChild(d);
-      this.el = d;
-      return d;
-    },
-    ensurePlaceholder(id) {
-      if (!id) return null;
-      let ph = document.getElementById(id);
-      if (ph) return ph;
-      const pool = this.ensurePool();
-      ph = document.createElement('div');
-      ph.id = id;
-      pool.appendChild(ph);
-      return ph;
-    },
-    returnToPool(id) {
-      const ph = document.getElementById(id);
-      if (!ph) return;
-      const pool = this.ensurePool();
-      if (ph.parentElement !== pool) {
-        pool.appendChild(ph);
+  function uniqInts(lines) {
+    const out = [];
+    const seen = new Set();
+    for (const v of lines) {
+      const n = parseInt(v, 10);
+      if (Number.isFinite(n) && n > 0 && !seen.has(n)) {
+        seen.add(n);
+        out.push(n);
       }
     }
-  };
+    return out;
+  }
 
-  // -------------------------
-  // Ezoic showAds safe wrapper (installed even if defined later)
-  // -------------------------
-  function normalizeIds(argsLike) {
-    const args = Array.from(argsLike);
-    if (!args.length) return [];
-    // showAds([id1,id2]) or showAds([[...]]) edge
-    if (args.length === 1 && Array.isArray(args[0])) return args[0].flat().map(String);
-    return args.flat().map(String);
+  function parsePool(raw) {
+    if (!raw) return [];
+    return uniqInts(String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean));
   }
 
-  function wrapShowAds(original) {
-    if (!original || original.__nodebbSafeWrapped) return original;
-
-    const wrapped = function (...args) {
-      const ids = normalizeIds(args);
-      if (!ids.length) return;
-
-      for (const id of ids) {
-        // Ensure placeholder exists somewhere (pool), so ez-standalone won't log "does not exist"
-        Pool.ensurePlaceholder(id);
-
-        const el = document.getElementById(id);
-        if (el && document.body.contains(el)) {
-          try {
-            // Call one-by-one to avoid batch logging on missing nodes
-            original.call(window.ezstandalone, id);
-          } catch (e) {
-            // swallow: Ezoic can throw if called during transitions
-          }
-        }
-      }
-    };
+  function getKind() {
+    const p = window.location.pathname || '';
+    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';
+  }
 
-    wrapped.__nodebbSafeWrapped = true;
-    return wrapped;
+  function getTopicItems() {
+    return Array.from(document.querySelectorAll(SELECTORS.topicItem));
   }
 
-  function installShowAdsHook() {
-    // If ezstandalone already exists, wrap now.
-    if (window.ezstandalone && window.ezstandalone.showAds) {
-      window.ezstandalone.showAds = wrapShowAds(window.ezstandalone.showAds);
-    }
+  function getCategoryItems() {
+    return Array.from(document.querySelectorAll(SELECTORS.categoryItem));
+  }
 
-    // Hook future assignment (no polling)
+  function getPostContainers() {
+    const nodes = Array.from(document.querySelectorAll(SELECTORS.postItem));
+    return nodes.filter((el) => {
+      if (!el || !el.isConnected) return false;
+      if (!el.querySelector(SELECTORS.postContent)) return false;
+      const parentPost = el.parentElement && el.parentElement.closest(SELECTORS.postItem);
+      if (parentPost && parentPost !== el) return false;
+      if (el.getAttribute('component') === 'post/parent') return false;
+      return true;
+    });
+  }
+
+  function isPlaceholderPresent(id) {
+    const el = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+    return !!(el && el.isConnected);
+  }
+
+  function schedule(fn) {
+    if (state.scheduled) return;
+    state.scheduled = true;
+    requestAnimationFrame(() => {
+      state.scheduled = false;
+      try { fn(); } catch (e) {}
+    });
+  }
+
+  // ----------------------------
+  // Ezoic showAds patch (handles arrays, varargs, and filters absent placeholders)
+  // ----------------------------
+  function patchShowAds() {
     try {
-      if (!window.ezstandalone) window.ezstandalone = {};
+      window.ezstandalone = window.ezstandalone || {};
       const ez = window.ezstandalone;
+      if (ez.__nodebbEzoicPatched) return;
+
+      // If showAds isn't ready yet, patch when it appears via cmd (no polling)
+      const apply = () => {
+        try {
+          if (!window.ezstandalone || typeof window.ezstandalone.showAds !== 'function') return;
+          const ez2 = window.ezstandalone;
+          if (ez2.__nodebbEzoicPatched) return;
+
+          const orig = ez2.showAds;
+          ez2.showAds = function () {
+            // Normalize ids from:
+            // - showAds([1,2])
+            // - showAds(1,2,3)
+            // - showAds(1)
+            const ids = [];
+            if (arguments.length === 1 && Array.isArray(arguments[0])) {
+              for (const v of arguments[0]) ids.push(v);
+            } else {
+              for (let i = 0; i < arguments.length; i++) ids.push(arguments[i]);
+            }
+
+            const seen = new Set();
+            for (const v of ids) {
+              const id = parseInt(v, 10);
+              if (!Number.isFinite(id) || id <= 0 || seen.has(id)) continue;
+              if (!isPlaceholderPresent(id)) continue;
+              seen.add(id);
+              try { orig.call(ez2, id); } catch (e) {}
+            }
+          };
+
+          ez2.__nodebbEzoicPatched = true;
+        } catch (e) {}
+      };
 
-      // If already has a setter installed, do nothing
-      const desc = Object.getOwnPropertyDescriptor(ez, 'showAds');
-      if (desc && (desc.set || desc.get)) return;
+      apply();
+      if (!window.ezstandalone.__nodebbEzoicPatchQueued) {
+        window.ezstandalone.__nodebbEzoicPatchQueued = true;
+        ez.cmd = ez.cmd || [];
+        ez.cmd.push(apply);
+      }
+    } catch (e) {}
+  }
 
-      let _showAds = ez.showAds;
-      Object.defineProperty(ez, 'showAds', {
-        configurable: true,
-        enumerable: true,
-        get() { return _showAds; },
-        set(v) { _showAds = wrapShowAds(v); }
+  function safeCmd(token, fn) {
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+      window.ezstandalone.cmd.push(function () {
+        // Drop stale work after ajaxify navigation
+        if (token !== state.pageToken) return;
+        if (getPageKey() !== state.pageKey) return;
+        try { fn(); } catch (e) {}
       });
-
-      // Re-assign current value through setter
-      ez.showAds = _showAds;
-    } catch (e) {
-      // If defineProperty fails, best-effort wrap is still in place above.
-    }
+    } catch (e) {}
   }
 
-  function ezCmd(fn) {
-    // Tokenize so queued callbacks don't run after navigation
-    const tokenAtSchedule = navToken;
-    window.ezstandalone = window.ezstandalone || {};
-    window.ezstandalone.cmd = window.ezstandalone.cmd || [];
-    window.ezstandalone.cmd.push(function () {
-      if (tokenAtSchedule !== navToken) return;
-      try { fn(); } catch (e) {}
+  function showAd(id) {
+    if (!id) return;
+    // throttle to avoid repeated calls during rerenders
+    const now = Date.now();
+    const last = state.lastShowAt.get(id) || 0;
+    if (now - last < 1500) return;
+    state.lastShowAt.set(id, now);
+
+    const token = state.pageToken;
+    safeCmd(token, () => {
+      if (!isPlaceholderPresent(id)) return;
+      patchShowAds();
+      if (window.ezstandalone && typeof window.ezstandalone.showAds === 'function') {
+        window.ezstandalone.showAds(id);
+      }
     });
   }
 
-  // -------------------------
-  // Config (hard gate)
-  // -------------------------
-  function prefetchConfig() {
-    if (cfgPromise) return cfgPromise;
-
-    cfgPromise = fetch(CFG_URL, { credentials: 'same-origin' })
-      .then(r => r.ok ? r.json() : Promise.reject(new Error('config http ' + r.status)))
-      .then(data => {
-        cfg = data;
-        // Pre-create placeholders in pool so Ezoic never complains even before first injection
-        const ids = parsePlaceholderIds((cfg && cfg.placeholderIds) || '');
-        ids.forEach(id => Pool.ensurePlaceholder(id));
-        return cfg;
-      })
-      .catch(() => {
-        cfg = null;
-        return null;
-      });
+  // ----------------------------
+  // DOM insertion (HTML-valid: if target is <li>, wrapper is <li>)
+  // ----------------------------
+  function buildWrap(id, kindClass, afterPos, liLike) {
+    const wrap = document.createElement(liLike ? 'li' : 'div');
+    wrap.className = `${WRAP_CLASS} ${kindClass}`;
+    wrap.setAttribute('data-ezoic-after', String(afterPos));
+    wrap.setAttribute('role', 'presentation');
+    wrap.style.width = '100%';
+
+    // Keep list styling if we're inside list-group
+    if (liLike && !wrap.classList.contains('list-group-item')) {
+      const targetIsListGroup = wrap.parentElement && wrap.parentElement.classList && wrap.parentElement.classList.contains('list-group');
+      // can't detect parent yet; we'll keep it minimal
+    }
 
-    return cfgPromise;
+    const ph = document.createElement('div');
+    ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+    wrap.appendChild(ph);
+    return wrap;
   }
 
-  function parsePlaceholderIds(s) {
-    return String(s || '')
-      .split(',')
-      .map(x => x.trim())
-      .filter(Boolean);
+  function findWrap(kindClass, afterPos) {
+    return document.querySelector(`.${WRAP_CLASS}.${kindClass}[data-ezoic-after="${afterPos}"]`);
   }
 
-  // -------------------------
-  // Ad insertion logic
-  // -------------------------
-  const Ad = {
-    // throttle showAds per placeholder id
-    lastShowAt: new Map(),
-    minShowIntervalMs: 1500,
+  function insertAfter(target, id, kindClass, afterPos) {
+    if (!target || !target.insertAdjacentElement) return null;
+    if (findWrap(kindClass, afterPos)) return null;
 
-    // Observers
-    io: null,
-    mo: null,
+    // avoid duplicates if already exists
+    if (isPlaceholderPresent(id)) return null;
 
-    // Bookkeeping
-    insertedKeys: new Set(), // avoid duplicate injection on re-renders
-
-    initObservers() {
-      if (!this.io) {
-        this.io = new IntersectionObserver((entries) => {
-          for (const e of entries) {
-            if (!e.isIntersecting) continue;
-            const id = e.target && e.target.getAttribute('data-ezoic-id');
-            if (id) this.requestShow(id);
-          }
-        }, { root: null, rootMargin: '1200px 0px', threshold: 0.01 });
-      }
+    const liLike = String(target.tagName).toUpperCase() === 'LI';
+    const wrap = buildWrap(id, kindClass, afterPos, liLike);
 
-      if (!this.mo) {
-        this.mo = new MutationObserver(() => this.scheduleScan());
-        const root = document.querySelector('#content, #panel, main, body');
-        if (root) this.mo.observe(root, { childList: true, subtree: true });
-      }
-    },
-
-    disconnectObservers() {
-      try { this.io && this.io.disconnect(); } catch (e) {}
-      try { this.mo && this.mo.disconnect(); } catch (e) {}
-      this.io = null;
-      this.mo = null;
-    },
-
-    scheduleScan() {
-      if (rafScheduled) return;
-      rafScheduled = true;
-      requestAnimationFrame(() => {
-        rafScheduled = false;
-        this.scanAndInject();
-      });
-    },
-
-    async scanAndInject() {
-      const c = await prefetchConfig();
-      if (!c) return;
-
-      if (c.excluded) return; // HARD stop: never inject for excluded users
-
-      installShowAdsHook();
-      this.initObservers();
-
-      if (c.enableBetweenAds) this.injectBetweenTopics(c);
-      // Extend: categories ads if you use them
-    },
-
-    // NodeBB topic list injection (between li rows)
-    injectBetweenTopics(c) {
-      // NodeBB 4.x (Harmony) uses: <ul component="category" class="topics-list ...">
-      // Older themes may use .topic-list
-      const container =
-        document.querySelector('ul[component="category"].topics-list') ||
-        document.querySelector('ul[component="category"].topic-list') ||
-        document.querySelector('ul.topics-list[component="category"]') ||
-        document.querySelector('ul.topics-list') ||
-        document.querySelector('.category ul.topics-list') ||
-        document.querySelector('.category .topic-list') ||
-        document.querySelector('.topics .topic-list') ||
-        document.querySelector('.topic-list');
-
-      if (!container) return;
-
-      let rows = Array.from(container.querySelectorAll(':scope > li')).filter(el => el && el.nodeType === 1);
-      if (!rows.length) {
-        // Fallback for older markups
-        rows = Array.from(container.querySelectorAll('li, .topic-row, .topic-item')).filter(el => el && el.nodeType === 1);
+    // If list-group-item exists on target, mirror it to keep theme markup consistent
+    if (liLike && target.classList && target.classList.contains('list-group-item')) {
+      wrap.classList.add('list-group-item');
+    }
+
+    target.insertAdjacentElement('afterend', wrap);
+    return wrap;
+  }
+
+  // ----------------------------
+  // Observers: preload + rerun on NodeBB DOM changes
+  // ----------------------------
+  function ensureIO() {
+    if (state.io) return;
+    if (!('IntersectionObserver' in window)) return;
+
+    state.io = new IntersectionObserver((entries) => {
+      for (const e of entries) {
+        if (!e.isIntersecting) continue;
+        const ph = e.target;
+        const id = parseInt(String(ph.id).replace(PLACEHOLDER_PREFIX, ''), 10);
+        if (Number.isFinite(id)) showAd(id);
+        try { state.io.unobserve(ph); } catch (err) {}
       }
-      if (!rows.length) return;
+    }, { root: null, rootMargin: '1200px 0px', threshold: 0 });
+  }
 
-      const ids = parsePlaceholderIds(c.placeholderIds);
-      if (!ids.length) return;
+  function observePlaceholder(id) {
+    ensureIO();
+    if (!state.io) return;
+    const ph = document.getElementById(`${PLACEHOLDER_PREFIX}${id}`);
+    if (!ph) return;
+    try { state.io.observe(ph); } catch (e) {}
+  }
 
-      const interval = clamp(parseInt(c.intervalPosts, 10) || 6, 1, 50);
+  function ensureMO() {
+    if (state.mo) return;
+    state.mo = new MutationObserver(() => schedule(runCore));
+    try { state.mo.observe(document.body, { childList: true, subtree: true }); } catch (e) {}
+  }
 
-      // HERO: early, above-the-fold (first eligible insertion point)
-      if (c.showFirstTopicAd) {
-        this.insertAdAfterRow(rows[0], ids[0], 'hero-topic-0');
+  // ----------------------------
+  // Config / exclusion
+  // ----------------------------
+  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;
+        const cfg = await res.json();
+        state.cfg = cfg;
+        return cfg;
+      } catch (e) {
+        return null;
+      } finally {
+        state.cfgPromise = null;
       }
+    })();
 
-      // Between rows
-      let idIndex = 0;
-      for (let i = interval; i < rows.length; i += interval) {
-        idIndex = (idIndex + 1) % ids.length;
-        this.insertAdAfterRow(rows[i - 1], ids[idIndex], `between-topic-${i}`);
-      }
-    },
+    return state.cfgPromise;
+  }
 
-    insertAdAfterRow(rowEl, placeholderId, key) {
-      if (!rowEl || !placeholderId || !key) return;
-      if (this.insertedKeys.has(key)) return;
+  function getUserGroupNamesFromAjaxify() {
+    try {
+      const ax = window.ajaxify;
+      const u = ax && ax.data && (ax.data.user || ax.data.profile || null);
+      if (!u) return [];
+      // NodeBB varies by route/theme; handle multiple shapes
+      const groupsA = u.groups || u.group_names || u.groupNames;
+      if (Array.isArray(groupsA)) return groupsA.map(g => (g && g.name) ? g.name : String(g)).filter(Boolean);
+      if (typeof groupsA === 'string') return groupsA.split(',').map(s => s.trim()).filter(Boolean);
+    } catch (e) {}
+    return [];
+  }
 
-      // If already present nearby, skip
-      if (rowEl.nextElementSibling && rowEl.nextElementSibling.classList && rowEl.nextElementSibling.classList.contains('ezoic-ad-wrapper')) {
-        this.insertedKeys.add(key);
-        return;
-      }
+  function parseExcludedGroupsFromCfg(cfg) {
+    const v = cfg && (cfg.excludedGroups || cfg.excludedGroupNames || cfg.excluded_groups);
+    if (!v) return [];
+    if (Array.isArray(v)) return v.map(x => (x && x.name) ? x.name : String(x)).filter(Boolean);
+    return String(v).split(',').map(s => s.trim()).filter(Boolean);
+  }
 
-      const isLi = rowEl.tagName && rowEl.tagName.toLowerCase() === 'li';
-      const wrapper = document.createElement(isLi ? 'li' : 'div');
-      wrapper.className = 'ezoic-ad-wrapper';
-      wrapper.setAttribute('role', 'presentation');
-      wrapper.setAttribute('data-ezoic-id', placeholderId);
+  function isExcludedClientSide(cfg) {
+    // Prefer server decision if present
+    if (cfg && cfg.excluded === true) return true;
 
-      // Theme compatibility: if list uses list-group-item, keep it to avoid layout/JS breaks
-      if (isLi && rowEl.classList.contains('list-group-item')) {
-        wrapper.classList.add('list-group-item');
-      }
+    // Extra safety: if cfg contains excluded group names, cross-check client-side.
+    const excludedGroups = parseExcludedGroupsFromCfg(cfg);
+    if (!excludedGroups.length) return false;
+    const userGroups = getUserGroupNamesFromAjaxify();
+    if (!userGroups.length) return false;
 
-      // Ensure placeholder exists (in pool) then move it into wrapper
-      const ph = Pool.ensurePlaceholder(placeholderId);
-      // If placeholder is currently rendered elsewhere, move it (Ezoic uses id lookup)
-      try { wrapper.appendChild(ph); } catch (e) {}
+    const set = new Set(userGroups);
+    return excludedGroups.some(g => set.has(g));
+  }
+
+  // ----------------------------
+  // Core injection
+  // ----------------------------
+  function computeTargets(count, interval, showFirst) {
+    const out = [];
+    if (count <= 0) return out;
+    if (showFirst) out.push(1);
+    for (let i = interval; i <= count; i += interval) out.push(i);
+    return Array.from(new Set(out)).sort((a, b) => a - b);
+  }
 
-      // Insert into DOM
-      rowEl.insertAdjacentElement('afterend', wrapper);
-      this.insertedKeys.add(key);
+  function injectBetween(kindClass, items, interval, showFirst, pool) {
+    if (!items.length || !pool.length) return [];
+
+    const targets = computeTargets(items.length, interval, showFirst);
+    const insertedIds = [];
+    for (const afterPos of targets) {
+      const el = items[afterPos - 1];
+      if (!el || !el.isConnected) continue;
+      if (!pool.length) break;
+      if (findWrap(kindClass, afterPos)) continue;
+
+      const id = pool.shift();
+      const wrap = insertAfter(el, id, kindClass, afterPos);
+      if (!wrap) {
+        // push back if couldn't insert
+        pool.unshift(id);
+        continue;
+      }
 
-      // Observe for preloading and request a show
-      if (this.io) this.io.observe(wrapper);
+      insertedIds.push(id);
 
-      // If above fold, request immediately (no timeout)
-      const rect = wrapper.getBoundingClientRect();
-      if (rect.top < (window.innerHeight * 1.5)) {
-        this.requestShow(placeholderId);
+      // Above-the-fold: immediate attempt
+      const rect = wrap.getBoundingClientRect ? wrap.getBoundingClientRect() : null;
+      const vh = window.innerHeight || 800;
+      if (rect && rect.top < (vh * 1.5)) {
+        showAd(id);
+      } else {
+        observePlaceholder(id);
       }
-    },
+    }
+    return insertedIds;
+  }
 
-    requestShow(placeholderId) {
-      if (!placeholderId) return;
+  function removeAllAds() {
+    try { document.querySelectorAll(`.${WRAP_CLASS}`).forEach(n => n.remove()); } catch (e) {}
+  }
 
-      const last = this.lastShowAt.get(placeholderId) || 0;
-      const t = now();
-      if ((t - last) < this.minShowIntervalMs) return;
-      this.lastShowAt.set(placeholderId, t);
+  async function runCore() {
+    state.pageKey = getPageKey();
 
-      // Ensure placeholder exists in DOM (pool or wrapper)
-      Pool.ensurePlaceholder(placeholderId);
+    patchShowAds();
 
-      // Use ez cmd queue if available
-      const doShow = () => {
-        if (!window.ezstandalone || !window.ezstandalone.showAds) return;
-        // showAds is wrapped; calling with one id is safest
-        window.ezstandalone.showAds(placeholderId);
-      };
+    const cfg = await fetchConfig();
+    if (!cfg) return;
 
-      if (window.ezstandalone && Array.isArray(window.ezstandalone.cmd)) {
-        ezCmd(doShow);
-      } else {
-        doShow();
-      }
-    },
-
-    // On navigation, return all placeholders to pool so they still exist
-    reclaimPlaceholders() {
-      const wrappers = document.querySelectorAll('.ezoic-ad-wrapper[data-ezoic-id]');
-      wrappers.forEach(w => {
-        const id = w.getAttribute('data-ezoic-id');
-        if (id) Pool.returnToPool(id);
-      });
-      // Let NodeBB wipe DOM; we do not aggressively remove nodes here.
-      this.insertedKeys.clear();
-      this.lastShowAt.clear();
+    // If excluded: ensure we remove any previously injected wrappers
+    if (isExcludedClientSide(cfg)) {
+      removeAllAds();
+      return;
+    }
+
+    const kind = getKind();
+
+    if (kind === 'topic' && normalizeBool(cfg.enableMessageAds)) {
+      const pool = parsePool(cfg.messagePlaceholderIds);
+      injectBetween(
+        'ezoic-ad-message',
+        getPostContainers(),
+        Math.max(1, parseInt(cfg.messageIntervalPosts, 10) || 3),
+        normalizeBool(cfg.showFirstMessageAd),
+        pool
+      );
+      return;
+    }
+
+    if (kind === 'categoryTopics' && normalizeBool(cfg.enableBetweenAds)) {
+      const pool = parsePool(cfg.placeholderIds);
+      injectBetween(
+        'ezoic-ad-between',
+        getTopicItems(),
+        Math.max(1, parseInt(cfg.intervalPosts, 10) || 6),
+        normalizeBool(cfg.showFirstTopicAd),
+        pool
+      );
+      return;
     }
-  };
 
-  // -------------------------
-  // NodeBB hooks
-  // -------------------------
-  function onAjaxifyStart() {
-    navToken++;
-    Ad.disconnectObservers();
-    Ad.reclaimPlaceholders();
+    if (kind === 'categories' && normalizeBool(cfg.enableCategoryAds)) {
+      const pool = parsePool(cfg.categoryPlaceholderIds);
+      injectBetween(
+        'ezoic-ad-categories',
+        getCategoryItems(),
+        Math.max(1, parseInt(cfg.intervalCategories, 10) || 4),
+        normalizeBool(cfg.showFirstCategoryAd),
+        pool
+      );
+    }
   }
 
-  function onAjaxifyEnd() {
-    // Kick scan for new page
-    prefetchConfig();
-    Ad.scheduleScan();
+  function cleanupForNav() {
+    // New token => any pending safeCmd work becomes stale
+    state.pageToken += 1;
+    state.cfg = null;
+    state.cfgPromise = null;
+    state.lastShowAt.clear();
+
+    // Disconnect observers for old DOM
+    try { if (state.io) state.io.disconnect(); } catch (e) {}
+    state.io = null;
+    try { if (state.mo) state.mo.disconnect(); } catch (e) {}
+    state.mo = null;
+
+    removeAllAds();
   }
 
-  // NodeBB exposes ajaxify events on document
-  on('ajaxify.start', onAjaxifyStart);
-  on('ajaxify.end', onAjaxifyEnd);
+  // ----------------------------
+  // Bind to NodeBB 4.x ajaxify events
+  // ----------------------------
+  function bind() {
+    if (!$) return;
 
-  // First load
-  once('DOMContentLoaded', () => {
-    installShowAdsHook();
-    prefetchConfig();
-    Ad.scheduleScan();
-  });
+    $(window).off('.ezoicInfinite');
+
+    $(window).on('action:ajaxify.start.ezoicInfinite', () => cleanupForNav());
+
+    $(window).on('action:ajaxify.end.ezoicInfinite', () => {
+      state.pageKey = getPageKey();
+      ensureMO();
+      schedule(runCore);
+    });
+
+    // Infinite scroll hooks
+    $(window).on('action:posts.loaded.ezoicInfinite', () => schedule(runCore));
+    $(window).on('action:topics.loaded.ezoicInfinite', () => schedule(runCore));
+    $(window).on('action:category.loaded.ezoicInfinite', () => schedule(runCore));
+    $(window).on('action:topic.loaded.ezoicInfinite', () => schedule(runCore));
+  }
 
-})();
+  // Boot
+  cleanupForNav();
+  bind();
+  ensureMO();
+  state.pageKey = getPageKey();
+  schedule(runCore);
+})();

package/public/style.css

@@ -4,6 +4,4 @@ span.ezoic-ad,
 span[class*="ezoic"] {
   min-height: 0 !important;
   min-width: 0 !important;
-}
-
-.ezoic-ad-wrapper{margin:0;padding:0;list-style:none;}
+}