node-red-contrib-room-tools 1.4.2 → 1.7.1

package/control-policy.js

@@ -0,0 +1,449 @@
+const CONTROL_POLICY_MARKER = '/* ui-control-panel-control-api-v1 */'
+const FEEDBACK_TOPIC_FIELDS = Object.freeze({
+  'display/power': 'display',
+  'display/source': 'source',
+  'audio/volume': 'volume',
+  'audio/mute': 'muted',
+  'lighting/brightness': 'light',
+  'room/curtain': 'curtains',
+  'climate/temperature': 'temperature',
+  'room/scene': 'scene',
+  'room/meeting': 'meeting'
+})
+
+function normalizeControlFeedback (message, expectedRoom, topicFields) {
+  if (!message || typeof message !== 'object' || Array.isArray(message)) {
+    throw new Error('Control feedback must be an object')
+  }
+  if (message.kind !== 'state') throw new Error('Control feedback must have kind=state')
+  if (expectedRoom && message.room !== expectedRoom) throw new Error('Control feedback room mismatch')
+  if (typeof message.topic !== 'string' || !message.topic) throw new Error('Control feedback needs a topic')
+
+  let state = message.state && typeof message.state === 'object' && !Array.isArray(message.state)
+    ? { ...message.state }
+    : {}
+  if (message.topic === 'room/state') {
+    if (!message.payload || typeof message.payload !== 'object' || Array.isArray(message.payload)) {
+      throw new Error('room/state feedback needs an object payload')
+    }
+    state = { ...state, ...message.payload }
+  } else if (topicFields[message.topic]) {
+    state[topicFields[message.topic]] = message.payload
+  }
+
+  return {
+    room: message.room,
+    kind: 'state',
+    topic: message.topic,
+    payload: message.payload,
+    state,
+    revision: Number.isInteger(message.revision) && message.revision >= 0 ? message.revision : null,
+    controlKey: typeof message.controlKey === 'string' ? message.controlKey : null
+  }
+}
+
+function createControlPanelPolicy ({
+  dispatch,
+  intervalMs = 40,
+  now = () => Date.now(),
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+  onError = () => {}
+}) {
+  if (typeof dispatch !== 'function') throw new Error('ControlPanel dispatch function is required')
+  if (!Number.isFinite(intervalMs) || intervalMs < 0) throw new Error('ControlPanel interval must be a non-negative number')
+
+  const continuousTypes = new Set(['level', 'dimmer', 'position'])
+  const discreteTypes = new Set(['power', 'source', 'preset', 'mute'])
+  const continuousControls = new Map()
+  let discreteQueue = Promise.resolve()
+  let disposed = false
+
+  const reportError = (error, command) => {
+    try {
+      onError(error, command)
+    } catch (_) {}
+  }
+
+  const normalize = (command) => {
+    if (!command || typeof command !== 'object' || Array.isArray(command)) {
+      throw new Error('Control command must be an object')
+    }
+    const type = String(command.type ?? command.controlType ?? '').trim().toLowerCase()
+    const topic = String(command.topic ?? '').trim()
+    const key = String(command.key ?? command.controlKey ?? '').trim()
+    const hasValue = Object.prototype.hasOwnProperty.call(command, 'value') ||
+      Object.prototype.hasOwnProperty.call(command, 'payload')
+
+    if (!continuousTypes.has(type) && !discreteTypes.has(type)) {
+      throw new Error('Unsupported control type: ' + type)
+    }
+    if (!topic) throw new Error('Control command needs a topic')
+    if (!/^[a-zA-Z0-9._:/-]{1,160}$/.test(key)) throw new Error('Control command needs a valid key')
+    if (!hasValue) throw new Error('Control command needs a value')
+
+    return {
+      topic,
+      payload: Object.prototype.hasOwnProperty.call(command, 'value') ? command.value : command.payload,
+      controlType: type,
+      controlKey: key,
+      final: command.final === true
+    }
+  }
+
+  const continuousControl = (key) => {
+    let control = continuousControls.get(key)
+    if (!control) {
+      control = {
+        inFlight: false,
+        lastCommand: null,
+        lastSentAt: -intervalMs,
+        latest: null,
+        timer: null
+      }
+      continuousControls.set(key, control)
+    }
+    return control
+  }
+
+  const dispatchContinuous = async (key) => {
+    const control = continuousControl(key)
+    if (control.inFlight || !control.latest) return
+
+    const command = control.latest
+    control.latest = null
+    control.inFlight = true
+    try {
+      await dispatch(command)
+    } catch (error) {
+      reportError(error, command)
+    } finally {
+      control.lastSentAt = now()
+      control.inFlight = false
+      if (!disposed && control.latest) scheduleContinuous(key, control.latest.final)
+    }
+  }
+
+  const scheduleContinuous = (key, force) => {
+    const control = continuousControl(key)
+    if (control.inFlight || !control.latest) return
+    if (force && control.timer) {
+      clearTimer(control.timer)
+      control.timer = null
+    }
+    if (control.timer) return
+
+    const delay = force ? 0 : Math.max(0, intervalMs - (now() - control.lastSentAt))
+    if (delay === 0) {
+      void dispatchContinuous(key)
+      return
+    }
+    control.timer = setTimer(() => {
+      control.timer = null
+      void dispatchContinuous(key)
+    }, delay)
+  }
+
+  const sendDiscrete = (command) => {
+    discreteQueue = discreteQueue
+      .catch(() => undefined)
+      .then(() => disposed ? undefined : dispatch(command))
+      .catch((error) => reportError(error, command))
+    return discreteQueue
+  }
+
+  return {
+    send (command) {
+      if (disposed) return Promise.resolve()
+      const normalized = normalize(command)
+      if (continuousTypes.has(normalized.controlType)) {
+        const control = continuousControl(normalized.controlKey)
+        control.lastCommand = normalized
+        control.latest = normalized
+        scheduleContinuous(normalized.controlKey, normalized.final)
+        return Promise.resolve()
+      }
+      return sendDiscrete(normalized)
+    },
+
+    flush (key) {
+      const control = continuousControls.get(String(key))
+      if (disposed || !control || !control.lastCommand) return Promise.resolve()
+      control.latest = { ...control.lastCommand, final: true }
+      scheduleContinuous(control.latest.controlKey, true)
+      return Promise.resolve()
+    },
+
+    dispose () {
+      disposed = true
+      for (const control of continuousControls.values()) {
+        if (control.timer) clearTimer(control.timer)
+        control.latest = null
+      }
+      continuousControls.clear()
+    }
+  }
+}
+
+function buildControlPolicyMixinSource () {
+  return `
+${CONTROL_POLICY_MARKER}
+const __controlPanelCreatePolicy = ${createControlPanelPolicy.toString()}
+const __controlPanelFeedbackFields = ${JSON.stringify(FEEDBACK_TOPIC_FIELDS)}
+const __controlPanelNormalizeFeedback = ${normalizeControlFeedback.toString()}
+const __controlPanelPolicyMixin = {
+  data () {
+    return {
+      deviceState: {},
+      deviceFeedbackRevision: 0,
+      deviceFeedbackConnected: false,
+      controlPending: {},
+      controlTargets: {}
+    }
+  },
+  created () {
+    this.__controlPanelSession = null
+    this.__controlPanelFeedbackSource = null
+    this.__controlPanelRequests = new Map()
+    this.__resetControlPolicy()
+  },
+  methods: {
+    __resetControlPolicy () {
+      this.__controlPanelPolicy?.dispose()
+      this.__controlPanelPolicy = __controlPanelCreatePolicy({
+        intervalMs: 40,
+        dispatch: (command) => this.__dispatchControl(command),
+        onError: (error, command) => {
+          if (command?.controlKey) this.__clearControlPending(command.controlKey)
+          if (typeof this.onControlError === 'function') this.onControlError(error, command)
+          else console.error('ControlPanel command failed', error)
+        }
+      })
+    },
+    __setControlPending (key, pending) {
+      const next = { ...this.controlPending }
+      if (pending) next[key] = true
+      else delete next[key]
+      this.controlPending = next
+    },
+    __setControlTarget (key, value) {
+      this.controlTargets = { ...this.controlTargets, [key]: value }
+    },
+    __clearControlPending (key) {
+      this.__controlPanelRequests.delete(String(key))
+      this.__setControlPending(String(key), false)
+      const targets = { ...this.controlTargets }
+      delete targets[String(key)]
+      this.controlTargets = targets
+    },
+    __setFeedbackConnected (connected) {
+      const next = connected === true
+      if (this.deviceFeedbackConnected === next) return
+      this.deviceFeedbackConnected = next
+      if (typeof this.onControlFeedbackStatus === 'function') this.onControlFeedbackStatus(next)
+    },
+    __closeControlFeedback () {
+      this.__controlPanelFeedbackSource?.close()
+      this.__controlPanelFeedbackSource = null
+      this.__setFeedbackConnected(false)
+    },
+    __connectControlFeedback () {
+      this.__closeControlFeedback()
+      const session = this.__controlPanelSession
+      if (!session || typeof EventSource === 'undefined') return
+      const source = new EventSource('/room-panel-api/regions/' + encodeURIComponent(session.room) + '/events')
+      this.__controlPanelFeedbackSource = source
+      source.onopen = () => {
+        if (this.__controlPanelFeedbackSource === source) this.__setFeedbackConnected(true)
+      }
+      source.onmessage = (event) => {
+        if (this.__controlPanelFeedbackSource !== source) return
+        try {
+          this.applyControlFeedback(JSON.parse(event.data))
+        } catch (error) {
+          if (typeof this.onControlError === 'function') this.onControlError(error)
+          else console.error('ControlPanel feedback failed', error)
+        }
+      }
+      source.onerror = () => {
+        if (this.__controlPanelFeedbackSource === source) this.__setFeedbackConnected(false)
+      }
+    },
+    __acknowledgeControlFeedback (feedback) {
+      for (const [key, request] of this.__controlPanelRequests) {
+        if (feedback.controlKey && feedback.controlKey !== key) continue
+        let matched = request.topic === 'room/reset'
+        let value
+        if (!matched && feedback.topic === request.topic) {
+          matched = true
+          value = feedback.payload
+        } else if (!matched && feedback.topic === 'room/state') {
+          const field = __controlPanelFeedbackFields[request.topic]
+          if (field && Object.prototype.hasOwnProperty.call(feedback.state, field)) {
+            matched = true
+            value = feedback.state[field]
+          }
+        }
+        if (matched && (request.topic === 'room/reset' || Object.is(value, request.value))) {
+          this.__clearControlPending(key)
+        }
+      }
+    },
+    setControlSession (session) {
+      if (!session || typeof session !== 'object' || !session.room || !session.csrf) {
+        throw new Error('ControlPanel session needs room and csrf')
+      }
+      const next = { room: String(session.room), csrf: String(session.csrf) }
+      if (this.__controlPanelSession &&
+        (this.__controlPanelSession.room !== next.room || this.__controlPanelSession.csrf !== next.csrf)) {
+        this.__resetControlPolicy()
+        this.__controlPanelRequests.clear()
+        this.controlPending = {}
+        this.controlTargets = {}
+        this.deviceState = {}
+        this.deviceFeedbackRevision = 0
+      }
+      this.__controlPanelSession = next
+      this.__connectControlFeedback()
+    },
+    clearControlSession () {
+      this.__closeControlFeedback()
+      this.__controlPanelSession = null
+      this.__resetControlPolicy()
+      this.__controlPanelRequests.clear()
+      this.controlPending = {}
+      this.controlTargets = {}
+      this.deviceState = {}
+      this.deviceFeedbackRevision = 0
+    },
+    sendControl (command) {
+      const key = String(command?.key ?? command?.controlKey ?? '')
+      const type = String(command?.type ?? command?.controlType ?? '').toLowerCase()
+      const value = Object.prototype.hasOwnProperty.call(command || {}, 'value') ? command.value : command?.payload
+      if (key) {
+        this.__controlPanelRequests.set(key, {
+          topic: String(command.topic ?? ''),
+          type,
+          value
+        })
+        this.__setControlPending(key, true)
+        if (['level', 'dimmer', 'position'].includes(type)) this.__setControlTarget(key, value)
+      }
+      try {
+        return this.__controlPanelPolicy.send(command)
+      } catch (error) {
+        if (key) this.__clearControlPending(key)
+        throw error
+      }
+    },
+    flushControl (key) {
+      return this.__controlPanelPolicy.flush(key)
+    },
+    applyControlFeedback (message) {
+      const room = this.__controlPanelSession?.room || this.authorizedRoom
+      const feedback = __controlPanelNormalizeFeedback(message, room, __controlPanelFeedbackFields)
+      this.deviceState = { ...this.deviceState, ...feedback.state }
+      if (feedback.revision !== null) this.deviceFeedbackRevision = feedback.revision
+      this.__acknowledgeControlFeedback(feedback)
+      if (typeof this.onDeviceFeedback === 'function') this.onDeviceFeedback(feedback, this.deviceState)
+      return feedback
+    },
+    hasDeviceState (field) {
+      return Object.prototype.hasOwnProperty.call(this.deviceState, String(field))
+    },
+    deviceValue (field, fallback = null) {
+      return this.hasDeviceState(field) ? this.deviceState[String(field)] : fallback
+    },
+    isControlPending (key) {
+      return this.controlPending[String(key)] === true
+    },
+    controlDisplayValue (key, field, fallback = null) {
+      const controlKey = String(key)
+      if (this.isControlPending(controlKey) &&
+        Object.prototype.hasOwnProperty.call(this.controlTargets, controlKey)) {
+        return this.controlTargets[controlKey]
+      }
+      return this.deviceValue(field, fallback)
+    },
+    async __dispatchControl (command) {
+      if (typeof this.controlTransport === 'function') return this.controlTransport(command)
+
+      const session = this.__controlPanelSession
+      const room = session?.room || this.authorizedRoom
+      if (typeof this.postControl === 'function') {
+        return this.postControl(room ? { ...command, room } : command, this.sessionGeneration)
+      }
+      if (!session) throw new Error('Call setControlSession() after login, or define controlTransport(command)')
+
+      const response = await fetch('/room-panel-api/regions/' + encodeURIComponent(session.room) + '/command', {
+        method: 'POST',
+        credentials: 'same-origin',
+        headers: { 'Content-Type': 'application/json', 'X-Room-CSRF': session.csrf },
+        body: JSON.stringify({ room: session.room, ...command }),
+        signal: AbortSignal.timeout(8000)
+      })
+      if (!response.ok) throw new Error('Control command failed (' + response.status + ')')
+      return response
+    }
+  },
+  unmounted () {
+    this.__closeControlFeedback()
+    this.__controlPanelPolicy?.dispose()
+    this.__controlPanelPolicy = null
+    this.__controlPanelRequests?.clear()
+    this.controlPending = {}
+    this.controlTargets = {}
+    this.__controlPanelSession = null
+  }
+}
+`
+}
+
+function injectControlPolicy (format) {
+  if (typeof format !== 'string' || format.includes(CONTROL_POLICY_MARKER)) return format
+
+  const scriptMatch = /<script(?!\s+setup\b)(?:\s[^>]*)?>/i.exec(format)
+  if (!scriptMatch) {
+    const setupMatch = /<script\s+setup\b([^>]*)>/i.exec(format)
+    if (!setupMatch && !/<template(?:\s|>)/i.test(format)) return format
+    const langMatch = setupMatch?.[1]?.match(/\blang\s*=\s*(["'])([^"']+)\1/i)
+    const scriptOpen = langMatch ? '<script lang="' + langMatch[2] + '">' : '<script>'
+    return format + '\n' + scriptOpen + '\n' + buildControlPolicyMixinSource() +
+      '\nexport default { mixins: [__controlPanelPolicyMixin] }\n</script>\n'
+  }
+
+  const scriptStart = scriptMatch.index + scriptMatch[0].length
+  const scriptEnd = format.indexOf('</script>', scriptStart)
+  if (scriptEnd === -1) return format
+
+  const source = format.slice(scriptStart, scriptEnd)
+  const exportMatch = /(^|\n)([ \t]*)export\s+default\b/.exec(source)
+  if (!exportMatch) {
+    const wrapped = source + '\n' + buildControlPolicyMixinSource() +
+      '\nexport default { mixins: [__controlPanelPolicyMixin] }\n'
+    return format.slice(0, scriptStart) + wrapped + format.slice(scriptEnd)
+  }
+
+  const exportStart = exportMatch.index + exportMatch[1].length + exportMatch[2].length
+  const exportEnd = exportMatch.index + exportMatch[0].length
+  const userOptions = source.slice(0, exportStart) +
+    'const __controlPanelUserOptions =' +
+    source.slice(exportEnd)
+  const wrapped = userOptions + '\n' + buildControlPolicyMixinSource() + `
+export default {
+  ...__controlPanelUserOptions,
+  mixins: [...(__controlPanelUserOptions.mixins || []), __controlPanelPolicyMixin]
+}
+`
+
+  return format.slice(0, scriptStart) + wrapped + format.slice(scriptEnd)
+}
+
+module.exports = {
+  CONTROL_POLICY_MARKER,
+  FEEDBACK_TOPIC_FIELDS,
+  buildControlPolicyMixinSource,
+  createControlPanelPolicy,
+  injectControlPolicy,
+  normalizeControlFeedback
+}