fix: variable handling operates on debounced

updates

changed: restructured variable definitions to
include variable paths

fix: variable parsing for non-numerics

Author: janikwitzig

src/actions/common.ts

@@ -95,8 +95,9 @@ export function createCommonActions(self: InstanceBaseExt<WingConfig>): Companio
 	const send = self.connection!.sendCommand.bind(self.connection)
 	const ensureLoaded = self.stateHandler!.ensureLoaded.bind(self.stateHandler)
 	const state = self.stateHandler?.state
+	const logger = self.logger
 	if (!state) {
-		self.logger!.error('State handler or state is not available for creating common actions')
+		logger?.error('State handler or state is not available for creating common actions')
 		throw new Error('State handler or state is not available')
 	}
 	const transitions = self.transitions

src/handlers/connection-handler.ts

@@ -1,17 +1,18 @@
 import osc, { OscMessage } from 'osc'
-import { ModuleLogger } from './logger.js'
+
 import { EventEmitter } from 'events'
 import { OSCSomeArguments } from '@companion-module/base'
+import { ModuleLogger } from './logger.js'
 
 /**
  * Handles OSC UDP connection management, message sending, and event emission for the Behringer Wing module.
  * Emits 'message', 'error', and 'close' events.
  */
 export class ConnectionHandler extends EventEmitter {
 	private osc: osc.UDPPort
-	private logger?: ModuleLogger
 	private subscriptionTimer?: NodeJS.Timeout
 	private subscriptionInterval: number = 9000
+	private logger?: ModuleLogger
 
 	/**
 	 * Create a new ConnectionHandler.
@@ -60,7 +61,8 @@ export class ConnectionHandler extends EventEmitter {
 		})
 
 		this.osc.on('message', (msg: OscMessage) => {
-			this.logger?.debug(`Received ${JSON.stringify(msg)}`)
+			const stringValue = (msg.args as osc.MetaArgument[])[0].value
+			this.logger?.debug(`State updated for ${msg.address}: ${stringValue}`)
 			this.emit('message', msg)
 		})
 
@@ -157,8 +159,7 @@ export class ConnectionHandler extends EventEmitter {
 			args: args,
 		}
 		this.osc.send(command)
-		// this.osc.send({ address: cmd, args: [] }) // a bit ugly, but needed to keep the desk state up to date in companion
 		if (preventLog) return
-		this.logger?.debug(`Sending OSC command: ${JSON.stringify(command)}`)
+		this.logger?.debug(`Sending OSC command: ${command.address} ${argument ?? ''}`)
 	}
 }

src/handlers/device-detector.ts

@@ -1,7 +1,7 @@
 import osc from 'osc'
 import { WingModel } from '../models/types.js'
-import { ModuleLogger } from './logger.js'
 import { EventEmitter } from 'events'
+import { ModuleLogger } from './logger.js'
 
 export interface DeviceInfo {
 	deviceName: string
@@ -25,8 +25,8 @@ export class WingDeviceDetector extends EventEmitter implements WingDeviceDetect
 	private osc?: osc.UDPPort
 	private knownDevices = new Map<string, DeviceInfo>()
 	private queryTimer: NodeJS.Timeout | undefined
-	private logger?: ModuleLogger
 	private noDeviceTimeout: NodeJS.Timeout | undefined
+	private logger?: ModuleLogger
 
 	constructor(logger?: ModuleLogger) {
 		super()

src/handlers/feedback-handler.ts

@@ -1,9 +1,9 @@
 import EventEmitter from 'events'
-import { ModuleLogger } from './logger.js'
 import debounceFn from 'debounce-fn'
 import { FeedbackId } from '../feedbacks.js'
 import { OscMessage } from 'osc'
 import { WingSubscriptions } from '../state/index.js'
+import { ModuleLogger } from './logger.js'
 
 /**
  * Handles feedback updates based on incoming OSC messages and manages feedback subscriptions.
@@ -12,9 +12,9 @@ import { WingSubscriptions } from '../state/index.js'
 export class FeedbackHandler extends EventEmitter {
 	private readonly messageFeedbacks = new Set<FeedbackId>()
 	private readonly debounceMessageFeedbacks: () => void
-	private logger?: ModuleLogger
 	private pollTimeout?: NodeJS.Timeout
 	private pollInterval: number = 3000
+	private logger: ModuleLogger | undefined
 
 	subscriptions?: WingSubscriptions
 
@@ -24,8 +24,8 @@ export class FeedbackHandler extends EventEmitter {
 	 */
 	constructor(logger?: ModuleLogger) {
 		super()
-		this.logger = logger
 
+		this.logger = logger
 		this.subscriptions = new WingSubscriptions()
 
 		this.debounceMessageFeedbacks = debounceFn(
@@ -47,16 +47,17 @@ export class FeedbackHandler extends EventEmitter {
 	 * Process an OSC message and trigger feedback checks if needed.
 	 * @param msg OSC message to process.
 	 */
-	processMessage(msg: OscMessage): void {
-		this.logger?.debug(`Processing message for feedbacks: ${msg.address}`)
-
-		const toUpdate = this.subscriptions?.getFeedbacks(msg.address)
-		if (toUpdate === undefined) {
-			return
-		}
-		if (toUpdate.length > 0) {
-			toUpdate.forEach((f) => this.messageFeedbacks.add(f))
-			this.debounceMessageFeedbacks()
+	processMessage(msgs: Set<OscMessage>): void {
+		this.logger?.debug(`Processing messages for feedbacks`)
+		for (const msg of msgs) {
+			const toUpdate = this.subscriptions?.getFeedbacks(msg.address)
+			if (toUpdate === undefined) {
+				return
+			}
+			if (toUpdate.length > 0) {
+				toUpdate.forEach((f) => this.messageFeedbacks.add(f))
+				this.debounceMessageFeedbacks()
+			}
 		}
 	}
 

src/handlers/logger.ts

@@ -8,21 +8,22 @@ type LoggerFunction = (level: LogLevel, message: string) => void
 export class ModuleLogger {
 	private moduleName: string
 	private loggerFn?: LoggerFunction
+	private enabled: boolean
 	debugMode: boolean
 	timestamps: boolean
 
 	/**
 	 * Create a new ModuleLogger.
+	 *
 	 * @param moduleName Name to prefix log messages.
 	 * @param loggerFn Optional custom log function.
-	 * @param debugMode Whether to include source location information in logs.
-	 * @param timestamps Whether to include timestamps in logs.
 	 */
 	constructor(moduleName: string, loggerFn?: LoggerFunction) {
 		this.moduleName = moduleName
 		this.loggerFn = loggerFn
 		this.debugMode = false
 		this.timestamps = false
+		this.enabled = true
 	}
 
 	/**
@@ -38,6 +39,7 @@ export class ModuleLogger {
 	 * @param message Message to log.
 	 */
 	debug(message: string): void {
+		if (!this.enabled) return
 		const msg = this.formatMessage(message)
 		if (this.loggerFn) {
 			this.loggerFn('debug', `[${this.moduleName}] ${msg}`)
@@ -51,6 +53,7 @@ export class ModuleLogger {
 	 * @param message Message to log.
 	 */
 	info(message: string): void {
+		if (!this.enabled) return
 		const msg = this.formatMessage(message)
 		if (this.loggerFn) {
 			this.loggerFn('info', `[${this.moduleName}] ${msg}`)
@@ -64,6 +67,7 @@ export class ModuleLogger {
 	 * @param message Message to log.
 	 */
 	error(message: string): void {
+		if (!this.enabled) return
 		const msg = this.formatMessage(message)
 		if (this.loggerFn) {
 			this.loggerFn('error', `[${this.moduleName}] ${msg}`)
@@ -77,6 +81,7 @@ export class ModuleLogger {
 	 * @param message Message to log.
 	 */
 	warn(message: string): void {
+		if (!this.enabled) return
 		const msg = this.formatMessage(message)
 		if (this.loggerFn) {
 			this.loggerFn('warn', `[${this.moduleName}] ${msg}`)
@@ -85,6 +90,14 @@ export class ModuleLogger {
 		}
 	}
 
+	enable(): void {
+		this.enabled = true
+	}
+
+	disable(): void {
+		this.enabled = false
+	}
+
 	/**
 	 * Format the message with optional timestamp and source location.
 	 * @private

src/handlers/osc-forwarder.ts

@@ -4,20 +4,22 @@ import { ModuleLogger } from './logger.js'
 
 export class OscForwarder {
 	private port: osc.UDPPort | undefined
-	private logger: ModuleLogger
+	private logger: ModuleLogger | undefined
 
-	constructor(logger: ModuleLogger) {
+	constructor(logger?: ModuleLogger) {
 		this.logger = logger
 	}
 
-	setup(enabled: boolean | undefined, host?: string, port?: number): void {
+	setup(enabled: boolean | undefined, host?: string, port?: number, logger?: ModuleLogger): void {
 		this.close()
 
+		this.logger = logger
+
 		if (!enabled || !host || !port) {
 			return
 		}
 
-		this.logger.info(`Setting up OSC forwarder to ${host}:${port}`)
+		this.logger?.info(`Setting up OSC forwarder to ${host}:${port}`)
 		try {
 			this.port = new osc.UDPPort({
 				localAddress: '0.0.0.0',
@@ -28,21 +30,21 @@ export class OscForwarder {
 			})
 
 			this.port.on('error', (err: Error): void => {
-				this.logger.warn(`OSC Forwarder Error: ${err.message}`)
+				this.logger?.warn(`OSC Forwarder Error: ${err.message}`)
 			})
 
 			this.port.open()
-			this.logger.info(`OSC forwarding enabled to ${host}:${port}`)
+			this.logger?.info(`OSC forwarding enabled to ${host}:${port}`)
 		} catch (err: any) {
-			this.logger.error(`Failed to setup OSC forwarder: ${err?.message ?? err}`)
+			this.logger?.error(`Failed to setup OSC forwarder: ${err?.message ?? err}`)
 		}
 	}
 
 	send(message: OscMessage): void {
 		try {
 			this.port?.send(message)
 		} catch (err: any) {
-			this.logger.warn(`OSC forward send failed: ${err?.message ?? err}`)
+			this.logger?.warn(`OSC forward send failed: ${err?.message ?? err}`)
 		}
 	}
 

src/handlers/state-handler.ts

@@ -1,19 +1,19 @@
 import EventEmitter from 'events'
-import { ModuleLogger } from './logger.js'
 import { ModelSpec } from '../models/types.js'
 import { WingState } from '../state/index.js'
 import PQueue from 'p-queue'
 import osc, { OscMessage } from 'osc'
 import debounceFn from 'debounce-fn'
+import { ModuleLogger } from './logger.js'
 
 /**
  * Manages the internal state of the Behringer Wing, processes OSC messages, and emits state updates.
  * Handles request queueing and state synchronization.
  */
 export class StateHandler extends EventEmitter {
 	private model: ModelSpec
+	private logger: ModuleLogger | undefined
 	state?: WingState
-	private logger?: ModuleLogger
 
 	private inFlightRequests: { [path: string]: () => void } = {}
 	private readonly requestQueue: PQueue = new PQueue({
@@ -35,8 +35,8 @@ export class StateHandler extends EventEmitter {
 	constructor(model: ModelSpec, logger?: ModuleLogger) {
 		super()
 		this.model = model
-		this.state = new WingState(model)
 		this.logger = logger
+		this.state = new WingState(model)
 
 		this.debounceUpdateCompanion = debounceFn(this.updateCompanionWithState.bind(this), {
 			wait: 200,
@@ -99,22 +99,27 @@ export class StateHandler extends EventEmitter {
 	 * Process an OSC message, update state, and emit events as needed.
 	 * @param msg OSC message to process.
 	 */
-	processMessage(msg: OscMessage): void {
-		const { address, args } = msg
-
-		const wasExpected = !!this.inFlightRequests[msg.address]
-		if (this.inFlightRequests[msg.address]) {
-			this.logger?.debug(`Received answer for request ${msg.address}`)
-			this.inFlightRequests[msg.address]()
-			delete this.inFlightRequests[msg.address]
-		}
+	processMessage(msgs: Set<OscMessage>): void {
+		for (const msg of msgs) {
+			const { address, args } = msg
+
+			const wasExpected = !!this.inFlightRequests[msg.address]
+			if (this.inFlightRequests[msg.address]) {
+				this.logger?.debug(`Received answer for request ${msg.address}`)
+				this.inFlightRequests[msg.address]()
+				delete this.inFlightRequests[msg.address]
+			}
 
-		this.state?.set(address, args as osc.MetaArgument[])
-		this.logger?.debug(`State updated for ${address} with args: ${JSON.stringify(args)}`)
+			const value = args as osc.MetaArgument[]
+			this.state?.set(address, value)
 
-		const hadStructuralChange = this.updateLists(msg)
-		if (!wasExpected && hadStructuralChange) {
-			this.requestUpdate()
+			const stringValue = value[0].value
+			this.logger?.debug(`State updated for ${address}: ${stringValue}`)
+
+			const hadStructuralChange = this.updateLists(msg)
+			if (!wasExpected && hadStructuralChange) {
+				this.requestUpdate()
+			}
 		}
 	}