node-poweredup 10.0.0 → 10.1.0

package/dist/node/hub.js

@@ -1,778 +0,0 @@
-"use strict";
-/**
- * Hub - Main hub class for LEGO Powered UP hubs
- *
- * Follows the event-driven pattern from node-coral/node-wedo/node-controllab.
- * Hubs emit device attach/detach events when peripherals are connected/disconnected.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DuploTrainBase = exports.RemoteControl = exports.TechnicMediumHub = exports.MoveHub = exports.WeDo2Hub = exports.LWP3Hub = exports.BaseHub = void 0;
-exports.createHub = createHub;
-const events_1 = require("events");
-const types_1 = require("./types");
-const connection_1 = require("./connection");
-const Protocol = __importStar(require("./protocol"));
-const WeDo2Protocol = __importStar(require("./protocol-wedo"));
-const commands = __importStar(require("./commands"));
-const devices_1 = require("./devices");
-// ============================================================================
-// Hub Base Class
-// ============================================================================
-/**
- * Base class for all LEGO Powered UP hubs
- */
-class BaseHub extends events_1.EventEmitter {
-    constructor(peripheral, hubType) {
-        super();
-        this._ports = new Map();
-        this._devices = new Map(); // Registered device instances
-        this._isConnected = false;
-        this._peripheral = peripheral;
-        this.hubType = hubType;
-        this._properties = {
-            name: peripheral.name || "",
-            firmwareVersion: "",
-            hardwareVersion: "",
-            batteryLevel: 0,
-            rssi: peripheral.rssi || 0,
-            batteryType: types_1.BatteryType.NORMAL,
-            primaryMACAddress: "",
-        };
-    }
-    /**
-     * Get hub name
-     */
-    get name() {
-        return this._properties.name;
-    }
-    /**
-     * Get firmware version
-     */
-    get firmwareVersion() {
-        return this._properties.firmwareVersion;
-    }
-    /**
-     * Get hardware version
-     */
-    get hardwareVersion() {
-        return this._properties.hardwareVersion;
-    }
-    /**
-     * Get battery level (0-100)
-     */
-    get batteryLevel() {
-        return this._properties.batteryLevel;
-    }
-    /**
-     * Get RSSI signal strength
-     */
-    get rssi() {
-        return this._properties.rssi;
-    }
-    /**
-     * Check if hub is connected
-     */
-    get isConnected() {
-        return this._isConnected;
-    }
-    /**
-     * Get attached ports
-     */
-    get ports() {
-        return new Map(this._ports);
-    }
-    /**
-     * Get port info by port ID
-     */
-    getPort(portId) {
-        return this._ports.get(portId);
-    }
-    /**
-     * Get ports by device type
-     */
-    getPortsByType(deviceType) {
-        const result = [];
-        for (const [, port] of this._ports) {
-            if (port.deviceType === deviceType) {
-                result.push(port);
-            }
-        }
-        return result;
-    }
-    /**
-     * Wait for a device of a specific type to be attached
-     * @param deviceType The device type to wait for
-     * @param timeout Timeout in milliseconds (default: 10000)
-     * @returns Promise that resolves to the Device
-     */
-    async waitForDeviceByType(deviceType, timeout = 10000) {
-        // Check if device is already attached
-        for (const [portId, port] of this._ports) {
-            if (port.deviceType === deviceType) {
-                return this._getOrCreateDevice(portId, port);
-            }
-        }
-        // Wait for device to be attached
-        return new Promise((resolve, reject) => {
-            const timeoutId = setTimeout(() => {
-                this.removeListener("attach", attachHandler);
-                reject(new Error(`Timeout waiting for device type ${deviceType}`));
-            }, timeout);
-            const attachHandler = (deviceInfo) => {
-                if (deviceInfo.deviceType === deviceType) {
-                    clearTimeout(timeoutId);
-                    this.removeListener("attach", attachHandler);
-                    resolve(this._getOrCreateDevice(deviceInfo.portId, deviceInfo));
-                }
-            };
-            this.on("attach", attachHandler);
-        });
-    }
-    /**
-     * Wait for a device at a specific port
-     * @param portName The port name (e.g., "A", "B", "LEFT", "RIGHT")
-     * @param timeout Timeout in milliseconds (default: 10000)
-     * @returns Promise that resolves to the Device
-     */
-    async waitForDeviceAtPort(portName, timeout = 10000) {
-        const portId = this._portNameToId(portName);
-        // Check if device is already attached
-        const existingPort = this._ports.get(portId);
-        if (existingPort) {
-            return this._getOrCreateDevice(portId, existingPort);
-        }
-        // Wait for device to be attached
-        return new Promise((resolve, reject) => {
-            const timeoutId = setTimeout(() => {
-                this.removeListener("attach", attachHandler);
-                reject(new Error(`Timeout waiting for device at port ${portName}`));
-            }, timeout);
-            const attachHandler = (deviceInfo) => {
-                if (deviceInfo.portId === portId) {
-                    clearTimeout(timeoutId);
-                    this.removeListener("attach", attachHandler);
-                    resolve(this._getOrCreateDevice(portId, deviceInfo));
-                }
-            };
-            this.on("attach", attachHandler);
-        });
-    }
-    /**
-     * Get existing device or create and register a new one
-     */
-    _getOrCreateDevice(portId, portInfo) {
-        let device = this._devices.get(portId);
-        if (!device) {
-            device = (0, devices_1.createDevice)(this, portInfo);
-            this._devices.set(portId, device);
-        }
-        return device;
-    }
-    /**
-     * Convert port name to port ID
-     */
-    _portNameToId(portName) {
-        const name = portName.toUpperCase();
-        // WeDo2 uses different port IDs
-        if (this.hubType === types_1.HubType.WEDO2_SMART_HUB) {
-            switch (name) {
-                case "A": return 1;
-                case "B": return 2;
-                case "LED": return 6;
-                default:
-                    const num = parseInt(portName, 10);
-                    if (!isNaN(num))
-                        return num;
-                    throw new Error(`Unknown port name: ${portName}`);
-            }
-        }
-        // LWP3 hubs (Powered UP, Boost, Technic, etc.)
-        switch (name) {
-            case "A": return 0;
-            case "B": return 1;
-            case "C": return 2;
-            case "D": return 3;
-            case "LEFT": return 0;
-            case "RIGHT": return 1;
-            default:
-                // Try to parse as number
-                const num = parseInt(portName, 10);
-                if (!isNaN(num))
-                    return num;
-                throw new Error(`Unknown port name: ${portName}`);
-        }
-    }
-    /**
-     * Sleep for a specified time
-     * @param ms Time to sleep in milliseconds
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    // Event emitter type overrides
-    on(event, listener) {
-        return super.on(event, listener);
-    }
-    once(event, listener) {
-        return super.once(event, listener);
-    }
-    emit(event, ...args) {
-        return super.emit(event, ...args);
-    }
-}
-exports.BaseHub = BaseHub;
-// ============================================================================
-// LWP3 Hub (Powered UP, Boost, Technic, etc.)
-// ============================================================================
-/**
- * Hub class for LWP3-based hubs (Powered UP, Boost Move Hub, Technic, etc.)
- */
-class LWP3Hub extends BaseHub {
-    constructor(peripheral, hubType) {
-        super(peripheral, hubType);
-        this._connection = new connection_1.LWP3Connection(peripheral);
-    }
-    /**
-     * Connect to the hub and initialize
-     */
-    async connect() {
-        // Set up message handler before connecting
-        this._connection.on("message", (message) => this._handleMessage(message));
-        this._connection.on("disconnect", () => this._handleDisconnect());
-        // Connect to the peripheral
-        await this._connection.open();
-        this._isConnected = true;
-        // Request hub properties
-        await this._requestHubProperties();
-        // Enable button notifications
-        await this._enableButtonNotifications();
-        this.emit("connect");
-    }
-    /**
-     * Disconnect from the hub
-     */
-    async disconnect() {
-        if (!this._isConnected)
-            return;
-        const message = commands.disconnect();
-        await this._connection.send(message);
-        await this._connection.close();
-        this._isConnected = false;
-    }
-    /**
-     * Shutdown the hub (power off)
-     */
-    async shutdown() {
-        if (!this._isConnected)
-            return;
-        const message = commands.shutdown();
-        await this._connection.send(message);
-        this._isConnected = false;
-    }
-    /**
-     * Set the hub name
-     */
-    async setName(name) {
-        const message = commands.setName(name);
-        await this._connection.send(message);
-        this._properties.name = name;
-    }
-    /**
-     * Set the hub LED color
-     */
-    async setLEDColor(color) {
-        const ledPort = this._findPortByDeviceType(types_1.DeviceType.HUB_LED);
-        if (ledPort === undefined) {
-            throw new Error("Hub LED not found");
-        }
-        const message = commands.ledColor(ledPort, color);
-        await this._connection.send(message);
-    }
-    /**
-     * Set the hub LED to RGB color
-     */
-    async setLEDRGB(red, green, blue) {
-        const ledPort = this._findPortByDeviceType(types_1.DeviceType.HUB_LED);
-        if (ledPort === undefined) {
-            throw new Error("Hub LED not found");
-        }
-        const message = commands.ledRGB(ledPort, red, green, blue);
-        await this._connection.send(message);
-    }
-    /**
-     * Run a motor at a given power level (-100 to 100)
-     */
-    async motorPower(portId, power) {
-        const message = commands.motorPower(portId, power);
-        await this._connection.send(message);
-    }
-    /**
-     * Run a motor at a given speed (-100 to 100) with power regulation
-     */
-    async motorSpeed(portId, speed, maxPower = 100) {
-        const message = commands.motorSpeed(portId, speed, maxPower);
-        await this._connection.send(message);
-    }
-    /**
-     * Run a motor for a specified time
-     */
-    async motorRunForTime(portId, time, speed, maxPower = 100, endState = types_1.BrakingStyle.BRAKE) {
-        const message = commands.motorRunForTime(portId, time, speed, maxPower, endState);
-        await this._connection.send(message);
-    }
-    /**
-     * Run a motor for a specified number of degrees
-     */
-    async motorRunForDegrees(portId, degrees, speed, maxPower = 100, endState = types_1.BrakingStyle.BRAKE) {
-        const message = commands.motorRunForDegrees(portId, degrees, speed, maxPower, endState);
-        await this._connection.send(message);
-    }
-    /**
-     * Move motor to absolute position
-     */
-    async motorGotoPosition(portId, position, speed, maxPower = 100, endState = types_1.BrakingStyle.BRAKE) {
-        const message = commands.motorGotoPosition(portId, position, speed, maxPower, endState);
-        await this._connection.send(message);
-    }
-    /**
-     * Stop a motor
-     */
-    async motorStop(portId) {
-        const message = commands.motorStop(portId);
-        await this._connection.send(message);
-    }
-    /**
-     * Brake a motor
-     */
-    async motorBrake(portId) {
-        const message = commands.motorBrake(portId);
-        await this._connection.send(message);
-    }
-    /**
-     * Subscribe to sensor updates on a port
-     */
-    async subscribe(portId, mode = 0, deltaInterval = 1) {
-        const message = commands.subscribe(portId, mode, deltaInterval);
-        await this._connection.send(message);
-    }
-    /**
-     * Unsubscribe from sensor updates on a port
-     */
-    async unsubscribe(portId, mode = 0) {
-        const message = commands.unsubscribe(portId, mode);
-        await this._connection.send(message);
-    }
-    /**
-     * Send raw command to the hub
-     */
-    async sendRaw(data) {
-        await this._connection.send(data);
-    }
-    // ========================================================================
-    // Private methods
-    // ========================================================================
-    async _requestHubProperties() {
-        // Request hub name
-        await this._connection.send(commands.requestProperty(Protocol.HubProperty.ADVERTISING_NAME));
-        // Request firmware version
-        await this._connection.send(commands.requestProperty(Protocol.HubProperty.FW_VERSION));
-        // Request hardware version
-        await this._connection.send(commands.requestProperty(Protocol.HubProperty.HW_VERSION));
-        // Request battery level and enable updates
-        await this._connection.send(commands.requestProperty(Protocol.HubProperty.BATTERY_VOLTAGE));
-        await this._connection.send(commands.enablePropertyUpdates(Protocol.HubProperty.BATTERY_VOLTAGE));
-    }
-    async _enableButtonNotifications() {
-        await this._connection.send(commands.enablePropertyUpdates(Protocol.HubProperty.BUTTON));
-    }
-    _handleMessage(message) {
-        switch (message.type) {
-            case Protocol.MessageType.HUB_PROPERTIES:
-                this._handleHubProperty(message);
-                break;
-            case Protocol.MessageType.HUB_ATTACHED_IO:
-                this._handleAttachedIO(message);
-                break;
-            case Protocol.MessageType.PORT_VALUE_SINGLE:
-                this._handlePortValue(message);
-                break;
-            case Protocol.MessageType.PORT_OUTPUT_COMMAND_FEEDBACK:
-                this._handleCommandFeedback(message);
-                break;
-            case Protocol.MessageType.HUB_ALERTS:
-                this._handleAlert(message);
-                break;
-            case Protocol.MessageType.GENERIC_ERROR_MESSAGES:
-                this._handleError(message);
-                break;
-        }
-    }
-    _handleHubProperty(message) {
-        switch (message.property) {
-            case Protocol.HubProperty.ADVERTISING_NAME:
-                this._properties.name = message.payload.toString("ascii");
-                break;
-            case Protocol.HubProperty.FW_VERSION:
-                this._properties.firmwareVersion = this._parseVersion(message.payload);
-                break;
-            case Protocol.HubProperty.HW_VERSION:
-                this._properties.hardwareVersion = this._parseVersion(message.payload);
-                break;
-            case Protocol.HubProperty.BATTERY_VOLTAGE:
-                this._properties.batteryLevel = message.payload[0];
-                this.emit("batteryLevel", this._properties.batteryLevel);
-                break;
-            case Protocol.HubProperty.BUTTON:
-                const buttonState = message.payload[0] === 1 ? types_1.ButtonState.PRESSED : types_1.ButtonState.RELEASED;
-                this.emit("button", buttonState);
-                break;
-            case Protocol.HubProperty.RSSI:
-                this._properties.rssi = message.payload.readInt8(0);
-                this.emit("rssi", this._properties.rssi);
-                break;
-        }
-    }
-    _handleAttachedIO(message) {
-        const portId = message.portId;
-        const event = message.event;
-        switch (event) {
-            case types_1.PortEvent.ATTACHED:
-            case types_1.PortEvent.ATTACHED_VIRTUAL: {
-                const deviceType = message.deviceType;
-                const deviceInfo = {
-                    portId,
-                    deviceType,
-                    hardwareRevision: message.hardwareRevision,
-                    softwareRevision: message.softwareRevision,
-                };
-                this._ports.set(portId, deviceInfo);
-                this.emit("attach", deviceInfo);
-                break;
-            }
-            case types_1.PortEvent.DETACHED: {
-                const deviceInfo = this._ports.get(portId);
-                if (deviceInfo) {
-                    this._ports.delete(portId);
-                    this.emit("detach", portId);
-                }
-                break;
-            }
-        }
-    }
-    _handlePortValue(message) {
-        const device = this._devices.get(message.portId);
-        if (device && typeof device.handlePortValue === "function") {
-            device.handlePortValue(message.value);
-        }
-    }
-    _handleCommandFeedback(message) {
-        // Command feedback can be used for promise resolution
-    }
-    _handleAlert(message) {
-        this.emit("alert", message.alertType);
-    }
-    _handleError(message) {
-        this.emit("error", new Error(`Hub error: command 0x${message.commandType.toString(16)}, error 0x${message.errorCode.toString(16)}`));
-    }
-    _handleDisconnect() {
-        this._isConnected = false;
-        this._ports.clear();
-        this.emit("disconnect");
-    }
-    _findPortByDeviceType(deviceType) {
-        for (const [portId, port] of this._ports) {
-            if (port.deviceType === deviceType) {
-                return portId;
-            }
-        }
-        return undefined;
-    }
-    _parseVersion(buffer) {
-        if (buffer.length < 4)
-            return "";
-        const version = buffer.readUInt32LE(0);
-        const major = (version >> 28) & 0x0f;
-        const minor = (version >> 24) & 0x0f;
-        const bugfix = (version >> 16) & 0xff;
-        const build = version & 0xffff;
-        return `${major}.${minor}.${bugfix}.${build}`;
-    }
-}
-exports.LWP3Hub = LWP3Hub;
-// ============================================================================
-// WeDo 2.0 Hub
-// ============================================================================
-/**
- * Hub class for WeDo 2.0 Smart Hub
- */
-class WeDo2Hub extends BaseHub {
-    constructor(peripheral) {
-        super(peripheral, types_1.HubType.WEDO2_SMART_HUB);
-        this._connection = new connection_1.WeDo2Connection(peripheral);
-    }
-    /**
-     * Connect to the hub and initialize
-     */
-    async connect() {
-        // Set up message handlers - WeDo2Connection emits separate events for each message type
-        this._connection.on("port", (message) => this._handlePortInfo(message));
-        this._connection.on("sensor", (message) => this._handleSensorValue(message));
-        this._connection.on("button", (message) => this._handleButton(message));
-        this._connection.on("battery", (message) => this._handleBattery(message));
-        this._connection.on("disconnect", () => this._handleDisconnect());
-        // Connect to the peripheral
-        await this._connection.open();
-        this._isConnected = true;
-        // Note: Internal devices (LED, voltage, current, piezo) are detected via
-        // PORT_TYPE notifications during connection, so no manual registration needed
-        this.emit("connect");
-    }
-    /**
-     * Disconnect from the hub
-     */
-    async disconnect() {
-        if (!this._isConnected)
-            return;
-        await this._connection.close();
-        this._isConnected = false;
-    }
-    /**
-     * Shutdown the hub (WeDo 2.0 doesn't support remote shutdown)
-     */
-    async shutdown() {
-        await this.disconnect();
-    }
-    /**
-     * Set the hub name
-     */
-    async setName(name) {
-        const message = WeDo2Protocol.createWeDo2SetName(name);
-        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.NAME_ID, message);
-        this._properties.name = name;
-    }
-    /**
-     * Set the hub LED color
-     */
-    async setLEDColor(color) {
-        const message = WeDo2Protocol.createWeDo2LEDColor(WeDo2Protocol.WEDO2_PORT_MAP.HUB_LED, color);
-        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.MOTOR_VALUE_WRITE, message);
-    }
-    /**
-     * Set the hub LED to RGB color
-     */
-    async setLEDRGB(red, green, blue) {
-        const message = WeDo2Protocol.createWeDo2LEDRGB(WeDo2Protocol.WEDO2_PORT_MAP.HUB_LED, red, green, blue);
-        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.MOTOR_VALUE_WRITE, message);
-    }
-    /**
-     * Run a motor at a given power level (-100 to 100)
-     */
-    async motorPower(portId, power) {
-        const message = WeDo2Protocol.createWeDo2MotorPower(portId, power);
-        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.MOTOR_VALUE_WRITE, message);
-    }
-    /**
-     * Stop a motor
-     */
-    async motorStop(portId) {
-        await this.motorPower(portId, 0);
-    }
-    /**
-     * Play a tone
-     */
-    async playTone(frequency, duration) {
-        const message = WeDo2Protocol.createWeDo2PiezoTone(WeDo2Protocol.WEDO2_PORT_MAP.PIEZO, frequency, duration);
-        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.MOTOR_VALUE_WRITE, message);
-    }
-    /**
-     * Stop tone playback
-     */
-    async stopTone() {
-        const message = WeDo2Protocol.createWeDo2PiezoStop(WeDo2Protocol.WEDO2_PORT_MAP.PIEZO);
-        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.MOTOR_VALUE_WRITE, message);
-    }
-    /**
-     * Set sensor mode
-     */
-    async setSensorMode(portId, mode) {
-        const deviceInfo = this._ports.get(portId);
-        if (!deviceInfo) {
-            throw new Error(`Port ${portId} not found`);
-        }
-        const message = WeDo2Protocol.createWeDo2Subscribe(portId, deviceInfo.deviceType, mode, true);
-        await this._connection.send(WeDo2Protocol.WEDO2_CHARACTERISTICS.PORT_TYPE_WRITE, message);
-    }
-    /**
-     * Send raw command
-     */
-    async sendRaw(characteristicUUID, data) {
-        await this._connection.send(characteristicUUID, data);
-    }
-    // ========================================================================
-    // Private methods
-    // ========================================================================
-    _handleMessage(message) {
-        switch (message.kind) {
-            case "port":
-                this._handlePortInfo(message);
-                break;
-            case "sensor":
-                this._handleSensorValue(message);
-                break;
-            case "button":
-                this._handleButton(message);
-                break;
-            case "battery":
-                this._handleBattery(message);
-                break;
-        }
-    }
-    _handlePortInfo(message) {
-        const portId = message.portId;
-        const deviceType = message.deviceType;
-        if (deviceType !== types_1.DeviceType.UNKNOWN) {
-            const deviceInfo = {
-                portId,
-                deviceType: deviceType,
-            };
-            this._ports.set(portId, deviceInfo);
-            this.emit("attach", deviceInfo);
-        }
-        else {
-            const deviceInfo = this._ports.get(portId);
-            if (deviceInfo) {
-                this._ports.delete(portId);
-                this.emit("detach", portId);
-            }
-        }
-    }
-    _handleSensorValue(message) {
-        // Sensor value events are handled by device classes
-    }
-    _handleButton(message) {
-        const buttonState = message.pressed ? types_1.ButtonState.PRESSED : types_1.ButtonState.RELEASED;
-        this.emit("button", buttonState);
-    }
-    _handleBattery(message) {
-        this._properties.batteryLevel = message.level;
-        this.emit("batteryLevel", message.level);
-    }
-    _handleDisconnect() {
-        this._isConnected = false;
-        this._ports.clear();
-        this.emit("disconnect");
-    }
-}
-exports.WeDo2Hub = WeDo2Hub;
-// ============================================================================
-// Hub Factory
-// ============================================================================
-/**
- * Create a hub instance based on the hub type
- */
-function createHub(peripheral, hubType) {
-    switch (hubType) {
-        case types_1.HubType.WEDO2_SMART_HUB:
-            return new WeDo2Hub(peripheral);
-        case types_1.HubType.MOVE_HUB:
-            return new MoveHub(peripheral);
-        case types_1.HubType.TECHNIC_MEDIUM_HUB:
-            return new TechnicMediumHub(peripheral);
-        case types_1.HubType.REMOTE_CONTROL:
-            return new RemoteControl(peripheral);
-        case types_1.HubType.DUPLO_TRAIN_BASE:
-            return new DuploTrainBase(peripheral);
-        default:
-            return new LWP3Hub(peripheral, hubType);
-    }
-}
-// ============================================================================
-// Specialized Hub Classes
-// ============================================================================
-/**
- * Move Hub (Boost) with built-in tilt sensor and motors
- */
-class MoveHub extends LWP3Hub {
-    constructor(peripheral) {
-        super(peripheral, types_1.HubType.MOVE_HUB);
-    }
-    get motorAPort() { return 0; }
-    get motorBPort() { return 1; }
-    get tiltSensorPort() { return 58; }
-    get colorSensorPort() { return 59; }
-}
-exports.MoveHub = MoveHub;
-/**
- * Technic Medium Hub with gyro and accelerometer
- */
-class TechnicMediumHub extends LWP3Hub {
-    constructor(peripheral) {
-        super(peripheral, types_1.HubType.TECHNIC_MEDIUM_HUB);
-    }
-    get gyroPort() { return 99; }
-    get accelerometerPort() { return 97; }
-    get tiltSensorPort() { return 98; }
-}
-exports.TechnicMediumHub = TechnicMediumHub;
-/**
- * Remote Control
- */
-class RemoteControl extends LWP3Hub {
-    constructor(peripheral) {
-        super(peripheral, types_1.HubType.REMOTE_CONTROL);
-    }
-    get leftButtonPort() { return 0; }
-    get rightButtonPort() { return 1; }
-}
-exports.RemoteControl = RemoteControl;
-/**
- * Duplo Train Base
- */
-class DuploTrainBase extends LWP3Hub {
-    constructor(peripheral) {
-        super(peripheral, types_1.HubType.DUPLO_TRAIN_BASE);
-    }
-    get motorPort() { return 0; }
-    get colorSensorPort() { return 18; }
-    get speedometerPort() { return 19; }
-    get speakerPort() { return 1; }
-    async playSound(sound) {
-        const message = commands.duploTrainSound(this.speakerPort, sound);
-        await this._connection.send(message);
-    }
-}
-exports.DuploTrainBase = DuploTrainBase;
-//# sourceMappingURL=hub.js.map