node-red-contrib-room-tools 1.8.0 → 1.8.1

package/control-policy.js

@@ -1,3 +1,6 @@
+const acorn = require('acorn')
+const escodegen = require('escodegen')
+
 const CONTROL_POLICY_MARKER = '/* ui-control-panel-control-api-v1 */'
 const FEEDBACK_TOPIC_FIELDS = Object.freeze({
   'display/power': 'display',
@@ -399,17 +402,337 @@ const __controlPanelPolicyMixin = {
 `
 }
 
+// Dashboard 2.0 1.31 parses ui-template scripts itself. It only treats a script
+// as component options when the script contains one `export default { ... }`
+// statement. Keep every helper inside data, methods, or lifecycle hooks so the
+// generated script remains inside that supported subset.
+function buildDashboardPolicyOptionsSource () {
+  return `
+export default {
+  data () {
+    return {
+      deviceState: {},
+      deviceFeedbackRevision: 0,
+      deviceFeedbackConnected: false,
+      controlPending: {},
+      controlTargets: {}
+    }
+  },
+  methods: {
+    __controlPanelCreatePolicy: ${createControlPanelPolicy.toString()},
+    __controlPanelNormalizeFeedback: ${normalizeControlFeedback.toString()},
+    __controlPanelFeedbackFields () {
+      return ${JSON.stringify(FEEDBACK_TOPIC_FIELDS)}
+    },
+    __initializeControlPanelPolicy () {
+      this.__controlPanelSession = null
+      this.__controlPanelFeedbackSource = null
+      this.__controlPanelRequests = new Map()
+      this.__resetControlPolicy()
+    },
+    __disposeControlPanelPolicy () {
+      this.__closeControlFeedback()
+      this.__controlPanelPolicy?.dispose()
+      this.__controlPanelPolicy = null
+      this.__controlPanelRequests?.clear()
+      this.controlPending = {}
+      this.controlTargets = {}
+      this.__controlPanelSession = null
+    },
+    __resetControlPolicy () {
+      this.__controlPanelPolicy?.dispose()
+      this.__controlPanelPolicy = this.__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) {
+      const feedbackFields = this.__controlPanelFeedbackFields()
+      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 = feedbackFields[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 = this.__controlPanelNormalizeFeedback(
+        message,
+        room,
+        this.__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
+    }
+  },
+  mounted () {
+    this.__initializeControlPanelPolicy()
+  },
+  unmounted () {
+    this.__disposeControlPanelPolicy()
+  }
+}
+`
+}
+
+function parseOptionsObject (source) {
+  const tree = acorn.parse(source, { ecmaVersion: 'latest', sourceType: 'module' })
+  if (tree.body.length !== 1 || tree.body[0].type !== 'ExportDefaultDeclaration' ||
+    tree.body[0].declaration.type !== 'ObjectExpression') return null
+  return tree.body[0].declaration
+}
+
+function propertyName (property) {
+  if (!property || property.type !== 'Property') return null
+  if (!property.computed && property.key.type === 'Identifier') return property.key.name
+  if (property.key.type === 'Literal') return String(property.key.value)
+  return null
+}
+
+function findProperty (object, name) {
+  return object.properties.find(property => propertyName(property) === name)
+}
+
+function parseProperty (source) {
+  const object = acorn.parse('({' + source + '})', { ecmaVersion: 'latest' }).body[0].expression
+  return object.properties[0]
+}
+
+function functionSource (property) {
+  return property ? escodegen.generate(property.value) : null
+}
+
+function mergeDashboardOptions (userSource) {
+  const user = parseOptionsObject(userSource)
+  if (!user) return null
+
+  const policy = parseOptionsObject(buildDashboardPolicyOptionsSource())
+  const policyData = findProperty(policy, 'data')
+  const policyMethods = findProperty(policy, 'methods')
+  const policyMounted = findProperty(policy, 'mounted')
+  const policyUnmounted = findProperty(policy, 'unmounted')
+  const userData = findProperty(user, 'data')
+  const userMethods = findProperty(user, 'methods')
+  const userMounted = findProperty(user, 'mounted')
+  const userUnmounted = findProperty(user, 'unmounted')
+
+  if (userMethods && userMethods.value.type !== 'ObjectExpression') return null
+
+  const data = userData
+    ? parseProperty(`data () {
+        const userState = (${functionSource(userData)}).call(this) || {}
+        const policyState = (${functionSource(policyData)}).call(this) || {}
+        return { ...userState, ...policyState }
+      }`)
+    : policyData
+
+  const policyMethodNames = new Set(policyMethods.value.properties.map(propertyName))
+  const methods = parseProperty('methods: {}')
+  methods.value.properties = [
+    ...(userMethods ? userMethods.value.properties.filter(property => !policyMethodNames.has(propertyName(property))) : []),
+    ...policyMethods.value.properties
+  ]
+
+  const mounted = userMounted
+    ? parseProperty(`mounted () {
+        (${functionSource(policyMounted)}).call(this)
+        return (${functionSource(userMounted)}).call(this)
+      }`)
+    : policyMounted
+
+  const unmounted = userUnmounted
+    ? parseProperty(`unmounted () {
+        try {
+          return (${functionSource(userUnmounted)}).call(this)
+        } finally {
+          (${functionSource(policyUnmounted)}).call(this)
+        }
+      }`)
+    : policyUnmounted
+
+  const replaced = new Set(['data', 'methods', 'mounted', 'unmounted'])
+  const merged = {
+    ...user,
+    properties: [
+      ...user.properties.filter(property => !replaced.has(propertyName(property))),
+      data,
+      methods,
+      mounted,
+      unmounted
+    ]
+  }
+
+  return CONTROL_POLICY_MARKER + '\nexport default ' + escodegen.generate(merged, {
+    format: { indent: { style: '  ' } }
+  })
+}
+
 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'
+    if (setupMatch || !/<template(?:\s|>)/i.test(format)) return format
+    return format + '\n<script>\n' + CONTROL_POLICY_MARKER + '\n' +
+      buildDashboardPolicyOptionsSource().trim() + '\n</script>\n'
   }
 
   const scriptStart = scriptMatch.index + scriptMatch[0].length
@@ -417,33 +740,23 @@ function injectControlPolicy (format) {
   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)
+  let wrapped
+  try {
+    wrapped = mergeDashboardOptions(source)
+  } catch (_) {
+    return format
   }
-
-  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)
+  if (!wrapped) return format
+  return format.slice(0, scriptStart) + '\n' + wrapped + '\n' + format.slice(scriptEnd)
 }
 
 module.exports = {
   CONTROL_POLICY_MARKER,
   FEEDBACK_TOPIC_FIELDS,
   buildControlPolicyMixinSource,
+  buildDashboardPolicyOptionsSource,
   createControlPanelPolicy,
   injectControlPolicy,
+  mergeDashboardOptions,
   normalizeControlFeedback
 }

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "node-red-contrib-room-tools",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "Room panel message generator and authenticated region gateway for Node-RED and MUSE Automator",
   "license": "UNLICENSED",
   "keywords": ["node-red"],
+  "dependencies": {
+    "acorn": "^8.15.0",
+    "escodegen": "^2.1.0"
+  },
   "files": ["gateway.cjs", "room-gateway.js", "room-gateway.html", "room-message.js", "room-message.html", "control-panel.js", "control-panel.html", "control-policy.js", "CONTROL_PANEL_AI_GUIDE.md", "README.md"],
   "node-red": {
     "nodes": {