loupedeck-commander 1.4.0 → 1.4.2

package/common/cmd-executer.mjs

@@ -1,16 +1,16 @@
-import { exec } from 'child_process'
-
-export async function sh (cmd) {
-  // console.log('TRIGGER -> ', cmd)
-
-  return new Promise(function (resolve, reject) {
-    exec(cmd, (err, stdout, stderr) => {
-      console.log('executed cmd, stdout:', stdout)
-      if (err) {
-        reject(err)
-      } else {
-        resolve({ stdout, stderr })
-      }
-    })
-  })
-}
+import { exec } from 'child_process'
+
+export async function sh (cmd) {
+  // console.log('TRIGGER -> ', cmd)
+
+  return new Promise(function (resolve, reject) {
+    exec(cmd, (err, stdout, stderr) => {
+      console.log('executed cmd, stdout:', stdout)
+      if (err) {
+        reject(err)
+      } else {
+        resolve({ stdout, stderr })
+      }
+    })
+  })
+}

package/common/index.mjs

@@ -1,5 +1,5 @@
-import { BaseLoupeDeckHandler } from './BaseLoupeDeckHandler.mjs'
-
-module.exports = {
-  BaseLoupeDeckHandler
-}
+import { BaseLoupeDeckHandler } from './BaseLoupeDeckHandler.mjs'
+
+module.exports = {
+  BaseLoupeDeckHandler
+}

package/common/utils.mjs

@@ -1,106 +1,106 @@
-import { readFileSync, writeFileSync } from 'node:fs'
-import YAML from 'yaml'
-
-/**
- * Read a Config file in either JSON or YAML Fileformat
- * @param {string} fileName - The name of the file to read
- * @returns {object} - The parsed object from the file
- */
-export function readConfigFile (fileName) {
-  let obj = undefined
-  try {
-    //console.log("Reading File:", fileName)
-    let data = readFileSync(fileName, 'utf8')
-    // If the file is a YAML file, parse it
-    if (fileName.endsWith('.yaml') || fileName.endsWith('.yml')) {
-      obj = YAML.parse(data)
-    } else if (fileName.endsWith('.json')) {
-      // If the file is a JSON file, parse it
-      obj = JSON.parse(data)
-      // automatically convert all json to yaml
-      writeYAMLFile(fileName.replace(".json",".yaml"), obj)
-    }
-  } catch (error) {
-    console.info(`Error reading File: ${fileName}`, error)
-  }
-  return obj
-}
-
-/**
- * Write a JSON File
- */
-export function writeJSONFile (fileName, jsonObj) {
-  const data = JSON.stringify(jsonObj, null, 4)
-  writeFileSync(fileName, data)
-}
-
-/**
- * Write a JSON File
- */
-export function writeYAMLFile (fileName, jsonObj) {
-  const data = YAML.stringify(jsonObj)
-  writeFileSync(fileName, data)
-}
-
-
-/**
- * Calculate the delta of a value within a range between min and max with overflow
- * @param {*} data 
- * @param {*} delta 
- * @param {*} min 
- * @param {*} max 
- * @returns 
- */
-export function calcDelta (data, delta, min = 0, max = 100) {
-  data = data + delta
-  if (data > max) { data = min }
-  else if (data < min) { data = max }
-  return data
-}
-
-/**
- * Invert a color in hex format (#RRGGBB) to its inverted color
- * @param {*} colorAsHex 
- * @returns 
- */
-export function invertColor(colorAsHex){
-  let rgb = colorToRGB(colorAsHex)
-  for (var i = 0; i < rgb.length; i++) {
-    rgb[i] = (i === 3 ? 1 : 255) - rgb[i];
-  }
-  let invertedColor = `#${rgb[0].toString(16)}${rgb[1].toString(16)}${rgb[2].toString(16)})`
-  //let invertedColor = `#${rgb[0].toString(16).padStart(2, '0')}${rgb[1].toString(16).padStart(2, '0')}${rgb[2].toString(16).padStart(2, '0')})`
-  //console.log("invert", colorAsHex,"=>",invertedColor)
-  return invertedColor
-}
-
-/**
- * Convert a color in hex format (#RRGGBB) to RGB array
- * @param {*} colorAsHex 
- * @returns 
- */
-export function colorToRGB(colorAsHex){
-  const r = parseInt(colorAsHex.slice(1, 3), 16)
-  const g = parseInt(colorAsHex.slice(3, 5), 16)
-  const b = parseInt(colorAsHex.slice(5, 7), 16)
-  return [r,g,b]
-}
-
-/**
- * Synchronize the parameters of a node with the default node
- * @param {*} node 
- * @param {*} defaultnode 
- * @returns node
- */
-export function syncParams(node, defaultnode){
-  if (node === undefined || defaultnode === undefined)
-    return node
-  let keys = Object.keys(defaultnode)
-  for (var i=0;i<keys.length;i++){
-    let key = keys[i]
-    if (!(key in node))
-      node[key] = defaultnode[key]
-  }
-  return node
-}
-
+import { readFileSync, writeFileSync } from 'node:fs'
+import YAML from 'yaml'
+
+/**
+ * Read a Config file in either JSON or YAML Fileformat
+ * @param {string} fileName - The name of the file to read
+ * @returns {object} - The parsed object from the file
+ */
+export function readConfigFile (fileName) {
+  let obj = undefined
+  try {
+    //console.log("Reading File:", fileName)
+    let data = readFileSync(fileName, 'utf8')
+    // If the file is a YAML file, parse it
+    if (fileName.endsWith('.yaml') || fileName.endsWith('.yml')) {
+      obj = YAML.parse(data)
+    } else if (fileName.endsWith('.json')) {
+      // If the file is a JSON file, parse it
+      obj = JSON.parse(data)
+      // automatically convert all json to yaml
+      writeYAMLFile(fileName.replace(".json",".yaml"), obj)
+    }
+  } catch (error) {
+    console.info(`Error reading File: ${fileName}`, error)
+  }
+  return obj
+}
+
+/**
+ * Write a JSON File
+ */
+export function writeJSONFile (fileName, jsonObj) {
+  const data = JSON.stringify(jsonObj, null, 4)
+  writeFileSync(fileName, data)
+}
+
+/**
+ * Write a JSON File
+ */
+export function writeYAMLFile (fileName, jsonObj) {
+  const data = YAML.stringify(jsonObj)
+  writeFileSync(fileName, data)
+}
+
+
+/**
+ * Calculate the delta of a value within a range between min and max with overflow
+ * @param {*} data 
+ * @param {*} delta 
+ * @param {*} min 
+ * @param {*} max 
+ * @returns 
+ */
+export function calcDelta (data, delta, min = 0, max = 100) {
+  data = data + delta
+  if (data > max) { data = min }
+  else if (data < min) { data = max }
+  return data
+}
+
+/**
+ * Invert a color in hex format (#RRGGBB) to its inverted color
+ * @param {*} colorAsHex 
+ * @returns 
+ */
+export function invertColor(colorAsHex){
+  let rgb = colorToRGB(colorAsHex)
+  for (var i = 0; i < rgb.length; i++) {
+    rgb[i] = (i === 3 ? 1 : 255) - rgb[i];
+  }
+  let invertedColor = `#${rgb[0].toString(16)}${rgb[1].toString(16)}${rgb[2].toString(16)})`
+  //let invertedColor = `#${rgb[0].toString(16).padStart(2, '0')}${rgb[1].toString(16).padStart(2, '0')}${rgb[2].toString(16).padStart(2, '0')})`
+  //console.log("invert", colorAsHex,"=>",invertedColor)
+  return invertedColor
+}
+
+/**
+ * Convert a color in hex format (#RRGGBB) to RGB array
+ * @param {*} colorAsHex 
+ * @returns 
+ */
+export function colorToRGB(colorAsHex){
+  const r = parseInt(colorAsHex.slice(1, 3), 16)
+  const g = parseInt(colorAsHex.slice(3, 5), 16)
+  const b = parseInt(colorAsHex.slice(5, 7), 16)
+  return [r,g,b]
+}
+
+/**
+ * Synchronize the parameters of a node with the default node
+ * @param {*} node 
+ * @param {*} defaultnode 
+ * @returns node
+ */
+export function syncParams(node, defaultnode){
+  if (node === undefined || defaultnode === undefined)
+    return node
+  let keys = Object.keys(defaultnode)
+  for (var i=0;i<keys.length;i++){
+    let key = keys[i]
+    if (!(key in node))
+      node[key] = defaultnode[key]
+  }
+  return node
+}
+

package/config.yaml

@@ -1,6 +1,8 @@
-application: Example
-profiles:
-  - name: profile-1
-    file: profile-1.yaml
-  - name: profile-2
-    file: profile-2.yaml
+application: Example
+parameters:
+  verbose: true
+profiles:
+  - name: profile-1
+    file: profile-1.yaml
+  - name: profile-2
+    file: profile-2.yaml

package/index.mjs

@@ -1,3 +1,3 @@
-import { BaseLoupeDeckHandler } from './common/BaseLoupeDeckHandler.mjs'
-
-export { BaseLoupeDeckHandler }
+import { BaseLoupeDeckHandler } from './common/BaseLoupeDeckHandler.mjs'
+
+export { BaseLoupeDeckHandler }

package/interfaces/baseif.mjs

@@ -1,71 +1,71 @@
-import format from 'string-template'
-import { EventEmitter } from 'node:events'
-
-export class BaseIf extends EventEmitter {
-  formattedCommand
-  cmd
-  options
-  call (cmd, options = {}) {
-    var res = this.Check(options)
-    if (res < 0){
-      this.LogError("Missing essential options in dictionary => Quitting\n",res,options)
-      return false
-    }
-
-    this.cmd = cmd
-    this.options = options
-    this.formattedCommand = this.formatString(cmd, options) 
-    this.LogDebug("Formatted command: ", this.formattedCommand,"\n")
-    this.LogDebug("Options",JSON.stringify(options),"\n"   )
-    return this.formattedCommand
-  }
-
-  async stop (){
-    
-  }
-
-  formatString (cmd, options = {}) {
-    let f =""
-    try{
-      f = format(cmd, options)
-    }catch(e){}
-    return f
-  }
-
-  Check(options) {
-    if (!"id" in options)
-        return -1
-    if (!"key" in options)
-      return -2
-    if (!"state" in options)
-      return -3
-    if (!"min" in options)
-      return -4
-    if (!"max" in options)
-      return -5
-    if (!"color" in options)
-      return -6
-    if (!"image" in options)
-      return -7
-    return 0
-  }
-
-  LogError(...args){
-    let str = new String(args)
-    process.stderr.write(str.toString())
-}
-
-  LogDebug(...args){
-    if (this.options && this.options.verbose){
-      let str = args.join(' ')
-      process.stdout.write(str.toString())
-    }
-  }
-
-  LogInfo(...args){
-    let str = new String(args)
-    process.stdout.write(str.toString())
-  }
-}
-
-
+import format from 'string-template'
+import { EventEmitter } from 'node:events'
+
+export class BaseIf extends EventEmitter {
+  formattedCommand
+  cmd
+  options
+  call (cmd, options = {}) {
+    var res = this.Check(options)
+    if (res < 0){
+      this.LogError("Missing essential options in dictionary => Quitting\n",res,options)
+      return false
+    }
+
+    this.cmd = cmd
+    this.options = options
+    this.formattedCommand = this.formatString(cmd, options) 
+    this.LogDebug("Formatted command: ", this.formattedCommand,"\n")
+    this.LogDebug("Options",JSON.stringify(options),"\n"   )
+    return this.formattedCommand
+  }
+
+  async stop (){
+    
+  }
+
+  formatString (cmd, options = {}) {
+    let f =""
+    try{
+      f = format(cmd, options)
+    }catch(e){}
+    return f
+  }
+
+  Check(options) {
+    if (!"id" in options)
+        return -1
+    if (!"key" in options)
+      return -2
+    if (!"state" in options)
+      return -3
+    if (!"min" in options)
+      return -4
+    if (!"max" in options)
+      return -5
+    if (!"color" in options)
+      return -6
+    if (!"image" in options)
+      return -7
+    return 0
+  }
+
+  LogError(...args){
+    let str = new String(args)
+    process.stderr.write(str.toString())
+}
+
+  LogDebug(...args){
+    if (this.options && this.options.verbose){
+      let str = args.join(' ')
+      process.stdout.write(str.toString())
+    }
+  }
+
+  LogInfo(...args){
+    let str = new String(args)
+    process.stdout.write(str.toString())
+  }
+}
+
+

package/interfaces/httpif.mjs

@@ -1,90 +1,90 @@
-import * as http from 'node:http'
-import url from 'node:url'
-import { BaseIf } from './baseif.mjs'
-
-/**
- * Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
- */
-export class HTTPif extends BaseIf {
-  async call (url1, options = {}) {
-    var res = this.Check(options)
-    if (res<0){
-//        this.LogError(`HTTPif call: Missing essential options in dictionary => Quitting`,res,"\n")
-        return false
-    }
-    let urlFormatted = super.call(url1, options)
-    let myURL
-    try {
-      myURL = new url.URL(urlFormatted)
-      await this.get(myURL, options)
-    } catch (e) {
-      this.LogError(`HTTPif: error with URL: ${e.message}\n`)
-      return false
-    }
-    return true
-  }
-
-  async stop(){
-    this.LogInfo("HTTPif: Stopped\n")
-    
-  }
-
-  Check(options) {
-    var res= super.Check(options)
-    if (res <0){
-      this.LogError(`HTTPif: mandatory parameter missing\n`)    
-      return res
-    }
-    if (!options.hostname){
-        this.LogError(`HTTPif: mandatory parameter hostname missing\n`)
-        return -21
-    }
-    return 0
-  }
-
-  /**
-   * Handle a HTTP Get request with Basic Authentification
-   * @param {*} myURL Uri
-   */
-  async get (myURL) {
-    const auth = 'Basic ' + Buffer.from(myURL.username + ':' + myURL.password).toString('base64')
-    const getOptions = {
-      hostname: myURL.hostname,
-      port: myURL.port,
-      path: myURL.pathname,
-      agent: false, // Create a new agent just for this one request
-      headers: {
-        Authorization: auth
-      }
-    }
-
-    this.LogInfo(`HTTPIf: call URL ${myURL} ${getOptions}\n`)
-    
-
-    const prom = new Promise((resolve, reject) => {
-      const req = http.get(getOptions, (response) => {
-        const chunksOfData = []
-
-        response.on('data', (fragments) => {
-          chunksOfData.push(fragments)
-        })
-
-        response.on('end', () => {
-          const responseBody = Buffer.concat(chunksOfData)
-          resolve(responseBody.toString())
-        })
-
-        response.on('error', (error) => {
-          resolve("")
-        })
-      })
-
-      req.on('error', (e) => {
-        this.LogError(`HTTPif: ignore other errors like ERRNOTCONNECTED: ${e.message}\n`)
-        return false
-      });
-    }).catch(function (error) { // (*)
-        return false
-    })
-  }
-}
+import * as http from 'node:http'
+import url from 'node:url'
+import { BaseIf } from './baseif.mjs'
+
+/**
+ * Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
+ */
+export class HTTPif extends BaseIf {
+  async call (url1, options = {}) {
+    var res = this.Check(options)
+    if (res<0){
+//        this.LogError(`HTTPif call: Missing essential options in dictionary => Quitting`,res,"\n")
+        return false
+    }
+    let urlFormatted = super.call(url1, options)
+    let myURL
+    try {
+      myURL = new url.URL(urlFormatted)
+      await this.get(myURL, options)
+    } catch (e) {
+      this.LogError(`HTTPif: error with URL: ${e.message}\n`)
+      return false
+    }
+    return true
+  }
+
+  async stop(){
+    this.LogInfo("HTTPif: Stopped\n")
+    
+  }
+
+  Check(options) {
+    var res= super.Check(options)
+    if (res <0){
+      this.LogError(`HTTPif: mandatory parameter missing\n`)    
+      return res
+    }
+    if (!options.hostname){
+        this.LogError(`HTTPif: mandatory parameter hostname missing\n`)
+        return -21
+    }
+    return 0
+  }
+
+  /**
+   * Handle a HTTP Get request with Basic Authentification
+   * @param {*} myURL Uri
+   */
+  async get (myURL) {
+    const auth = 'Basic ' + Buffer.from(myURL.username + ':' + myURL.password).toString('base64')
+    const getOptions = {
+      hostname: myURL.hostname,
+      port: myURL.port,
+      path: myURL.pathname,
+      agent: false, // Create a new agent just for this one request
+      headers: {
+        Authorization: auth
+      }
+    }
+
+    this.LogInfo(`HTTPIf: call URL ${myURL} ${getOptions}\n`)
+    
+
+    const prom = new Promise((resolve, reject) => {
+      const req = http.get(getOptions, (response) => {
+        const chunksOfData = []
+
+        response.on('data', (fragments) => {
+          chunksOfData.push(fragments)
+        })
+
+        response.on('end', () => {
+          const responseBody = Buffer.concat(chunksOfData)
+          resolve(responseBody.toString())
+        })
+
+        response.on('error', (error) => {
+          resolve("")
+        })
+      })
+
+      req.on('error', (e) => {
+        this.LogError(`HTTPif: ignore other errors like ERRNOTCONNECTED: ${e.message}\n`)
+        return false
+      });
+    }).catch(function (error) { // (*)
+        return false
+    })
+  }
+}

package/interfaces/interfaces.mjs

@@ -1,34 +1,34 @@
-import * as shellif from '../interfaces/shellif.mjs'
-import * as httpif from '../interfaces/httpif.mjs'
-import * as opcuaif from '../interfaces/opcuaif.mjs'
-import { EventEmitter } from 'node:events'
-
-export var opcuainterface = undefined
-export var httpinterface = undefined
-export var shellinterface = undefined
-export var profileEmitter = undefined
-
-export async function InitializeInterfaces(appConfig){
-  if (opcuainterface === undefined ){
-    opcuainterface = new opcuaif.OPCUAIf()
-  }
-  // the opcua interface needs the profile to register nodes with subscriptions:
-  opcuainterface.init(appConfig.parameters,appConfig)
-  if (httpinterface === undefined) 
-    httpinterface = new httpif.HTTPif()
-  if (shellinterface === undefined)
-    shellinterface = new shellif.SHELLif()
-  if (profileEmitter === undefined)
-    profileEmitter = new EventEmitter()
-}
-
-export async function StopInterfaces(){
-  if (opcuainterface !== undefined )
-    await opcuainterface.stop()
-  if (httpinterface !== undefined) 
-    await httpinterface.stop()
-  if (shellinterface !== undefined)
-    await shellinterface.stop()
-  
-  }
-
+import * as shellif from '../interfaces/shellif.mjs'
+import * as httpif from '../interfaces/httpif.mjs'
+import * as opcuaif from '../interfaces/opcuaif.mjs'
+import { EventEmitter } from 'node:events'
+
+export var opcuainterface = undefined
+export var httpinterface = undefined
+export var shellinterface = undefined
+export var profileEmitter = undefined
+
+export async function InitializeInterfaces(appConfig){
+  if (opcuainterface === undefined ){
+    opcuainterface = new opcuaif.OPCUAIf()
+  }
+  // the opcua interface needs the profile to register nodes with subscriptions:
+  opcuainterface.init(appConfig.parameters,appConfig)
+  if (httpinterface === undefined) 
+    httpinterface = new httpif.HTTPif()
+  if (shellinterface === undefined)
+    shellinterface = new shellif.SHELLif()
+  if (profileEmitter === undefined)
+    profileEmitter = new EventEmitter()
+}
+
+export async function StopInterfaces(){
+  if (opcuainterface !== undefined )
+    await opcuainterface.stop()
+  if (httpinterface !== undefined) 
+    await httpinterface.stop()
+  if (shellinterface !== undefined)
+    await shellinterface.stop()
+  
+  }
+