nodebb-plugin-ezoic-infinite 1.4.89 → 1.4.91

package/package.json

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

package/public/README.md

@@ -0,0 +1,15 @@
+# NodeBB Plugin – Ezoic Infinite (Production)
+
+This plugin injects Ezoic placeholders between topics and posts on NodeBB 4.x,
+with full support for infinite scroll.
+
+## Key guarantees
+- No duplicate ads back-to-back
+- One showAds call per placeholder
+- Fast reveal (MutationObserver on first child)
+- Safe with ajaxify navigation
+- Works with NodeBB 4.x + Harmony
+
+## Notes
+- Placeholders must exist and be selected in Ezoic
+- Use separate ID pools for topics vs messages

package/public/library.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const meta = require.main.require('./src/meta');
+const groups = require.main.require('./src/groups');
+const db = require.main.require('./src/database');
+
+const SETTINGS_KEY = 'ezoic-infinite';
+const plugin = {};
+
+function normalizeExcludedGroups(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return String(value).split(',').map(s => s.trim()).filter(Boolean);
+}
+
+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);
+  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);
+  // Sort alphabetically for ACP usability
+  data.sort((a, b) => String(a.name).localeCompare(String(b.name), 'fr', { sensitivity: 'base' }));
+  return data;
+}
+async function getSettings() {
+  const s = await meta.settings.get(SETTINGS_KEY);
+  return {
+    // 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),
+  };
+}
+
+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.addAdminNavigation = async (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', middleware.buildHeader, 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;

package/public/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "nodebb-plugin-ezoic-infinite",
+  "version": "1.4.8",
+  "description": "Production-ready Ezoic infinite ads integration for NodeBB 4.x",
+  "main": "library.js",
+  "license": "MIT",
+  "keywords": [
+    "nodebb",
+    "nodebb-plugin",
+    "ezoic",
+    "ads",
+    "infinite-scroll"
+  ],
+  "engines": {
+    "nodebb": ">=4.0.0"
+  },
+  "nbbpm": {
+    "compatibility": "^4.0.0"
+  },
+  "private": false
+}

package/public/plugin.json

@@ -0,0 +1,29 @@
+{
+  "id": "nodebb-plugin-ezoic-infinite",
+  "name": "NodeBB Ezoic Infinite Ads",
+  "description": "Ezoic ads with infinite scroll using a pool of placeholder IDs",
+  "library": "./library.js",
+  "hooks": [
+    {
+      "hook": "static:app.load",
+      "method": "init"
+    },
+    {
+      "hook": "filter:admin.header.build",
+      "method": "addAdminNavigation"
+    }
+  ],
+  "staticDirs": {
+    "public": "public"
+  },
+  "acpScripts": [
+    "public/admin.js"
+  ],
+  "scripts": [
+    "public/client.js"
+  ],
+  "templates": "public/templates",
+  "css": [
+    "public/style.css"
+  ]
+}

package/public/{admin.js → public/admin.js}

@@ -13,10 +13,11 @@
         e.preventDefault();
 
         Settings.save('ezoic-infinite', $form, function () {
+          // Toast vert (NodeBB core)
           if (alerts && typeof alerts.success === 'function') {
-            alerts.success('[[admin/settings:saved]]');
+            alerts.success('Enregistré');
           } else if (window.app && typeof window.app.alertSuccess === 'function') {
-            window.app.alertSuccess('[[admin/settings:saved]]');
+            window.app.alertSuccess('Enregistré');
           }
         });
       });

package/public/public/client.js

@@ -0,0 +1,371 @@
+(function () {
+  'use strict';
+
+  const $ = (typeof window.jQuery === 'function') ? window.jQuery : null;
+
+  const SELECTORS = {
+    topicItem: 'li[component="category/topic"]',
+    postItem: '[component="post"][data-pid]',
+    categoryItem: 'li[component="categories/category"]',
+  };
+
+  const WRAP_CLASS = 'ezoic-ad';
+  const PLACEHOLDER_PREFIX = 'ezoic-pub-ad-placeholder-';
+  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(),
+    lastShowById: new Map(),
+    canShowAds: false,
+    scheduled: false,
+    timer: null,
+    obs: null,
+  };
+
+  const sessionDefinedIds = new Set();
+
+  function normalizeBool(v) {
+    return v === true || v === 'true' || v === 1 || v === '1' || v === 'on';
+  }
+
+  function uniqInts(lines) {
+    const out = [], 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;
+  }
+
+  function parsePool(raw) {
+    if (!raw) return [];
+    const lines = String(raw).split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+    return uniqInts(lines);
+  }
+
+  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 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';
+    return 'other';
+  }
+
+  function getTopicItems() {
+    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));
+  }
+
+  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;
+      }
+    })();
+
+    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;
+    const filtered = ids.filter(id => Number.isFinite(id) && id > 0);
+    if (!filtered.length) return;
+
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+      
+      const call = () => {
+        if (typeof window.ezstandalone.destroyPlaceholders === 'function') {
+          window.ezstandalone.destroyPlaceholders(filtered);
+        }
+      };
+
+      if (window.ezstandalone && typeof window.ezstandalone.destroyPlaceholders === 'function') {
+        call();
+      } else {
+        window.ezstandalone.cmd.push(call);
+      }
+
+      // Recyclage: libérer après 100ms
+      setTimeout(() => {
+        filtered.forEach(id => sessionDefinedIds.delete(id));
+      }, 100);
+    } catch (e) {}
+  }
+
+  function buildWrap(id, kindClass, afterPos) {
+    const wrap = document.createElement('div');
+    wrap.className = `${WRAP_CLASS} ${kindClass}`;
+    wrap.setAttribute('data-ezoic-after', String(afterPos));
+    wrap.style.width = '100%';
+
+    const ph = document.createElement('div');
+    ph.id = `${PLACEHOLDER_PREFIX}${id}`;
+    wrap.appendChild(ph);
+    return wrap;
+  }
+
+  function findWrap(kindClass, afterPos) {
+    return document.querySelector(`.${WRAP_CLASS}.${kindClass}[data-ezoic-after="${afterPos}"]`);
+  }
+
+  function insertAfter(target, id, kindClass, afterPos) {
+    if (!target || !target.insertAdjacentElement) return null;
+    if (findWrap(kindClass, afterPos)) return null;
+
+    try {
+      const wrap = buildWrap(id, kindClass, afterPos);
+      target.insertAdjacentElement('afterend', wrap);
+      return wrap;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  function pickId(pool) {
+    if (!pool || !pool.length) return null;
+    return pool.shift();
+  }
+
+  function callShowAds(id) {
+    if (!id) return;
+    
+    try {
+      window.ezstandalone = window.ezstandalone || {};
+      window.ezstandalone.cmd = window.ezstandalone.cmd || [];
+      
+      window.ezstandalone.cmd.push(function() {
+        if (typeof window.ezstandalone.showAds === 'function') {
+          window.ezstandalone.showAds(id);
+          sessionDefinedIds.add(id);
+        }
+      });
+    } catch (e) {}
+  }
+
+  function injectBetween(kindClass, items, interval, showFirst, pool, usedSet) {
+    if (!items || items.length === 0) return 0;
+
+    let inserted = 0;
+    const targets = [];
+
+    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);
+    }
+
+    for (const afterPos of targets) {
+      if (inserted >= MAX_INSERTS_PER_RUN) break;
+
+      const el = items[afterPos - 1];
+      if (!el || !el.isConnected) continue;
+      if (findWrap(kindClass, afterPos)) continue;
+
+      const id = pickId(pool);
+      if (!id) break;
+
+      const wrap = insertAfter(el, id, kindClass, afterPos);
+      if (!wrap) continue;
+
+      usedSet.add(id);
+      callShowAds(id);
+      inserted += 1;
+    }
+
+    return inserted;
+  }
+
+  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() {
+    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.usedTopics.clear();
+    state.usedPosts.clear();
+    state.usedCategories.clear();
+    state.lastShowById.clear();
+    sessionDefinedIds.clear();
+
+    if (state.obs) {
+      state.obs.disconnect();
+      state.obs = null;
+    }
+
+    state.scheduled = false;
+    clearTimeout(state.timer);
+    state.timer = null;
+  }
+
+  function ensureObserver() {
+    if (state.obs) return;
+    state.obs = new MutationObserver(() => scheduleRun());
+    try {
+      state.obs.observe(document.body, { childList: true, subtree: true });
+    } catch (e) {}
+  }
+
+  function waitForContentThenRun() {
+    const kind = getKind();
+    let selector = SELECTORS.postItem;
+    if (kind === 'categoryTopics') selector = SELECTORS.topicItem;
+    else if (kind === 'categories') selector = SELECTORS.categoryItem;
+
+    const check = () => {
+      if (document.querySelector(selector)) {
+        scheduleRun();
+      } else {
+        setTimeout(check, 200);
+      }
+    };
+    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();
+    });
+
+    $(window).on('action:category.loaded.ezoicInfinite', () => {
+      ensureObserver();
+      waitForContentThenRun();
+    });
+
+    $(window).on('action:topics.loaded.ezoicInfinite', () => {
+      ensureObserver();
+      waitForContentThenRun();
+    });
+  }
+
+  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

@@ -0,0 +1,11 @@
+.ezoic-ad {
+  padding: 0 !important;
+  margin: 0 !important;
+  min-height: 0 !important;
+  min-width: 0 !important;
+}
+
+.ezoic-ad * {
+  min-height: 0 !important;
+  min-width: 0 !important;
+}