domma-cms 0.15.0 → 0.17.0

package/plugins/analytics/lifetime.json

@@ -0,0 +1,25 @@
+{
+  "/": 162,
+  "/about": 88,
+  "/blog": 42,
+  "/contact": 31,
+  "/resources/typography": 4,
+  "/resources": 13,
+  "/resources/shortcodes": 14,
+  "/resources/cards": 19,
+  "/resources/interactive": 13,
+  "/resources/grid": 6,
+  "/forms": 14,
+  "/resources/effects": 6,
+  "/blog/hello-world": 28,
+  "/feedback": 42,
+  "/resources/dependencies": 2,
+  "/resources/components": 6,
+  "/gdpr": 3,
+  "/scratch": 84,
+  "/getting-started": 3,
+  "/resources/pro": 1,
+  "/todo": 23,
+  "/thank-you": 1,
+  "/test-from-controller": 1
+}

package/plugins/analytics/plugin.js

@@ -1,58 +1,462 @@
 /**
  * Analytics Plugin — Server
- * Tracks page hits in a JSON file alongside the plugin.
- * Endpoints:
- *   POST   /api/plugins/analytics/hit    - public: record a hit { url }
- *   GET    /api/plugins/analytics/stats  - admin: return all hit counts
- *   DELETE /api/plugins/analytics/stats  - admin: reset all stats
+ * Tracks page hits with per-day buckets so we can chart trends and
+ * filter by time range.
+ *
+ * Storage:
+ *   lifetime.json  { "/url": totalHits }
+ *   daily.json     { "YYYY-MM-DD": { "/url": hits } }
+ *
+ * Endpoints (mounted at /api/plugins/analytics):
+ *   POST   /hit            public  record a hit { url, dnt }
+ *   GET    /stats          admin   summary + top pages (?range=today|7d|30d|90d|all|custom&from=&to=)
+ *   GET    /series         admin   per-day totals series (?days=N or ?from=&to=)
+ *   GET    /export.csv     admin   CSV export of top pages for the active range
+ *   DELETE /stats          admin   reset all stats
  */
 import fs from 'fs/promises';
 import path from 'path';
 import {fileURLToPath} from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const STATS_FILE = path.join(__dirname, 'stats.json');
+const LIFETIME_FILE = path.join(__dirname, 'lifetime.json');
+const DAILY_FILE = path.join(__dirname, 'daily.json');
+const LEGACY_FILE = path.join(__dirname, 'stats.json');
+const JOURNEYS_FILE = path.join(__dirname, 'journeys.json');
+const JOURNEY_DAILY_CAP = 5000;
+const REALTIME_WINDOW_MS = 5 * 60 * 1000;
 
-async function readStats() {
+async function readJson(file, fallback) {
     try {
-        return JSON.parse(await fs.readFile(STATS_FILE, 'utf8'));
+        return JSON.parse(await fs.readFile(file, 'utf8'));
     } catch {
-        return {};
+        return fallback;
     }
 }
 
-async function writeStats(stats) {
-    await fs.writeFile(STATS_FILE, JSON.stringify(stats, null, 2) + '\n', 'utf8');
+async function writeJson(file, data) {
+    const tmp = file + '.tmp';
+    await fs.writeFile(tmp, JSON.stringify(data, null, 2) + '\n', 'utf8');
+    await fs.rename(tmp, file);
+}
+
+/**
+ * One-shot migration from the legacy flat stats.json.
+ * Preserves existing totals as lifetime numbers; daily history starts empty.
+ * Also seeds journeys.json if missing.
+ */
+async function migrateLegacy() {
+    let lifetimeExists = false;
+    try {
+        await fs.access(LIFETIME_FILE);
+        lifetimeExists = true;
+    } catch { /* not migrated */ }
+
+    if (!lifetimeExists) {
+        const legacy = await readJson(LEGACY_FILE, null);
+        if (legacy && typeof legacy === 'object') {
+            await writeJson(LIFETIME_FILE, legacy);
+        } else {
+            await writeJson(LIFETIME_FILE, {});
+        }
+        await writeJson(DAILY_FILE, {});
+    }
+
+    try {
+        await fs.access(JOURNEYS_FILE);
+    } catch {
+        await writeJson(JOURNEYS_FILE, {});
+    }
+}
+
+function todayKey(date = new Date()) {
+    return date.toISOString().slice(0, 10);
+}
+
+function rangeToDates(range, from, to) {
+    const today = new Date();
+    today.setUTCHours(0, 0, 0, 0);
+    const end = to ? new Date(to + 'T00:00:00Z') : today;
+    let start;
+    switch (range) {
+        case 'today':
+            start = today;
+            break;
+        case '7d':
+            start = new Date(today);
+            start.setUTCDate(start.getUTCDate() - 6);
+            break;
+        case '30d':
+            start = new Date(today);
+            start.setUTCDate(start.getUTCDate() - 29);
+            break;
+        case '90d':
+            start = new Date(today);
+            start.setUTCDate(start.getUTCDate() - 89);
+            break;
+        case 'custom':
+            start = from ? new Date(from + 'T00:00:00Z') : today;
+            break;
+        case 'all':
+        default:
+            return null; // all-time → use lifetime aggregate
+    }
+    return { start, end };
+}
+
+function aggregateDaily(daily, start, end) {
+    const totals = {};
+    let total = 0;
+    const startMs = start.getTime();
+    const endMs = end.getTime();
+    for (const [day, urls] of Object.entries(daily)) {
+        const dayMs = new Date(day + 'T00:00:00Z').getTime();
+        if (dayMs < startMs || dayMs > endMs) continue;
+        for (const [url, hits] of Object.entries(urls)) {
+            totals[url] = (totals[url] || 0) + hits;
+            total += hits;
+        }
+    }
+    return { totals, total };
+}
+
+function buildSeries(daily, start, end) {
+    const series = [];
+    const cursor = new Date(start);
+    while (cursor.getTime() <= end.getTime()) {
+        const key = todayKey(cursor);
+        const day = daily[key] || {};
+        const hits = Object.values(day).reduce((acc, n) => acc + n, 0);
+        series.push({ date: key, hits });
+        cursor.setUTCDate(cursor.getUTCDate() + 1);
+    }
+    return series;
+}
+
+function escapeCsvCell(value) {
+    const str = String(value ?? '');
+    if (/[",\n\r]/.test(str)) {
+        return '"' + str.replace(/"/g, '""') + '"';
+    }
+    return str;
+}
+
+function eventsInRange(journeys, start, end) {
+    const startMs = start.getTime();
+    const endMs = end.getTime();
+    const out = [];
+    for (const [day, events] of Object.entries(journeys)) {
+        const dayMs = new Date(day + 'T00:00:00Z').getTime();
+        if (dayMs < startMs || dayMs > endMs) continue;
+        for (const ev of events) out.push(ev);
+    }
+    return out;
+}
+
+function groupBySession(events) {
+    const sessions = new Map();
+    for (const ev of events) {
+        if (!sessions.has(ev.sid)) sessions.set(ev.sid, []);
+        sessions.get(ev.sid).push(ev);
+    }
+    for (const arr of sessions.values()) arr.sort((a, b) => a.t - b.t);
+    return sessions;
+}
+
+function aggregateJourneys(events) {
+    const sessions = groupBySession(events);
+    const entry = new Map();
+    const exit = new Map();
+    const paths = new Map(); // key: '\x00'-joined, value: { from, to, count }
+    let bouncedSessions = 0;
+
+    for (const arr of sessions.values()) {
+        if (arr.length === 0) continue;
+        entry.set(arr[0].url, (entry.get(arr[0].url) || 0) + 1);
+        exit.set(arr[arr.length - 1].url, (exit.get(arr[arr.length - 1].url) || 0) + 1);
+        if (arr.length === 1) bouncedSessions += 1;
+        for (let i = 0; i < arr.length - 1; i += 1) {
+            const from = arr[i].url;
+            const to = arr[i + 1].url;
+            const key = from + '\x00' + to; // NUL is invalid in URL pathnames, so unambiguous
+            const existing = paths.get(key);
+            if (existing) {
+                existing.count += 1;
+            } else {
+                paths.set(key, { from, to, count: 1 });
+            }
+        }
+    }
+
+    const toSorted = (m) => Array.from(m.entries())
+        .map(([url, count]) => ({ url, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 10);
+
+    const pathsSorted = Array.from(paths.values())
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 10);
+
+    const totalSessions = sessions.size;
+    return {
+        entry: toSorted(entry),
+        exit: toSorted(exit),
+        paths: pathsSorted,
+        bounceRate: totalSessions === 0 ? 0 : +(bouncedSessions / totalSessions).toFixed(3),
+        totalSessions
+    };
+}
+
+function detectSpikes(daily, now = new Date()) {
+    const todayStr = todayKey(now);
+    const currentHour = now.getUTCHours();
+
+    // Approximation: distribute today's hits evenly across elapsed hours.
+    const todayUrls = daily[todayStr] || {};
+    const elapsedHours = Math.max(1, currentHour + 1);
+
+    const flagged = [];
+    for (const [url, totalToday] of Object.entries(todayUrls)) {
+        const currentHits = totalToday / elapsedHours;
+
+        // Baseline: previous 7 days' same-hour share (assume 24-hour spread)
+        const samples = [];
+        for (let i = 1; i <= 7; i += 1) {
+            const prev = new Date(now);
+            prev.setUTCDate(prev.getUTCDate() - i);
+            const key = todayKey(prev);
+            const sample = (daily[key] && daily[key][url]) ? daily[key][url] / 24 : 0;
+            samples.push(sample);
+        }
+        const mean = samples.reduce((a, b) => a + b, 0) / samples.length;
+        const variance = samples.reduce((acc, x) => acc + (x - mean) * (x - mean), 0) / samples.length;
+        const stddev = Math.sqrt(variance);
+
+        if (currentHits >= 5 && currentHits > mean + 2 * stddev && mean > 0) {
+            flagged.push({
+                url,
+                hits: Math.round(currentHits),
+                baseline: Math.round(mean),
+                ratio: +(currentHits / Math.max(mean, 0.5)).toFixed(2)
+            });
+        }
+    }
+
+    return flagged.sort((a, b) => b.ratio - a.ratio).slice(0, 5);
+}
+
+function shouldRecordJourney(dayEntries, cap = JOURNEY_DAILY_CAP) {
+    return Array.isArray(dayEntries) && dayEntries.length < cap;
 }
 
 export default async function analyticsPlugin(fastify, options) {
-  const {authenticate, requireAdmin} = options.auth;
+    const { authenticate, requireAdmin } = options.auth;
+    const settings = options.settings || {};
+
+    await migrateLegacy();
+
+    fastify.decorate('analytics', {
+        async getStats({ range = '7d', from, to } = {}) {
+            const dates = rangeToDates(range, from, to);
+            const [lifetime, daily] = await Promise.all([
+                readJson(LIFETIME_FILE, {}),
+                readJson(DAILY_FILE, {})
+            ]);
+            let totals; let total;
+            if (!dates) {
+                totals = lifetime;
+                total = Object.values(lifetime).reduce((a, n) => a + n, 0);
+            } else {
+                const agg = aggregateDaily(daily, dates.start, dates.end);
+                totals = agg.totals;
+                total = agg.total;
+            }
+            const top = Object.entries(totals)
+                .map(([url, hits]) => ({ url, hits }))
+                .sort((a, b) => b.hits - a.hits);
+            return { total, top, lifetimeTotal: Object.values(lifetime).reduce((a, n) => a + n, 0) };
+        },
+        async getDaily() { return readJson(DAILY_FILE, {}); },
+        async getJourneys({ range = '7d', from, to } = {}) {
+            const dates = rangeToDates(range === 'all' ? '30d' : range, from, to);
+            const journeys = await readJson(JOURNEYS_FILE, {});
+            return aggregateJourneys(eventsInRange(journeys, dates.start, dates.end));
+        },
+        async getRealtime() {
+            const journeys = await readJson(JOURNEYS_FILE, {});
+            const today = todayKey();
+            const events = journeys[today] || [];
+            const cutoff = Date.now() - REALTIME_WINDOW_MS;
+            const sids = new Set();
+            for (const ev of events) if (ev.t >= cutoff) sids.add(ev.sid);
+            return { activeSessions: sids.size, windowMinutes: REALTIME_WINDOW_MS / 60000 };
+        },
+        async getSpikes() {
+            const daily = await readJson(DAILY_FILE, {});
+            return { items: detectSpikes(daily) };
+        }
+    });
 
-  // Record a page hit — called by the client-side injection script (public)
     fastify.post('/hit', async (request, reply) => {
-        const { url } = request.body || {};
+        const { url, dnt, sid, ref } = request.body || {};
         if (!url || typeof url !== 'string') {
             return reply.status(400).send({ error: 'url is required' });
         }
+        if (dnt === true || dnt === '1') {
+            return { ok: true, ignored: 'dnt' };
+        }
+
+        const normalised = url.split('?')[0].split('#')[0].replace(/\/+$/, '') || '/';
+        if (settings.excludeAdmin && normalised.startsWith('/admin')) {
+            return { ok: true, ignored: 'admin' };
+        }
+        if (Array.isArray(settings.excludePaths)) {
+            for (const prefix of settings.excludePaths) {
+                if (typeof prefix === 'string' && prefix && normalised.startsWith(prefix)) {
+                    return { ok: true, ignored: 'excluded' };
+                }
+            }
+        }
 
-        const normalised = url.split('?')[0].replace(/\/$/, '') || '/';
-        const stats = await readStats();
-        stats[normalised] = (stats[normalised] || 0) + 1;
-        await writeStats(stats);
+        const today = todayKey();
+        const [lifetime, daily, journeys] = await Promise.all([
+            readJson(LIFETIME_FILE, {}),
+            readJson(DAILY_FILE, {}),
+            readJson(JOURNEYS_FILE, {})
+        ]);
+
+        lifetime[normalised] = (lifetime[normalised] || 0) + 1;
+        if (!daily[today]) daily[today] = {};
+        daily[today][normalised] = (daily[today][normalised] || 0) + 1;
+
+        // Journey event — only if sid is a string of reasonable shape, and under cap
+        const safeSid = typeof sid === 'string' && sid.length > 0 && sid.length <= 64 ? sid : null;
+        const safeRef = typeof ref === 'string' && ref.length <= 512 ? ref : '';
+        if (safeSid) {
+            if (!journeys[today]) journeys[today] = [];
+            if (shouldRecordJourney(journeys[today])) {
+                journeys[today].push({ sid: safeSid, t: Date.now(), url: normalised, ref: safeRef });
+            }
+        }
+
+        await Promise.all([
+            writeJson(LIFETIME_FILE, lifetime),
+            writeJson(DAILY_FILE, daily),
+            writeJson(JOURNEYS_FILE, journeys)
+        ]);
         return { ok: true };
     });
 
-  // Return all stats — admin only
-  fastify.get('/stats', {preHandler: [authenticate, requireAdmin]}, async () => {
-        const stats = await readStats();
-        return Object.entries(stats)
+    fastify.get('/stats', { preHandler: [authenticate, requireAdmin] }, async (request) => {
+        const { range = '30d', from, to } = request.query || {};
+        const dates = rangeToDates(range, from, to);
+        const [lifetime, daily] = await Promise.all([
+            readJson(LIFETIME_FILE, {}),
+            readJson(DAILY_FILE, {})
+        ]);
+
+        let totals;
+        let total;
+        if (!dates) {
+            totals = lifetime;
+            total = Object.values(lifetime).reduce((acc, n) => acc + n, 0);
+        } else {
+            const agg = aggregateDaily(daily, dates.start, dates.end);
+            totals = agg.totals;
+            total = agg.total;
+        }
+
+        const top = Object.entries(totals)
             .map(([url, hits]) => ({ url, hits }))
             .sort((a, b) => b.hits - a.hits);
+
+        const lifetimeTotal = Object.values(lifetime).reduce((acc, n) => acc + n, 0);
+        return {
+            range,
+            from: dates ? todayKey(dates.start) : null,
+            to: dates ? todayKey(dates.end) : null,
+            total,
+            lifetimeTotal,
+            uniquePages: top.length,
+            top
+        };
     });
 
-  // Reset stats — admin only
-  fastify.delete('/stats', {preHandler: [authenticate, requireAdmin]}, async () => {
-        await writeStats({});
+    fastify.get('/series', { preHandler: [authenticate, requireAdmin] }, async (request) => {
+        const { range = '30d', from, to } = request.query || {};
+        const dates = rangeToDates(range === 'all' ? '30d' : range, from, to);
+        const daily = await readJson(DAILY_FILE, {});
+        return { series: buildSeries(daily, dates.start, dates.end) };
+    });
+
+    fastify.get('/journeys', { preHandler: [authenticate, requireAdmin] }, async (request) => {
+        const { range = '7d', from, to } = request.query || {};
+        const dates = rangeToDates(range === 'all' ? '30d' : range, from, to);
+        const journeys = await readJson(JOURNEYS_FILE, {});
+        const events = eventsInRange(journeys, dates.start, dates.end);
+        const agg = aggregateJourneys(events);
+        return {
+            range,
+            from: todayKey(dates.start),
+            to: todayKey(dates.end),
+            ...agg
+        };
+    });
+
+    fastify.get('/realtime', { preHandler: [authenticate, requireAdmin] }, async () => {
+        const journeys = await readJson(JOURNEYS_FILE, {});
+        const today = todayKey();
+        const events = journeys[today] || [];
+        const cutoff = Date.now() - REALTIME_WINDOW_MS;
+        const sids = new Set();
+        for (const ev of events) {
+            if (ev.t >= cutoff) sids.add(ev.sid);
+        }
+        return { activeSessions: sids.size, windowMinutes: REALTIME_WINDOW_MS / 60000 };
+    });
+
+    fastify.get('/spikes', { preHandler: [authenticate, requireAdmin] }, async () => {
+        const daily = await readJson(DAILY_FILE, {});
+        return { items: detectSpikes(daily) };
+    });
+
+    fastify.get('/export.csv', { preHandler: [authenticate, requireAdmin] }, async (request, reply) => {
+        const { range = '30d', from, to } = request.query || {};
+        const dates = rangeToDates(range, from, to);
+        const [lifetime, daily] = await Promise.all([
+            readJson(LIFETIME_FILE, {}),
+            readJson(DAILY_FILE, {})
+        ]);
+        const totals = dates ? aggregateDaily(daily, dates.start, dates.end).totals : lifetime;
+        const rows = Object.entries(totals)
+            .map(([url, hits]) => ({ url, hits }))
+            .sort((a, b) => b.hits - a.hits);
+
+        const lines = ['url,hits'];
+        for (const row of rows) {
+            lines.push(`${escapeCsvCell(row.url)},${row.hits}`);
+        }
+        const filename = `analytics-${range}-${new Date().toISOString().slice(0, 10)}.csv`;
+        reply
+            .header('Content-Type', 'text/csv; charset=utf-8')
+            .header('Content-Disposition', `attachment; filename="${filename}"`);
+        return lines.join('\n') + '\n';
+    });
+
+    fastify.delete('/stats', { preHandler: [authenticate, requireAdmin] }, async () => {
+        await Promise.all([
+            writeJson(LIFETIME_FILE, {}),
+            writeJson(DAILY_FILE, {}),
+            writeJson(JOURNEYS_FILE, {})
+        ]);
+        try {
+            await fs.unlink(LEGACY_FILE);
+        } catch {
+            // ignore
+        }
         return { ok: true };
     });
 }
+
+export { aggregateJourneys, detectSpikes, shouldRecordJourney };
+

package/plugins/analytics/plugin.json

@@ -1,10 +1,10 @@
 {
   "name": "analytics",
   "displayName": "Analytics",
-  "version": "1.0.0",
-  "description": "Basic page view analytics. Tracks hits per page using a simple JSON store.",
+  "version": "2.0.0",
+  "description": "Page view analytics with daily trends, time-range filtering, top-pages table and CSV export. Honours Do-Not-Track and dedups per session.",
   "author": "Darryl Waterhouse",
-  "date": "2026-03-01",
+  "date": "2026-05-04",
   "icon": "chart-bar",
   "admin": {
     "sidebar": [
@@ -25,7 +25,7 @@
     ],
     "views": {
       "plugin-analytics": {
-        "entry": "analytics/admin/views/analytics.js?v=80339cdc",
+        "entry": "analytics/admin/views/analytics.js?v=2c26480d",
         "exportName": "analyticsView"
       }
     }
@@ -37,7 +37,11 @@
   "scaffold": {
     "reset": [
       {
-        "path": "stats.json",
+        "path": "lifetime.json",
+        "content": "{}"
+      },
+      {
+        "path": "daily.json",
         "content": "{}"
       }
     ]

package/plugins/analytics/public/inject-body.html

@@ -1,13 +1,55 @@
-<!-- analytics: page view tracker -->
+<!-- analytics: page view tracker (DNT-aware, session-deduped) -->
 <script>
 (function () {
+    if (typeof fetch !== 'function') return;
+
+    var dnt = navigator.doNotTrack === '1'
+        || window.doNotTrack === '1'
+        || navigator.msDoNotTrack === '1';
+    if (dnt) return;
+
     var url = window.location.pathname;
-    if (typeof fetch === 'function') {
-        fetch('/api/plugins/analytics/hit', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ url: url })
-        }).catch(function () { /* silent fail */ });
+
+    // Session-scoped anonymous ID — clears with the tab. Cookie-less.
+    var sid = '';
+    try {
+        sid = sessionStorage.getItem('dm_sid') || '';
+        if (!sid) {
+            sid = (crypto && crypto.randomUUID)
+                ? crypto.randomUUID()
+                : (Date.now().toString(36) + Math.random().toString(36).slice(2, 10));
+            sessionStorage.setItem('dm_sid', sid);
+        }
+    } catch (e) {
+        // sessionStorage unavailable — proceed without sid
     }
+
+    // Session dedup (one hit per URL per session)
+    try {
+        var key = 'dm_analytics_seen';
+        var seen = sessionStorage.getItem(key);
+        var list = seen ? seen.split('|') : [];
+        if (list.indexOf(url) !== -1) return;
+        list.push(url);
+        sessionStorage.setItem(key, list.join('|'));
+    } catch (e) {
+        // proceed anyway
+    }
+
+    // Strip query/fragment from referrer; only keep same-origin or external origin+path
+    var ref = '';
+    try {
+        if (document.referrer) {
+            var r = new URL(document.referrer);
+            ref = r.origin === window.location.origin ? r.pathname : (r.origin + r.pathname);
+        }
+    } catch (e) { /* ignore */ }
+
+    fetch('/api/plugins/analytics/hit', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        keepalive: true,
+        body: JSON.stringify({ url: url, sid: sid, ref: ref })
+    }).catch(function () { /* silent */ });
 })();
 </script>

package/plugins/blog/admin/templates/blog.html

@@ -1,10 +1,29 @@
 <div class="view-header d-flex align-items-center justify-content-between mb-4">
-  <h1 class="h3 mb-0">Blog Posts</h1>
+  <h1 class="h3 mb-0"><span data-icon="file-text"></span> Blog Posts</h1>
   <button id="btn-new-post" class="btn btn-primary">
     <span data-icon="plus"></span> New Post
   </button>
 </div>
 
+<div class="grid grid-cols-4 gap-3 mb-4">
+  <div class="card"><div class="card-body">
+    <div class="text-muted small">Total</div>
+    <div class="h3 mb-0" id="kpi-total">—</div>
+  </div></div>
+  <div class="card"><div class="card-body">
+    <div class="text-muted small">Published</div>
+    <div class="h3 mb-0" id="kpi-published">—</div>
+  </div></div>
+  <div class="card"><div class="card-body">
+    <div class="text-muted small">Drafts</div>
+    <div class="h3 mb-0" id="kpi-drafts">—</div>
+  </div></div>
+  <div class="card"><div class="card-body">
+    <div class="text-muted small">Scheduled</div>
+    <div class="h3 mb-0" id="kpi-scheduled">—</div>
+  </div></div>
+</div>
+
 <div class="card mb-3">
   <div class="card-body">
     <div class="d-flex gap-2 flex-wrap">
@@ -14,7 +33,11 @@
         <option value="scheduled">Scheduled</option>
         <option value="published">Published</option>
       </select>
-      <input id="filter-search" type="text" class="form-control" style="width:200px;" placeholder="Search posts…">
+      <select id="filter-category" class="form-select" style="width:auto;">
+        <option value="">All categories</option>
+      </select>
+      <input id="filter-search" type="text" class="form-control" style="width:240px;" placeholder="Search title or excerpt…">
+      <button id="filter-reset" class="btn btn-ghost btn-sm">Reset</button>
     </div>
   </div>
 </div>