node-red-dashboard-2-hmi 0.1.10 → 0.1.11

package/nodes/alarms.js

@@ -1,177 +1,177 @@
-'use strict'
-
-// Alarm list for one canvas (ISA-18.2 style): every alarm the symbols can show
-// (fault key, limits, alarm banners, tripped breakers) is tracked with its
-// activation time and acknowledgement. An alarm leaves the active list only when
-// it is back to normal AND acknowledged; every change goes to the history.
-
-const HISTORY_MAX = 500
-
-const num = v => (v === '' || v === undefined || v === null || typeof v === 'boolean' || !isFinite(Number(v))) ? null : Number(v)
-
-function isOn (value, rule, threshold) {
-    if (value === undefined || value === null || value === '') return null
-    if (rule === 'gt') return Number(value) > Number(threshold)
-    if (typeof value === 'boolean') return value
-    if (typeof value === 'string' && isNaN(Number(value))) return value.length > 0
-    return Number(value) !== 0
-}
-
-function onState (value, p) {
-    const on = isOn(value, p && p.onWhen, p && p.threshold)
-    return on !== null && p && p.invert === 'yes' ? !on : on
-}
-
-// same as scaleValue in ui/symbols: raw × factor ÷ divisor + offset
-function scaled (sym, raw) {
-    const sc = sym.scale
-    const n = num(raw)
-    if (n === null || !sc) return n
-    const k = num(sc.factor)
-    const d = num(sc.divisor)
-    const o = num(sc.offset)
-    return Math.round((n * (k === null ? 1 : k) / (d === null || d === 0 ? 1 : d) + (o === null ? 0 : o)) * 1e9) / 1e9
-}
-
-function nameOf (sym) {
-    const p = sym.props || {}
-    return String(p.label || p.title || p.text || sym.key || sym.type)
-}
-
-const RANGE_TYPES = ['tank', 'gauge', 'bar', 'tag', 'bagFilter', 'oven', 'flowmeter', 'instrument', 'scale', 'isaBar']
-
-// Every alarm the canvas can raise: { id, symbolId, text, priority, active(values) }
-function alarmDefs (symbols) {
-    const out = []
-    for (const s of Array.isArray(symbols) ? symbols : []) {
-        if (!s || typeof s !== 'object') continue
-        const p = s.props || {}
-        if (p.alarmList === 'no') continue
-        const name = nameOf(s)
-        const prio = String(p.priority || '2')
-        if (p.faultKey) {
-            out.push({ id: s.id + ':fault', symbolId: s.id, text: name + ' em falha', priority: String(p.priority || '1'), active: v => isOn(v[p.faultKey], 'nonzero') === true })
-        }
-        if (s.type === 'breaker' && p.tripKey) {
-            out.push({ id: s.id + ':trip', symbolId: s.id, text: name + ' disparado', priority: String(p.priority || '1'), active: v => isOn(v[p.tripKey], 'nonzero') === true })
-        }
-        if (s.type === 'alarm' && s.key) {
-            out.push({ id: s.id + ':on', symbolId: s.id, text: String(p.text || name), priority: String(p.priority || '1'), active: v => onState(v[s.key], p) === true })
-        }
-        if (s.key && RANGE_TYPES.includes(s.type)) {
-            const val = v => scaled(s, v[s.key])
-            const lim = (k, label, pr, test) => {
-                const l = num(p[k])
-                if (l !== null) out.push({ id: s.id + ':' + k, symbolId: s.id, text: name + ' ' + label, priority: pr, active: v => { const x = val(v); return x !== null && test(x, l) } })
-            }
-            if (s.type === 'isaBar') {
-                lim('lolo', 'muito baixo', '1', (x, l) => x < l)
-                lim('lo', 'baixo', prio, (x, l) => x < l && !(num(p.lolo) !== null && x < num(p.lolo)))
-                lim('hi', 'alto', prio, (x, l) => x > l && !(num(p.hihi) !== null && x > num(p.hihi)))
-                lim('hihi', 'muito alto', '1', (x, l) => x > l)
-            } else {
-                lim('lo', 'baixo', prio, (x, l) => x < l)
-                lim('hi', 'alto', prio, (x, l) => x > l)
-            }
-        }
-    }
-    return out
-}
-
-function createAlarms (symbols, saved) {
-    const defs = alarmDefs(symbols)
-    const known = new Set(defs.map(d => d.id))
-    const byId = new Map(defs.map(d => [d.id, d]))
-    // shelved (suppressed) alarms: id -> { id, symbolId, text, priority, until, by }
-    const shelved = new Map()
-    // id -> { id, symbolId, text, priority, active, acked, since, cleared, ackBy }
-    const list = new Map()
-    let history = []
-    if (saved && typeof saved === 'object') {
-        // text and priority follow the symbol as it is now (renamed after a deploy)
-        const fresh = a => ({ ...a, text: byId.get(a.id).text, priority: byId.get(a.id).priority })
-        for (const a of Array.isArray(saved.active) ? saved.active : []) if (a && known.has(a.id)) list.set(a.id, fresh(a))
-        if (Array.isArray(saved.history)) history = saved.history.slice(0, HISTORY_MAX)
-        for (const sh of Array.isArray(saved.shelved) ? saved.shelved : []) if (sh && known.has(sh.id)) shelved.set(sh.id, fresh(sh))
-    }
-    // goes up on every history row, so pages only get the history when it changed
-    let version = 0
-    const log = (a, event, now, user) => {
-        version++
-        history.unshift({ ts: now, id: a.id, symbolId: a.symbolId, text: a.text, priority: a.priority, event, ...(user ? { user } : {}) })
-        if (history.length > HISTORY_MAX) history.length = HISTORY_MAX
-        return { event, id: a.id, symbolId: a.symbolId, text: a.text, priority: a.priority, ts: now, ...(user ? { user } : {}) }
-    }
-
-    return {
-        count: defs.length,
-        get version () { return version },
-        has (id) { return byId.has(id) },
-        // checks every alarm against the values; returns the events (ATIVO, NORMAL)
-        evaluate (values, now) {
-            const events = []
-            for (const d of defs) {
-                let on
-                try { on = d.active(values || {}) } catch (e) { on = false }
-                const cur = list.get(d.id)
-                if (on && (!cur || !cur.active)) {
-                    const a = { id: d.id, symbolId: d.symbolId, text: d.text, priority: d.priority, active: true, acked: false, since: now }
-                    list.set(d.id, a)
-                    events.push(log(a, 'ATIVO', now))
-                } else if (!on && cur && cur.active) {
-                    cur.active = false
-                    cur.cleared = now
-                    events.push(log(cur, 'NORMAL', now))
-                    if (cur.acked) list.delete(d.id)
-                }
-            }
-            return events
-        },
-        // acknowledges one alarm (by id), all alarms of a symbol (symbol:<id>) or every alarm ('all')
-        ack (which, now, user) {
-            const events = []
-            for (const a of [...list.values()]) {
-                // "all" is what the operator sees: shelved alarms are not in it
-                const match = (which === 'all' && !shelved.has(a.id)) || a.id === which || (typeof which === 'string' && which.startsWith('symbol:') && a.symbolId === which.slice(7))
-                if (!match || a.acked) continue
-                a.acked = true
-                a.ackTs = now
-                if (user) a.ackBy = user
-                events.push(log(a, 'RECONHECIDO', now, user))
-                if (!a.active) list.delete(a.id)
-            }
-            return events
-        },
-        // suppresses an alarm for some minutes (ISA-18.2 shelving): it leaves the list and the counters
-        shelve (id, minutes, now, user) {
-            const d = byId.get(id)
-            if (!d) return []
-            const min = Math.max(1, Math.min(1440, Number(minutes) || 30))
-            const sh = { id, symbolId: d.symbolId, text: d.text, priority: d.priority, until: now + min * 60000, ...(user ? { by: user } : {}) }
-            shelved.set(id, sh)
-            return [log(sh, 'SUPRIMIDO', now, user)]
-        },
-        unshelve (id, now, user) {
-            const sh = shelved.get(id)
-            if (!sh) return []
-            shelved.delete(id)
-            return [log(sh, 'LIBERADO', now, user)]
-        },
-        // shelved alarms whose time is over come back
-        expire (now) {
-            const events = []
-            for (const sh of [...shelved.values()]) if (sh.until <= now) events.push(...this.unshelve(sh.id, now, ''))
-            return events
-        },
-        snapshot (historyRows) {
-            const order = { 1: 0, 2: 1, 3: 2 }
-            const active = [...list.values()].filter(a => !shelved.has(a.id)).sort((a, b) => (a.acked - b.acked) || ((order[a.priority] ?? 3) - (order[b.priority] ?? 3)) || (b.since - a.since))
-            return { active, history: history.slice(0, historyRows === undefined ? 100 : historyRows), unacked: active.filter(a => !a.acked).length, shelved: [...shelved.values()].sort((a, b) => a.until - b.until) }
-        },
-        save () {
-            return { active: [...list.values()], history, shelved: [...shelved.values()] }
-        }
-    }
-}
-
-module.exports = { alarmDefs, createAlarms, onState }
+'use strict'
+
+// Alarm list for one canvas (ISA-18.2 style): every alarm the symbols can show
+// (fault key, limits, alarm banners, tripped breakers) is tracked with its
+// activation time and acknowledgement. An alarm leaves the active list only when
+// it is back to normal AND acknowledged; every change goes to the history.
+
+const HISTORY_MAX = 500
+
+const num = v => (v === '' || v === undefined || v === null || typeof v === 'boolean' || !isFinite(Number(v))) ? null : Number(v)
+
+function isOn (value, rule, threshold) {
+    if (value === undefined || value === null || value === '') return null
+    if (rule === 'gt') return Number(value) > Number(threshold)
+    if (typeof value === 'boolean') return value
+    if (typeof value === 'string' && isNaN(Number(value))) return value.length > 0
+    return Number(value) !== 0
+}
+
+function onState (value, p) {
+    const on = isOn(value, p && p.onWhen, p && p.threshold)
+    return on !== null && p && p.invert === 'yes' ? !on : on
+}
+
+// same as scaleValue in ui/symbols: raw × factor ÷ divisor + offset
+function scaled (sym, raw) {
+    const sc = sym.scale
+    const n = num(raw)
+    if (n === null || !sc) return n
+    const k = num(sc.factor)
+    const d = num(sc.divisor)
+    const o = num(sc.offset)
+    return Math.round((n * (k === null ? 1 : k) / (d === null || d === 0 ? 1 : d) + (o === null ? 0 : o)) * 1e9) / 1e9
+}
+
+function nameOf (sym) {
+    const p = sym.props || {}
+    return String(p.label || p.title || p.text || sym.key || sym.type)
+}
+
+const RANGE_TYPES = ['tank', 'gauge', 'bar', 'tag', 'bagFilter', 'oven', 'flowmeter', 'instrument', 'scale', 'isaBar']
+
+// Every alarm the canvas can raise: { id, symbolId, text, priority, active(values) }
+function alarmDefs (symbols) {
+    const out = []
+    for (const s of Array.isArray(symbols) ? symbols : []) {
+        if (!s || typeof s !== 'object') continue
+        const p = s.props || {}
+        if (p.alarmList === 'no') continue
+        const name = nameOf(s)
+        const prio = String(p.priority || '2')
+        if (p.faultKey) {
+            out.push({ id: s.id + ':fault', symbolId: s.id, text: name + ' em falha', priority: String(p.priority || '1'), active: v => isOn(v[p.faultKey], 'nonzero') === true })
+        }
+        if (s.type === 'breaker' && p.tripKey) {
+            out.push({ id: s.id + ':trip', symbolId: s.id, text: name + ' disparado', priority: String(p.priority || '1'), active: v => isOn(v[p.tripKey], 'nonzero') === true })
+        }
+        if (s.type === 'alarm' && s.key) {
+            out.push({ id: s.id + ':on', symbolId: s.id, text: String(p.text || name), priority: String(p.priority || '1'), active: v => onState(v[s.key], p) === true })
+        }
+        if (s.key && RANGE_TYPES.includes(s.type)) {
+            const val = v => scaled(s, v[s.key])
+            const lim = (k, label, pr, test) => {
+                const l = num(p[k])
+                if (l !== null) out.push({ id: s.id + ':' + k, symbolId: s.id, text: name + ' ' + label, priority: pr, active: v => { const x = val(v); return x !== null && test(x, l) } })
+            }
+            if (s.type === 'isaBar') {
+                lim('lolo', 'muito baixo', '1', (x, l) => x < l)
+                lim('lo', 'baixo', prio, (x, l) => x < l && !(num(p.lolo) !== null && x < num(p.lolo)))
+                lim('hi', 'alto', prio, (x, l) => x > l && !(num(p.hihi) !== null && x > num(p.hihi)))
+                lim('hihi', 'muito alto', '1', (x, l) => x > l)
+            } else {
+                lim('lo', 'baixo', prio, (x, l) => x < l)
+                lim('hi', 'alto', prio, (x, l) => x > l)
+            }
+        }
+    }
+    return out
+}
+
+function createAlarms (symbols, saved) {
+    const defs = alarmDefs(symbols)
+    const known = new Set(defs.map(d => d.id))
+    const byId = new Map(defs.map(d => [d.id, d]))
+    // shelved (suppressed) alarms: id -> { id, symbolId, text, priority, until, by }
+    const shelved = new Map()
+    // id -> { id, symbolId, text, priority, active, acked, since, cleared, ackBy }
+    const list = new Map()
+    let history = []
+    if (saved && typeof saved === 'object') {
+        // text and priority follow the symbol as it is now (renamed after a deploy)
+        const fresh = a => ({ ...a, text: byId.get(a.id).text, priority: byId.get(a.id).priority })
+        for (const a of Array.isArray(saved.active) ? saved.active : []) if (a && known.has(a.id)) list.set(a.id, fresh(a))
+        if (Array.isArray(saved.history)) history = saved.history.slice(0, HISTORY_MAX)
+        for (const sh of Array.isArray(saved.shelved) ? saved.shelved : []) if (sh && known.has(sh.id)) shelved.set(sh.id, fresh(sh))
+    }
+    // goes up on every history row, so pages only get the history when it changed
+    let version = 0
+    const log = (a, event, now, user) => {
+        version++
+        history.unshift({ ts: now, id: a.id, symbolId: a.symbolId, text: a.text, priority: a.priority, event, ...(user ? { user } : {}) })
+        if (history.length > HISTORY_MAX) history.length = HISTORY_MAX
+        return { event, id: a.id, symbolId: a.symbolId, text: a.text, priority: a.priority, ts: now, ...(user ? { user } : {}) }
+    }
+
+    return {
+        count: defs.length,
+        get version () { return version },
+        has (id) { return byId.has(id) },
+        // checks every alarm against the values; returns the events (ATIVO, NORMAL)
+        evaluate (values, now) {
+            const events = []
+            for (const d of defs) {
+                let on
+                try { on = d.active(values || {}) } catch (e) { on = false }
+                const cur = list.get(d.id)
+                if (on && (!cur || !cur.active)) {
+                    const a = { id: d.id, symbolId: d.symbolId, text: d.text, priority: d.priority, active: true, acked: false, since: now }
+                    list.set(d.id, a)
+                    events.push(log(a, 'ATIVO', now))
+                } else if (!on && cur && cur.active) {
+                    cur.active = false
+                    cur.cleared = now
+                    events.push(log(cur, 'NORMAL', now))
+                    if (cur.acked) list.delete(d.id)
+                }
+            }
+            return events
+        },
+        // acknowledges one alarm (by id), all alarms of a symbol (symbol:<id>) or every alarm ('all')
+        ack (which, now, user) {
+            const events = []
+            for (const a of [...list.values()]) {
+                // "all" is what the operator sees: shelved alarms are not in it
+                const match = (which === 'all' && !shelved.has(a.id)) || a.id === which || (typeof which === 'string' && which.startsWith('symbol:') && a.symbolId === which.slice(7))
+                if (!match || a.acked) continue
+                a.acked = true
+                a.ackTs = now
+                if (user) a.ackBy = user
+                events.push(log(a, 'RECONHECIDO', now, user))
+                if (!a.active) list.delete(a.id)
+            }
+            return events
+        },
+        // suppresses an alarm for some minutes (ISA-18.2 shelving): it leaves the list and the counters
+        shelve (id, minutes, now, user) {
+            const d = byId.get(id)
+            if (!d) return []
+            const min = Math.max(1, Math.min(1440, Number(minutes) || 30))
+            const sh = { id, symbolId: d.symbolId, text: d.text, priority: d.priority, until: now + min * 60000, ...(user ? { by: user } : {}) }
+            shelved.set(id, sh)
+            return [log(sh, 'SUPRIMIDO', now, user)]
+        },
+        unshelve (id, now, user) {
+            const sh = shelved.get(id)
+            if (!sh) return []
+            shelved.delete(id)
+            return [log(sh, 'LIBERADO', now, user)]
+        },
+        // shelved alarms whose time is over come back
+        expire (now) {
+            const events = []
+            for (const sh of [...shelved.values()]) if (sh.until <= now) events.push(...this.unshelve(sh.id, now, ''))
+            return events
+        },
+        snapshot (historyRows) {
+            const order = { 1: 0, 2: 1, 3: 2 }
+            const active = [...list.values()].filter(a => !shelved.has(a.id)).sort((a, b) => (a.acked - b.acked) || ((order[a.priority] ?? 3) - (order[b.priority] ?? 3)) || (b.since - a.since))
+            return { active, history: history.slice(0, historyRows === undefined ? 100 : historyRows), unacked: active.filter(a => !a.acked).length, shelved: [...shelved.values()].sort((a, b) => a.until - b.until) }
+        },
+        save () {
+            return { active: [...list.values()], history, shelved: [...shelved.values()] }
+        }
+    }
+}
+
+module.exports = { alarmDefs, createAlarms, onState }

package/nodes/clients.js

@@ -1,31 +1,31 @@
-'use strict'
-
-// Dashboard clicks on a canvas never go through the widget-action path of
-// Dashboard 2.0 (that one also feeds beforeSend, so a page could fake values).
-// The plugin in plugin.js hands them here with the socket, and each canvas
-// node answers its own: canvas id -> { action(conn, msg), load(conn, msg) }
-const canvases = new Map()
-
-// who is on the other end of a socket: login from FlowFuse / multi-user plugins,
-// or the user of HTTP basic auth (httpNodeAuth) in front of the dashboard
-function clientOf (RED, conn) {
-    let item = { _client: {} }
-    try {
-        for (const p of RED.plugins.getByType('node-red-dashboard-2')) {
-            if (p.hooks && typeof p.hooks.onAddConnectionCredentials === 'function') item = p.hooks.onAddConnectionCredentials(conn, item) || item
-        }
-    } catch (e) {}
-    const hs = (conn && conn.handshake) || {}
-    const c = { ...(item._client || {}), socketId: conn && conn.id, socketIp: hs.address, clientId: hs.query && hs.query.clientId }
-    if (!c.user) {
-        const auth = String((hs.headers && hs.headers.authorization) || '')
-        if (/^basic /i.test(auth)) {
-            const plain = Buffer.from(auth.slice(6).trim(), 'base64').toString('utf8')
-            const name = plain.slice(0, Math.max(0, plain.indexOf(':')))
-            if (name) c.user = { username: name }
-        }
-    }
-    return c
-}
-
-module.exports = { canvases, clientOf }
+'use strict'
+
+// Dashboard clicks on a canvas never go through the widget-action path of
+// Dashboard 2.0 (that one also feeds beforeSend, so a page could fake values).
+// The plugin in plugin.js hands them here with the socket, and each canvas
+// node answers its own: canvas id -> { action(conn, msg), load(conn, msg) }
+const canvases = new Map()
+
+// who is on the other end of a socket: login from FlowFuse / multi-user plugins,
+// or the user of HTTP basic auth (httpNodeAuth) in front of the dashboard
+function clientOf (RED, conn) {
+    let item = { _client: {} }
+    try {
+        for (const p of RED.plugins.getByType('node-red-dashboard-2')) {
+            if (p.hooks && typeof p.hooks.onAddConnectionCredentials === 'function') item = p.hooks.onAddConnectionCredentials(conn, item) || item
+        }
+    } catch (e) {}
+    const hs = (conn && conn.handshake) || {}
+    const c = { ...(item._client || {}), socketId: conn && conn.id, socketIp: hs.address, clientId: hs.query && hs.query.clientId }
+    if (!c.user) {
+        const auth = String((hs.headers && hs.headers.authorization) || '')
+        if (/^basic /i.test(auth)) {
+            const plain = Buffer.from(auth.slice(6).trim(), 'base64').toString('utf8')
+            const name = plain.slice(0, Math.max(0, plain.indexOf(':')))
+            if (name) c.user = { username: name }
+        }
+    }
+    return c
+}
+
+module.exports = { canvases, clientOf }

package/nodes/plugin.js

@@ -1,24 +1,24 @@
-'use strict'
-
-const { canvases } = require('./clients')
-
-// Dashboard 2.0 plugin: clicks and page loads of an hmi canvas go to the canvas
-// node itself (with the socket), never to the generic widget-action path
-module.exports = function (RED) {
-    RED.plugins.registerPlugin('node-red-dashboard-2-hmi', {
-        type: 'node-red-dashboard-2',
-        hooks: {
-            onAction (conn, id, msg) {
-                const c = canvases.get(id)
-                if (!c) return msg
-                try { c.action(conn, msg) } catch (e) { c.error(e) }
-                return null
-            },
-            onLoad (conn, id, msg, state) {
-                const c = canvases.get(id)
-                if (!c) return msg
-                try { return c.load(conn, msg) } catch (e) { c.error(e); return msg }
-            }
-        }
-    })
-}
+'use strict'
+
+const { canvases } = require('./clients')
+
+// Dashboard 2.0 plugin: clicks and page loads of an hmi canvas go to the canvas
+// node itself (with the socket), never to the generic widget-action path
+module.exports = function (RED) {
+    RED.plugins.registerPlugin('node-red-dashboard-2-hmi', {
+        type: 'node-red-dashboard-2',
+        hooks: {
+            onAction (conn, id, msg) {
+                const c = canvases.get(id)
+                if (!c) return msg
+                try { c.action(conn, msg) } catch (e) { c.error(e) }
+                return null
+            },
+            onLoad (conn, id, msg, state) {
+                const c = canvases.get(id)
+                if (!c) return msg
+                try { return c.load(conn, msg) } catch (e) { c.error(e); return msg }
+            }
+        }
+    })
+}

package/nodes/trend.js

@@ -1,54 +1,54 @@
-'use strict'
-
-// Recent samples of every key shown in a trend symbol: key -> [[time ms, value], ...]
-// A window holds at most POINTS samples spread over time: faster data is thinned
-// (one sample per window / POINTS), so a 1 h trend really covers the hour.
-// The page (UIHmiCanvas.vue) keeps its own samples the same way.
-const POINTS = 1500
-
-function windowsOf (symbols) {
-    const windows = {}
-    for (const s of Array.isArray(symbols) ? symbols : []) {
-        if (!s || s.type !== 'trend' || !s.key) continue
-        const win = Math.max(5, Math.min(3600, Number(s.props && s.props.window) || 60)) * 1000
-        windows[s.key] = Math.max(windows[s.key] || 0, win)
-    }
-    return windows
-}
-
-// adds one sample to a list, dropping old ones; returns the new list
-function addSample (list, now, value, win) {
-    const out = list.filter(q => q[0] >= now - win)
-    const step = win / POINTS
-    const last = out[out.length - 1]
-    if (last && now - last[0] < step && out.length > 1 && now - out[out.length - 2][0] < step) out[out.length - 1] = [now, value]
-    else out.push([now, value])
-    return out.length > POINTS + 2 ? out.slice(-(POINTS + 2)) : out
-}
-
-// saved: the history of the previous instance (kept across a deploy)
-function createTrendHistory (symbols, saved) {
-    const windows = windowsOf(symbols)
-    const hist = {}
-    if (saved && typeof saved === 'object') {
-        for (const k of Object.keys(windows)) if (Array.isArray(saved[k])) hist[k] = saved[k].slice(-(POINTS + 2))
-    }
-    return {
-        size: Object.keys(windows).length,
-        record (values, now) {
-            for (const k of Object.keys(windows)) {
-                const raw = values ? values[k] : undefined
-                const v = Number(raw)
-                const ok = raw !== undefined && raw !== null && raw !== '' && typeof raw !== 'boolean' && isFinite(v)
-                hist[k] = ok ? addSample(hist[k] || [], now, v, windows[k]) : (hist[k] || []).filter(q => q[0] >= now - windows[k])
-            }
-        },
-        snapshot () {
-            const out = {}
-            for (const k of Object.keys(hist)) out[k] = hist[k].slice()
-            return out
-        }
-    }
-}
-
-module.exports = { createTrendHistory, addSample, POINTS }
+'use strict'
+
+// Recent samples of every key shown in a trend symbol: key -> [[time ms, value], ...]
+// A window holds at most POINTS samples spread over time: faster data is thinned
+// (one sample per window / POINTS), so a 1 h trend really covers the hour.
+// The page (UIHmiCanvas.vue) keeps its own samples the same way.
+const POINTS = 1500
+
+function windowsOf (symbols) {
+    const windows = {}
+    for (const s of Array.isArray(symbols) ? symbols : []) {
+        if (!s || s.type !== 'trend' || !s.key) continue
+        const win = Math.max(5, Math.min(3600, Number(s.props && s.props.window) || 60)) * 1000
+        windows[s.key] = Math.max(windows[s.key] || 0, win)
+    }
+    return windows
+}
+
+// adds one sample to a list, dropping old ones; returns the new list
+function addSample (list, now, value, win) {
+    const out = list.filter(q => q[0] >= now - win)
+    const step = win / POINTS
+    const last = out[out.length - 1]
+    if (last && now - last[0] < step && out.length > 1 && now - out[out.length - 2][0] < step) out[out.length - 1] = [now, value]
+    else out.push([now, value])
+    return out.length > POINTS + 2 ? out.slice(-(POINTS + 2)) : out
+}
+
+// saved: the history of the previous instance (kept across a deploy)
+function createTrendHistory (symbols, saved) {
+    const windows = windowsOf(symbols)
+    const hist = {}
+    if (saved && typeof saved === 'object') {
+        for (const k of Object.keys(windows)) if (Array.isArray(saved[k])) hist[k] = saved[k].slice(-(POINTS + 2))
+    }
+    return {
+        size: Object.keys(windows).length,
+        record (values, now) {
+            for (const k of Object.keys(windows)) {
+                const raw = values ? values[k] : undefined
+                const v = Number(raw)
+                const ok = raw !== undefined && raw !== null && raw !== '' && typeof raw !== 'boolean' && isFinite(v)
+                hist[k] = ok ? addSample(hist[k] || [], now, v, windows[k]) : (hist[k] || []).filter(q => q[0] >= now - windows[k])
+            }
+        },
+        snapshot () {
+            const out = {}
+            for (const k of Object.keys(hist)) out[k] = hist[k].slice()
+            return out
+        }
+    }
+}
+
+module.exports = { createTrendHistory, addSample, POINTS }