reaper-osc/dist/Handlers.js

Controls Cockos Reaper using OSC

"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[0] === 'track') {
            const trackNumber = parseInt(message.addressParts[1]);
            // 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[0] === 'track' && message.addressParts[2] === 'fx') {
            const fxNumber = parseInt(message.addressParts[3]);
            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