loupedeck-commander 1.2.3 → 1.2.4

package/common/utils.mjs

@@ -1,29 +1,30 @@
-import { readFileSync, writeFileSync } from 'node:fs'
-
-/**
- * Read a JSON File
- */
-export function readJSONFile (fileName) {
-  let data
-  try {
-    data = readFileSync(fileName, 'utf8')
-    return JSON.parse(data)
-  } catch (error) {
-    return data
-  }
-}
-
-/**
- * Write a JSON File
- */
-export function writeJSONFile (fileName, jsonObj) {
-  const data = JSON.stringify(jsonObj, null, 4)
-  writeFileSync(fileName, data)
-}
-
-export function calcDelta (data, delta, max = 100) {
-  data = data + delta
-  if (data > max) { data = max }
-  if (data < 0) { data = 0 }
-  return data
-}
+import { readFileSync, writeFileSync } from 'node:fs'
+
+/**
+ * Read a JSON File
+ */
+export function readJSONFile (fileName) {
+  let data
+  try {
+    data = readFileSync(fileName, 'utf8')
+    return JSON.parse(data)
+  } catch (error) {
+    console.info(`Error reading File: ${fileName}`)
+    return data
+  }
+}
+
+/**
+ * Write a JSON File
+ */
+export function writeJSONFile (fileName, jsonObj) {
+  const data = JSON.stringify(jsonObj, null, 4)
+  writeFileSync(fileName, data)
+}
+
+export function calcDelta (data, delta, max = 100) {
+  data = data + delta
+  if (data > max) { data = max }
+  if (data < 0) { data = 0 }
+  return data
+}

package/config.json

@@ -1,9 +1,9 @@
-{
-    "application": "Example",
-    "profiles": [
-        {
-            "name": "profile1",
-            "file": "profile-1.json"
-        }
-    ]
+{
+    "application": "Example",
+    "profiles": [
+        {
+            "name": "profile-1",
+            "file": "profile-1.json"
+        }
+    ]
 }

package/eslint.config.mjs

@@ -1,9 +1,9 @@
-import globals from "globals";
-import pluginJs from "@eslint/js";
-
-
-/** @type {import('eslint').Linter.Config[]} */
-export default [
-  {languageOptions: { globals: globals.browser }},
-  pluginJs.configs.recommended,
+import globals from "globals";
+import pluginJs from "@eslint/js";
+
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  {languageOptions: { globals: globals.browser }},
+  pluginJs.configs.recommended,
 ];

package/example/ExampleDeviceHandler.mjs

@@ -1,44 +1,44 @@
-import { HAPTIC } from 'loupedeck'
-import { BaseLoupeDeckHandler } from '../common/BaseLoupeDeckHandler.mjs'
-
-/**
-* Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
- */
-export class ExampleDeviceHandler extends BaseLoupeDeckHandler {
-  /**
-   * Handle different Vibration-Feedback on OK (true), and NOK (false)
-   * @param {*} ok
-   */
-  async vibrateHandler (ok) {
-    if (ok) { await this.device.vibrate(HAPTIC.REV_FASTEST) } else {
-      this.device.vibrate(HAPTIC.RUMBLE2)
-    }
-  }
-
-  /**
-   * Handle Button-Up Events with Vibration Handler
-   * @param {*} event
-   */
-  async onButtonUp (event) {
-    const res = await super.onButtonUp(event)
-    await this.vibrateHandler(res)
-  }
-
-  /**
-   * Handle Knob-Rotation Events with Vibration Handler
-   * @param {*} event
-   */
-  async onRotate (event) {
-    const res = await super.onRotate(event)
-    await this.vibrateHandler(res)
-  }
-
-  /**
-   * Handle Touch-End Events with Vibration Handler
-   * @param {*} event
-   */
-  async onTouchEnd (event) {
-    const res = await super.onTouchEnd(event)
-    await this.vibrateHandler(res)
-  }
-}
+import { HAPTIC } from 'loupedeck'
+import { BaseLoupeDeckHandler } from '../common/BaseLoupeDeckHandler.mjs'
+
+/**
+* Our Special-Handler just used the Default - and adds Vibration after triggers through Button-Releases
+ */
+export class ExampleDeviceHandler extends BaseLoupeDeckHandler {
+  /**
+   * Handle different Vibration-Feedback on OK (true), and NOK (false)
+   * @param {*} ok
+   */
+  async vibrateHandler (ok) {
+    if (ok) { await this.device.vibrate(HAPTIC.REV_FASTEST) } else {
+      this.device.vibrate(HAPTIC.RUMBLE2)
+    }
+  }
+
+  /**
+   * Handle Button-Up Events with Vibration Handler
+   * @param {*} event
+   */
+  async onButtonUp (event) {
+    const res = await super.onButtonUp(event)
+    await this.vibrateHandler(res)
+  }
+
+  /**
+   * Handle Knob-Rotation Events with Vibration Handler
+   * @param {*} event
+   */
+  async onRotate (event) {
+    const res = await super.onRotate(event)
+    await this.vibrateHandler(res)
+  }
+
+  /**
+   * Handle Touch-End Events with Vibration Handler
+   * @param {*} event
+   */
+  async onTouchEnd (event) {
+    const res = await super.onTouchEnd(event)
+    await this.vibrateHandler(res)
+  }
+}

package/example/example.mjs

@@ -1,21 +1,21 @@
-import { ExampleDeviceHandler } from './ExampleDeviceHandler.mjs'
-
-const handler = new ExampleDeviceHandler('config.json')
-
-
-/**
- * Stop the handlers when a signal like SIGINT or SIGTERM arrive
- * @param {*} signal 
- */
-const stopHandler = async(signal) =>  {
-  console.log(`Receiving ${signal} => Stopping processes.`)
-  await handler.stop()
-}
-
-// Initiating the signal handlers:
-// see https://www.tutorialspoint.com/unix/unix-signals-traps.htm
-process.on('SIGINT', async (signal) => { stopHandler(signal) })
-process.on('SIGTERM', async (signal) => { stopHandler(signal) })
-
-// Initiating a process
-await handler.start()
+import { ExampleDeviceHandler } from './ExampleDeviceHandler.mjs'
+
+const handler = new ExampleDeviceHandler('config.json')
+
+
+/**
+ * Stop the handlers when a signal like SIGINT or SIGTERM arrive
+ * @param {*} signal 
+ */
+const stopHandler = async(signal) =>  {
+  console.log(`Receiving ${signal} => Stopping processes.`)
+  await handler.stop()
+}
+
+// Initiating the signal handlers:
+// see https://www.tutorialspoint.com/unix/unix-signals-traps.htm
+process.on('SIGINT', async (signal) => { stopHandler(signal) })
+process.on('SIGTERM', async (signal) => { stopHandler(signal) })
+
+// Initiating a process
+await handler.start()

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,69 +1,69 @@
-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){
-      LogError("Missing essential options in dictionary => Quitting\n",res,options)
-      return false
-    }
-
-    this.cmd = cmd
-    this.options = options
-    this.formattedCommand = this.formatString(cmd, options)    
-    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 = new String(args)
-      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)    
+    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 = new String(args)
+      process.stdout.write(str.toString())
+    }
+  }
+
+  LogInfo(...args){
+    let str = new String(args)
+    process.stdout.write(str.toString())
+  }
+}
+
+

package/interfaces/httpif.mjs

@@ -1,81 +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 = {}) {
-    url1 = super.call(url1, options)
-    let myURL
-    try {
-      myURL = new url.URL(url1)
-      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: Stopping\n")
-    
-  }
-
-  Check(options) {
-    var res= super.Check(options)
-    if (res <0)
-        return res
-    if (!options.hostname)
-        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: Stopping\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
+    })
+  }
+}