@flowfuse/node-red-dashboard 1.32.0 → 1.32.1-15daa3c-202609281436.0

package/nodes/config/ui_base.js

@@ -6,6 +6,7 @@ const axios = require('axios')
 const v = require('../../package.json').version
 const { createClientStore } = require('../store/clients.js')
 const datastore = require('../store/data.js')
+const { attachToContext } = require('../store/reactive.js')
 const statestore = require('../store/state.js')
 const { appendTopic, addConnectionCredentials, matchesClient, normalizeClientId, getThirdPartyWidgets } = require('../utils/index.js')
 
@@ -401,6 +402,20 @@ module.exports = function (RED) {
 
         node._created = Date.now()
 
+        try {
+            let unavailable = null
+            const store = attachToContext(node.context().global, {
+                clone: RED.util.cloneMessage,
+                onUnavailable: (err) => { unavailable = err },
+                onReplaced: () => node.warn('global.dashboardStore was replaced by a flow since the last deploy, discarding the stored value of every widget. The store has been re-created. To write your own data, set global.dashboardStore.<key> rather than replacing global.dashboardStore itself.')
+            })
+            if (!store) {
+                node.warn('Dashboard data store disabled: the global context store doesn\'t hold objects by reference (e.g. cache: false), so live state can\'t work. Use the memory store or localfilesystem with cache: true.' + (unavailable ? ' Reading it failed with: ' + unavailable.message : ''))
+            }
+        } catch (err) {
+            node.warn('Dashboard data store disabled: could not initialise it in global context (' + err.message + ').')
+        }
+
         n.root = RED.settings.httpNodeRoot || '/'
 
         /** @type {Object.<string, Socket>} */

package/nodes/store/reactive.js

@@ -0,0 +1,154 @@
+const STORE = Symbol.for('@flowfuse/node-red-dashboard/store')
+const NAMESPACE = 'dashboardStore'
+
+class Entry {
+    constructor () {
+        this.value = undefined
+        this.quality = 'GOOD'
+        this.timestamp = 0
+        this.history = []
+    }
+}
+
+// only plain objects and arrays are deep-watched; Buffers, Dates, class instances etc. are opaque leaves
+function isReactable (v) {
+    if (Array.isArray(v)) return true
+    if (v === null || typeof v !== 'object') return false
+    const proto = Object.getPrototypeOf(v)
+    return proto === null || Object.getPrototypeOf(proto) === null
+}
+
+// reads through proxies (structuredClone rejects them); production injects RED.util.cloneMessage
+function deepClone (v, seen = new WeakMap()) {
+    if (v === null || typeof v !== 'object') return v
+    if (Buffer.isBuffer(v)) return Buffer.from(v)
+    if (v instanceof Date) return new Date(v)
+    if (seen.has(v)) return seen.get(v)
+    const out = Array.isArray(v) ? [] : {}
+    seen.set(v, out)
+    for (const k of Object.keys(v)) out[k] = deepClone(v[k], seen)
+    return out
+}
+
+function deepReactive (value, notify, path, clone, seen = new WeakMap()) {
+    if (!isReactable(value)) return value
+    if (seen.has(value)) return seen.get(value)
+    const proxy = new Proxy(value, {
+        get (t, p, r) { return Reflect.get(t, p, r) },
+        set (t, p, v) {
+            if (typeof p === 'symbol') return Reflect.set(t, p, v)
+            // a push writes the new index then grows length; only a shrink is a change worth reporting
+            const shrank = p === 'length' && Array.isArray(t) && v < t.length
+            t[p] = deepReactive(clone(v), notify, `${path}.${String(p)}`, clone)
+            if (p !== 'length') notify(`${path}.${String(p)}`)
+            else if (shrank) notify(path)
+            return true
+        },
+        deleteProperty (t, p) {
+            const existed = p in t
+            const ok = delete t[p]
+            if (existed) notify(`${path}.${String(p)}`)
+            return ok
+        }
+    })
+    // registered before walking children so a cycle resolves to this proxy instead of recursing
+    seen.set(value, proxy)
+    for (const k of Object.keys(value)) value[k] = deepReactive(value[k], notify, `${path}.${k}`, clone, seen)
+    return proxy
+}
+
+function createDataStore ({ maxHistory = 5, onChange, clone = deepClone, now = Date.now } = {}) {
+    const cloneValue = (v) => (v && typeof v === 'object') ? clone(v) : v
+    const emit = (prop, rec, path) => { try { onChange?.(prop, rec, path) } catch (err) {} }
+    const records = Object.create(null)
+
+    records[STORE] = true
+
+    const handler = {
+        get (target, prop, receiver) {
+            if (typeof prop === 'symbol') return Reflect.get(target, prop, receiver)
+            if (prop === 'toJSON') {
+                return () => Object.fromEntries(Object.entries(target).map(([k, r]) => [k, r.value]))
+            }
+            if (prop.startsWith('$')) {
+                const rec = target[prop.slice(1)]
+                return rec && Object.freeze({ value: rec.value, quality: rec.quality, timestamp: rec.timestamp, history: Object.freeze(rec.history.slice()) })
+            }
+            const rec = target[prop]
+            return rec ? rec.value : undefined
+        },
+        set (target, prop, value) {
+            if (typeof prop === 'symbol') return Reflect.set(target, prop, value)
+            // returning true rather than false so a strict caller picking a reserved name doesn't throw
+            if (prop === '__proto__' || prop === 'constructor' || prop === 'toJSON') return true
+            if (prop.startsWith('$')) return true // '$' is reserved for the read-only meta view
+
+            let rec = target[prop]
+            if (!rec) {
+                rec = new Entry()
+                target[prop] = rec
+            } else {
+                rec.history.push(Object.freeze({ value: cloneValue(rec.value), timestamp: rec.timestamp }))
+                if (rec.history.length > maxHistory) rec.history.shift()
+            }
+            const notify = (path) => {
+                // a replaced value keeps its proxies alive; they must not report into the record any more
+                if (rec.value !== wrapped) return
+                rec.timestamp = now()
+                emit(prop, rec, path)
+            }
+            // clone on write so a flow reusing its own object can't mutate stored state
+            const wrapped = deepReactive(cloneValue(value), notify, prop, cloneValue)
+            rec.value = wrapped
+            rec.timestamp = now()
+            emit(prop, rec, prop)
+            return true
+        },
+        ownKeys (target) { return Reflect.ownKeys(target) },
+        deleteProperty (target, prop) {
+            if (typeof prop === 'symbol') return Reflect.deleteProperty(target, prop)
+            const rec = target[prop]
+            const existed = prop in target
+            const ok = delete target[prop]
+            if (rec) rec.value = undefined
+            if (existed) emit(prop, undefined, prop)
+            return ok
+        }
+    }
+    return new Proxy(records, handler)
+}
+
+const injected = new WeakMap()
+
+// Inject the store into global context once. On redeploy the existing store is reused;
+// after a restart with a persistent context store, existing plain data is rehydrated.
+// Returns null when the context store can't hold a live proxy: a cache-off store serves
+// only async access so a sync get throws, and a serialising store hands back a copy.
+function attachToContext (globalContext, opts = {}) {
+    const namespace = opts.namespace || NAMESPACE
+    let existing
+    try {
+        existing = globalContext.get(namespace)
+    } catch (err) {
+        opts.onUnavailable?.(err)
+        return null
+    }
+    if (existing && existing[STORE]) {
+        injected.set(globalContext, existing)
+        return existing
+    }
+
+    const previous = injected.get(globalContext)
+    if (previous && existing !== previous) opts.onReplaced?.()
+
+    const store = createDataStore(opts)
+    if (isReactable(existing) && !Array.isArray(existing)) {
+        for (const [k, v] of Object.entries(existing)) store[k] = v
+    }
+    globalContext.set(namespace, store)
+    if (globalContext.get(namespace) !== store) return null
+    injected.set(globalContext, store)
+    return store
+}
+
+module.exports = { createDataStore, attachToContext, NAMESPACE, STORE }

package/nodes/widgets/ui_gauge.js

@@ -10,6 +10,7 @@ module.exports = function (RED) {
         const group = RED.nodes.getNode(config.group)
 
         const evts = {
+            onAction: true,
             beforeSend: async function (msg) {
                 const updates = msg.ui_update
                 if (updates) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flowfuse/node-red-dashboard",
-    "version": "1.32.0",
+    "version": "1.32.1-15daa3c-202609281436.0",
     "description": "FlowFuse Dashboard - A collection of Node-RED nodes that provide functionality to build your own UI applications (inc. forms, buttons, charts).",
     "keywords": [
         "node-red"

package/dist/assets/abnfDiagram-N423BO3Z-BOzAedUe.js

@@ -1 +0,0 @@
-import{g as p,r as u,d as a}from"./chunk-6Q2QTUOP-DpGB6o5S.js";import{p as f}from"./chunk-JWPE2WC7-UNqcBwu_.js";import{_ as n,l as o}from"./mermaid-CX4mRs5N.js";import{M as c,b as d}from"./cynefin-VYW2F7L2-BDPznSFQ.js";var v=d().RailroadAbnf.parser.LangiumParser,l=n(e=>{const r=e.alternatives.map(g);return r.length===1?r[0]:{type:"choice",alternatives:r}},"transformAlternation"),g=n(e=>{const r=e.elements.map(y);return r.length===1?r[0]:{type:"sequence",elements:r}},"transformConcatenation"),b=n(e=>{if(e.includes("*")){const[t,s]=e.split("*"),i=t?parseInt(t,10):0,m=s?parseInt(s,10):1/0;return{min:i,max:m}}const r=parseInt(e,10);return{min:r,max:r}},"parseRepeat"),y=n(e=>{const r=A(e.primary);if(!e.repeat)return r;const{min:t,max:s}=b(e.repeat);return t===0&&s===1?{type:"optional",element:r}:{type:"repetition",element:r,min:t,max:s}},"transformElement"),A=n(e=>{switch(e.$type){case"AbnfStringLiteral":return{type:"terminal",value:e.value};case"AbnfNumVal":return{type:"terminal",value:e.value};case"AbnfRuleName":return{type:"nonterminal",name:e.name};case"AbnfGroup":return l(e.element);case"AbnfOptionalGroup":return{type:"optional",element:l(e.element)};default:throw new Error(`Unsupported ABNF primary node: ${e.$type}`)}},"transformPrimary"),P=n(e=>({name:e.name,definition:l(e.definition)}),"transformRule"),h=n(e=>{f(e,a),e.title&&a.setTitle(e.title),e.rules.map(r=>a.addRule(P(r)))},"populateDb"),R={parse:n(e=>{a.clear(),o.debug("[ABNF Parser] Starting Langium parse");const r=v.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new c(r);const t=r.value;o.debug("[ABNF Parser] Parsed rules:",t.rules.length),h(t),o.debug("[ABNF Parser] Parse complete")},"parse"),parser:{yy:a}},w={parser:R,db:a,renderer:u,styles:p};export{w as diagram};