reaper-osc 0.2.0 → 0.3.0

package/dist/Handlers.js

@@ -1,157 +1,157 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FloatMessageHandler = exports.StringMessageHandler = exports.IntegerMessageHandler = exports.BooleanMessageHandler = exports.TrackFxMessageHandler = exports.TransportMessageHandler = exports.TrackMessageHandler = void 0;
-/**
- * Routes messages to the appropriate track
- * @param trackSelector A function that can be used to get a track
- * */
-class TrackMessageHandler {
-    constructor(trackSelector) {
-        this.trackSelector = trackSelector;
-    }
-    handle(message) {
-        if (message.addressParts[1] === 'track') {
-            const trackNumber = parseInt(message.addressParts[2]);
-            // If NaN, probably means that it's a message for the selected track - ignore
-            if (isNaN(trackNumber)) {
-                return false;
-            }
-            const track = this.trackSelector(trackNumber);
-            if (track !== null) {
-                return track.receive(message);
-            }
-        }
-        return false;
-    }
-}
-exports.TrackMessageHandler = TrackMessageHandler;
-/** Routes messages to the transport */
-class TransportMessageHandler {
-    constructor(transport) {
-        this.transport = transport;
-    }
-    handle(message) {
-        return this.transport.receive(message);
-    }
-}
-exports.TransportMessageHandler = TransportMessageHandler;
-/** Routes messages to the appropriate track fx */
-class TrackFxMessageHandler {
-    constructor(fxSelector) {
-        this.fxSelector = fxSelector;
-    }
-    handle(message) {
-        if (message.addressParts[1] === 'track' && message.addressParts[3] === 'fx') {
-            const fxNumber = parseInt(message.addressParts[4]);
-            if (isNaN(fxNumber)) {
-                throw new Error('Expected an integer');
-            }
-            const fx = this.fxSelector(fxNumber);
-            if (fx !== null) {
-                return fx.receive(message);
-            }
-        }
-        return false;
-    }
-}
-exports.TrackFxMessageHandler = TrackFxMessageHandler;
-/**
- * Handles an OSC message containing a single boolean value (0 or 1)
- * @param address The address of the message to handle
- * @param callback The callback to be called when a message with the specified OSC address is received
- */
-class BooleanMessageHandler {
-    constructor(address, callback) {
-        this.address = address;
-        this._callback = callback;
-    }
-    handle(message) {
-        var _a;
-        if (message.address === this.address) {
-            const booleanValue = ((_a = message.args[0]) === null || _a === void 0 ? void 0 : _a.value) === 1 ? true : false;
-            this._callback(booleanValue);
-            return true;
-        }
-        return false;
-    }
-}
-exports.BooleanMessageHandler = BooleanMessageHandler;
-class IntegerMessageHandler {
-    constructor(address, callback) {
-        this.address = address;
-        this._callback = callback;
-    }
-    handle(message) {
-        if (message.address === this.address) {
-            const messageValue = message.args[0].value;
-            let intValue;
-            switch (typeof messageValue) {
-                case 'number':
-                    intValue = messageValue;
-                    break;
-                case 'string':
-                    intValue = parseInt(messageValue);
-                    if (isNaN(intValue)) {
-                        throw new Error('Expected an integer');
-                    }
-                    break;
-                default:
-                    throw new Error('Expected an integer');
-            }
-            this._callback(intValue);
-            return true;
-        }
-        return false;
-    }
-}
-exports.IntegerMessageHandler = IntegerMessageHandler;
-class StringMessageHandler {
-    constructor(address, callback) {
-        this.address = address;
-        this.address = address;
-        this._callback = callback;
-    }
-    handle(message) {
-        if (message.address === this.address) {
-            const messageValue = message.args[0].value;
-            if (typeof messageValue !== 'string') {
-                throw new Error('Expected a string');
-            }
-            this._callback(messageValue);
-            return true;
-        }
-        return false;
-    }
-}
-exports.StringMessageHandler = StringMessageHandler;
-class FloatMessageHandler {
-    constructor(address, callback) {
-        this.address = address;
-        this.address = address;
-        this._callback = callback;
-    }
-    handle(message) {
-        if (message.address === this.address) {
-            const messageValue = message.args[0].value;
-            let floatValue;
-            switch (typeof messageValue) {
-                case 'number':
-                    floatValue = messageValue;
-                    break;
-                case 'string':
-                    floatValue = parseFloat(messageValue);
-                    if (isNaN(floatValue)) {
-                        throw new Error('Expected an integer');
-                    }
-                    break;
-                default:
-                    throw new Error('Expected an integer');
-            }
-            this._callback(floatValue);
-            return true;
-        }
-        return false;
-    }
-}
-exports.FloatMessageHandler = FloatMessageHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatMessageHandler = exports.StringMessageHandler = exports.IntegerMessageHandler = exports.BooleanMessageHandler = exports.TrackFxMessageHandler = exports.TransportMessageHandler = exports.TrackMessageHandler = void 0;
+/**
+ * Routes messages to the appropriate track
+ * @param trackSelector A function that can be used to get a track
+ * */
+class TrackMessageHandler {
+    constructor(trackSelector) {
+        this.trackSelector = trackSelector;
+    }
+    handle(message) {
+        if (message.addressParts[1] === 'track') {
+            const trackNumber = parseInt(message.addressParts[2]);
+            // If NaN, probably means that it's a message for the selected track - ignore
+            if (isNaN(trackNumber)) {
+                return false;
+            }
+            const track = this.trackSelector(trackNumber);
+            if (track !== null) {
+                return track.receive(message);
+            }
+        }
+        return false;
+    }
+}
+exports.TrackMessageHandler = TrackMessageHandler;
+/** Routes messages to the transport */
+class TransportMessageHandler {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    handle(message) {
+        return this.transport.receive(message);
+    }
+}
+exports.TransportMessageHandler = TransportMessageHandler;
+/** Routes messages to the appropriate track fx */
+class TrackFxMessageHandler {
+    constructor(fxSelector) {
+        this.fxSelector = fxSelector;
+    }
+    handle(message) {
+        if (message.addressParts[1] === 'track' && message.addressParts[3] === 'fx') {
+            const fxNumber = parseInt(message.addressParts[4]);
+            if (isNaN(fxNumber)) {
+                throw new Error('Expected an integer');
+            }
+            const fx = this.fxSelector(fxNumber);
+            if (fx !== null) {
+                return fx.receive(message);
+            }
+        }
+        return false;
+    }
+}
+exports.TrackFxMessageHandler = TrackFxMessageHandler;
+/**
+ * Handles an OSC message containing a single boolean value (0 or 1)
+ * @param address The address of the message to handle
+ * @param callback The callback to be called when a message with the specified OSC address is received
+ */
+class BooleanMessageHandler {
+    constructor(address, callback) {
+        this.address = address;
+        this._callback = callback;
+    }
+    handle(message) {
+        var _a;
+        if (message.address === this.address) {
+            const booleanValue = ((_a = message.args[0]) === null || _a === void 0 ? void 0 : _a.value) === 1 ? true : false;
+            this._callback(booleanValue);
+            return true;
+        }
+        return false;
+    }
+}
+exports.BooleanMessageHandler = BooleanMessageHandler;
+class IntegerMessageHandler {
+    constructor(address, callback) {
+        this.address = address;
+        this._callback = callback;
+    }
+    handle(message) {
+        if (message.address === this.address) {
+            const messageValue = message.args[0].value;
+            let intValue;
+            switch (typeof messageValue) {
+                case 'number':
+                    intValue = messageValue;
+                    break;
+                case 'string':
+                    intValue = parseInt(messageValue);
+                    if (isNaN(intValue)) {
+                        throw new Error('Expected an integer');
+                    }
+                    break;
+                default:
+                    throw new Error('Expected an integer');
+            }
+            this._callback(intValue);
+            return true;
+        }
+        return false;
+    }
+}
+exports.IntegerMessageHandler = IntegerMessageHandler;
+class StringMessageHandler {
+    constructor(address, callback) {
+        this.address = address;
+        this.address = address;
+        this._callback = callback;
+    }
+    handle(message) {
+        if (message.address === this.address) {
+            const messageValue = message.args[0].value;
+            if (typeof messageValue !== 'string') {
+                throw new Error('Expected a string');
+            }
+            this._callback(messageValue);
+            return true;
+        }
+        return false;
+    }
+}
+exports.StringMessageHandler = StringMessageHandler;
+class FloatMessageHandler {
+    constructor(address, callback) {
+        this.address = address;
+        this.address = address;
+        this._callback = callback;
+    }
+    handle(message) {
+        if (message.address === this.address) {
+            const messageValue = message.args[0].value;
+            let floatValue;
+            switch (typeof messageValue) {
+                case 'number':
+                    floatValue = messageValue;
+                    break;
+                case 'string':
+                    floatValue = parseFloat(messageValue);
+                    if (isNaN(floatValue)) {
+                        throw new Error('Expected an integer');
+                    }
+                    break;
+                default:
+                    throw new Error('Expected an integer');
+            }
+            this._callback(floatValue);
+            return true;
+        }
+        return false;
+    }
+}
+exports.FloatMessageHandler = FloatMessageHandler;
 //# sourceMappingURL=Handlers.js.map

package/dist/Messages.d.ts

@@ -1,70 +1,70 @@
-export interface ISendOscMessage {
-    (message: OscMessage): void;
-}
-export declare enum OscArgumentType {
-    /** 32-bit Integer */
-    INT = "i",
-    /** 64-bit Integer */
-    LONG = "h",
-    /** 32-bit Floating Point */
-    FLOAT = "f",
-    /** 64-bit Floating Point */
-    DOUBLE = "d",
-    /** String */
-    STRING = "s",
-    /** Single Character */
-    CHAR = "c",
-    /** Binary blob */
-    BLOB = "b",
-    /** True. No bytes are allocated in the argument data */
-    TRUE = "T",
-    /** False. No bytes are allocated in the argument data */
-    FALSE = "F",
-    /** Null. No bytes are allocated in the argument data */
-    NULL = "N",
-    /** Impulse aka bang. Used for event triggers. No bytes are allocated in the argument data */
-    IMPULSE = "I",
-    COLOR = "r",
-    MIDI = "m"
-}
-export declare class OscArgument<T> {
-    readonly type: OscArgumentType;
-    readonly value: T;
-    constructor(type: OscArgumentType, value: T);
-}
-export declare class StringArgument extends OscArgument<string> {
-    constructor(value: string);
-}
-export declare class IntArgument extends OscArgument<number> {
-    constructor(value: number);
-}
-export declare class BoolArgument extends IntArgument {
-    constructor(value: boolean);
-}
-export declare class FloatArgument extends OscArgument<number> {
-    constructor(value: number);
-}
-export declare class OscMessage {
-    readonly address: string;
-    readonly addressParts: string[];
-    readonly args: OscArgument<unknown>[];
-    constructor(address: string, args?: OscArgument<unknown>[]);
-}
-export declare class StringMessage extends OscMessage {
-    constructor(address: string, value: string);
-}
-export declare class BooleanMessage extends OscMessage {
-    constructor(address: string, value: boolean);
-}
-export declare class ActionMessage extends OscMessage {
-    constructor(commandId: string | number, value?: number | null);
-}
-export declare class ToggleMessage extends OscMessage {
-    constructor(address: string);
-}
-export declare class IntegerMessage extends OscMessage {
-    constructor(address: string, value: number);
-}
-export declare class FloatMessage extends OscMessage {
-    constructor(address: string, value: number);
-}
+export interface ISendOscMessage {
+    (message: OscMessage): void;
+}
+export declare enum OscArgumentType {
+    /** 32-bit Integer */
+    INT = "i",
+    /** 64-bit Integer */
+    LONG = "h",
+    /** 32-bit Floating Point */
+    FLOAT = "f",
+    /** 64-bit Floating Point */
+    DOUBLE = "d",
+    /** String */
+    STRING = "s",
+    /** Single Character */
+    CHAR = "c",
+    /** Binary blob */
+    BLOB = "b",
+    /** True. No bytes are allocated in the argument data */
+    TRUE = "T",
+    /** False. No bytes are allocated in the argument data */
+    FALSE = "F",
+    /** Null. No bytes are allocated in the argument data */
+    NULL = "N",
+    /** Impulse aka bang. Used for event triggers. No bytes are allocated in the argument data */
+    IMPULSE = "I",
+    COLOR = "r",
+    MIDI = "m"
+}
+export declare class OscArgument<T> {
+    readonly type: OscArgumentType;
+    readonly value: T;
+    constructor(type: OscArgumentType, value: T);
+}
+export declare class StringArgument extends OscArgument<string> {
+    constructor(value: string);
+}
+export declare class IntArgument extends OscArgument<number> {
+    constructor(value: number);
+}
+export declare class BoolArgument extends IntArgument {
+    constructor(value: boolean);
+}
+export declare class FloatArgument extends OscArgument<number> {
+    constructor(value: number);
+}
+export declare class OscMessage {
+    readonly address: string;
+    readonly addressParts: string[];
+    readonly args: OscArgument<unknown>[];
+    constructor(address: string, args?: OscArgument<unknown>[]);
+}
+export declare class StringMessage extends OscMessage {
+    constructor(address: string, value: string);
+}
+export declare class BooleanMessage extends OscMessage {
+    constructor(address: string, value: boolean);
+}
+export declare class ActionMessage extends OscMessage {
+    constructor(commandId: string | number, value?: number | null);
+}
+export declare class ToggleMessage extends OscMessage {
+    constructor(address: string);
+}
+export declare class IntegerMessage extends OscMessage {
+    constructor(address: string, value: number);
+}
+export declare class FloatMessage extends OscMessage {
+    constructor(address: string, value: number);
+}