node-red-contrib-room-tools 1.9.0 → 1.9.3

package/xy-series-frame.js

@@ -0,0 +1,98 @@
+function finite (value) {
+  return typeof value === 'number' && Number.isFinite(value)
+}
+
+function createXYSeriesReceiver (manifest) {
+  if (manifest?.kind !== 'xy-series-manifest' || typeof manifest.streamId !== 'string' ||
+    !manifest.streamId.trim() || manifest.streamId.length > 255 ||
+    typeof manifest.epoch !== 'string' || !manifest.epoch || manifest.epoch.length > 128 ||
+    !Number.isInteger(manifest.layoutVersion) || manifest.layoutVersion < 1 ||
+    manifest.layoutVersion > 2147483647 || manifest.clock !== 'monotonic-ms' ||
+    !finite(manifest.publishHz) || manifest.publishHz < 1 || manifest.publishHz > 60 ||
+    !Number.isSafeInteger(manifest.maxPoints) || manifest.maxPoints < 1 || manifest.maxPoints > 8192 ||
+    typeof manifest.xUnit !== 'string' || manifest.xUnit.length > 32 ||
+    typeof manifest.yUnit !== 'string' || manifest.yUnit.length > 32) {
+    throw Error('Invalid xy-series manifest')
+  }
+  const schema = Object.freeze({ ...manifest })
+  let latest = null, pending = false, closed = false
+  return {
+    manifest: schema,
+    accept (frame) {
+      if (closed || frame?.kind !== 'xy-series-frame' || frame.streamId !== schema.streamId ||
+        frame.epoch !== schema.epoch || frame.layoutVersion !== schema.layoutVersion ||
+        !Number.isSafeInteger(frame.seq) || frame.seq < 1 || (latest && frame.seq <= latest.seq) ||
+        !finite(frame.sampleTime) || frame.sampleTime < 0 || !Array.isArray(frame.points) ||
+        frame.points.length > schema.maxPoints || frame.points.some(point =>
+          !Array.isArray(point) || point.length !== 2 || !finite(point[0]) || !finite(point[1]))) return false
+      latest = Object.freeze({ kind: 'xy-series-frame', streamId: schema.streamId,
+        epoch: schema.epoch, seq: frame.seq, layoutVersion: schema.layoutVersion,
+        sampleTime: frame.sampleTime,
+        points: Object.freeze(frame.points.map(point => Object.freeze([point[0], point[1]]))) })
+      pending = true
+      return true
+    },
+    snapshot () { return latest },
+    take () { if (!pending) return null; pending = false; return latest },
+    close () { closed = true; pending = false; latest = null }
+  }
+}
+
+function createXYSeriesRenderer ({ receiver, requestFrame, cancelFrame, apply }) {
+  let handle = null, closed = false
+  return {
+    receive (frame) {
+      if (closed || !receiver.accept(frame)) return false
+      if (handle === null) {
+        handle = requestFrame(() => {
+          handle = null
+          const current = receiver.take()
+          if (!closed && current) apply(current)
+        })
+      }
+      return true
+    },
+    close () {
+      closed = true
+      if (handle !== null) cancelFrame(handle)
+      handle = null
+      receiver.close()
+    }
+  }
+}
+
+function createRoomXYSeriesReceiver (layout) {
+  const finite = value => typeof value === 'number' && Number.isFinite(value)
+  if (layout?.kind !== 'room-xy-series-layout' || typeof layout.panelId !== 'string' ||
+    typeof layout.room !== 'string' || typeof layout.epoch !== 'string' || !layout.epoch ||
+    !Array.isArray(layout.ids) || !layout.ids.length || layout.ids.length > 256 ||
+    layout.ids.some(id => typeof id !== 'string' || !id) || new Set(layout.ids).size !== layout.ids.length) {
+    throw Error('Invalid Room XY-series layout')
+  }
+  let latest = null, pending = false, closed = false
+  const count = layout.ids.length
+  return {
+    accept (frame) {
+      if (closed || frame?.kind !== 'room-xy-series-frame' || frame.panelId !== layout.panelId ||
+        frame.room !== layout.room || frame.epoch !== layout.epoch ||
+        !Number.isSafeInteger(frame.seq) || frame.seq < 1 || (latest && frame.seq <= latest.seq) ||
+        !Array.isArray(frame.values) || frame.values.length !== count ||
+        !Array.isArray(frame.valid) || frame.valid.length !== count) return false
+      for (let index = 0; index < count; index++) {
+        const points = frame.values[index], valid = frame.valid[index]
+        if (typeof valid !== 'boolean' || !Array.isArray(points) || points.length > 8192 ||
+          (!valid && points.length !== 0) ||
+          (valid && points.some(point => !Array.isArray(point) || point.length !== 2 ||
+            !finite(point[0]) || !finite(point[1])))) return false
+      }
+      latest = { values: frame.values.map(points => points.map(point => point.slice())),
+        valid: frame.valid.slice(), seq: frame.seq }
+      pending = true
+      return true
+    },
+    take () { if (!pending) return null; pending = false; return latest },
+    close () { closed = true; latest = null; pending = false }
+  }
+}
+
+module.exports = { createXYSeriesReceiver, createXYSeriesRenderer, createRoomXYSeriesReceiver }

package/xy-series-route.js

@@ -0,0 +1,11 @@
+function xySeriesRoute (value) {
+  if (!value || typeof value !== 'object' ||
+    typeof value.streamId !== 'string' || !value.streamId.trim() || value.streamId.length > 255 ||
+    ![value.eventPath, value.manifestPath].every(path => typeof path === 'string' &&
+      /^\/\/[^/]/.test(path) && path.length <= 1026) || value.eventPath === value.manifestPath) {
+    throw Error('Invalid xy-series delivery metadata')
+  }
+  return { streamId: value.streamId, eventPath: value.eventPath, manifestPath: value.manifestPath }
+}
+
+module.exports = { xySeriesRoute }