incyclist-devices 1.4.102 → 1.5.1

package/lib/modes/simulator.js

@@ -1,140 +1,140 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const gd_eventlog_1 = require("gd-eventlog");
-const CyclingMode_1 = require("../CyclingMode");
-const power_base_1 = __importDefault(require("./power-base"));
-const MIN_SPEED = 10;
-const config = {
-    name: "Simulator",
-    description: "Simulates a ride with constant speed or power output",
-    properties: [
-        { key: 'mode', name: 'Simulation Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Speed', 'Power'], default: 'Power' },
-        { key: 'delay', name: 'Start Delay', description: 'Delay (in s) at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 2, min: 0, max: 30 },
-        { key: 'power', name: 'Power', description: 'Power (in W) at start of training', condition: (s) => !s.mode || s.mode === 'Power', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 150, min: 25, max: 800 },
-        { key: 'speed', name: 'Speed', description: 'Speed (in km/h) at start of training', condition: (s) => s.mode === 'Speed', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 30, min: 5, max: 50 },
-        { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' }
-    ]
-};
-class SimulatorCyclingMode extends power_base_1.default {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.prevUpdateTS = 0;
-        this.hasBikeUpdate = false;
-        this.event = {};
-        this.logger = adapter.logger || new gd_eventlog_1.EventLogger('SIMMode');
-        this.data = {};
-        this.logger.logEvent({ message: 'constructor', props });
-    }
-    getName() {
-        return config.name;
-    }
-    getDescription() {
-        return config.description;
-    }
-    getProperties() {
-        return config.properties;
-    }
-    getProperty(name) {
-        return config.properties.find(p => p.name === name);
-    }
-    getBikeInitRequest() {
-        return {};
-    }
-    sendBikeUpdate(request) {
-        this.logger.logEvent({ message: 'bike update request', request });
-        const r = request || { refresh: true };
-        if (r.refresh) {
-            if (Object.keys(r).length === 1)
-                return this.prevRequest || {};
-            delete r.refresh;
-        }
-        if (request.slope !== undefined) {
-            if (!this.data)
-                this.data = {};
-            this.data.slope = request.slope;
-        }
-        this.prevRequest = request ? JSON.parse(JSON.stringify(request)) : {};
-        return r;
-    }
-    updateData(bikeData) {
-        const prevData = JSON.parse(JSON.stringify(this.data || {}));
-        const prevSpeed = prevData.speed;
-        const prevRequest = this.prevRequest || {};
-        const data = this.data || {};
-        const bikeType = (this.getSetting('bikeType') || 'Race').toLowerCase();
-        const mode = this.getSetting('mode');
-        delete this.event.gearUpdated;
-        delete this.event.rpmUpdated;
-        try {
-            let rpm = 90;
-            let power = (!mode || mode.toLowerCase() === 'power') ? Number(this.getSetting('power')) : bikeData.power || 0;
-            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
-            let speed = mode.toLowerCase() === 'speed' ? Number(this.getSetting('speed')) : bikeData.speed || 0;
-            let m = this.getWeight();
-            let distanceInternal = prevData.distanceInternal || 0;
-            let ts = Date.now();
-            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-            const t = this.getTimeSinceLastUpdate();
-            let distance = 0;
-            if (!mode || mode.toLowerCase() === 'power') {
-                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
-                speed = res.speed;
-                distance = res.distance;
-            }
-            else if (mode.toLowerCase() === 'speed') {
-                const res = this.calculatePowerAndDistance(speed, slope, m, t, { bikeType });
-                power = res.power;
-                distance = res.distance;
-            }
-            if (prevRequest.targetPower) {
-                power = prevRequest.targetPower;
-                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
-                speed = res.speed;
-                distance = res.distance;
-            }
-            if (prevRequest.maxPower && power > prevRequest.maxPower) {
-                power = prevRequest.maxPower;
-                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
-                speed = res.speed;
-                distance = res.distance;
-            }
-            else if (prevRequest.minPower && power < prevRequest.minPower) {
-                power = prevRequest.minPower;
-                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
-                speed = res.speed;
-                distance = res.distance;
-            }
-            if (power === 0 && speed < MIN_SPEED) {
-                data.speed = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
-                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
-            }
-            else {
-                data.speed = speed;
-                data.distanceInternal = distanceInternal + distance;
-            }
-            data.speed = speed;
-            data.power = Math.round(power);
-            data.distanceInternal = distanceInternal + distance;
-            data.slope = slope;
-            data.pedalRpm = rpm;
-            if (data.time !== undefined)
-                data.time += duration;
-            else
-                data.time = 0;
-            data.heartrate = bikeData.heartrate;
-            data.isPedalling = true;
-            this.prevUpdateTS = ts;
-        }
-        catch (err) {
-            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
-        }
-        this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest, prevSpeed });
-        this.data = data;
-        return data;
-    }
-}
-exports.default = SimulatorCyclingMode;
-SimulatorCyclingMode.isERG = true;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gd_eventlog_1 = require("gd-eventlog");
+const cycling_mode_1 = require("../cycling-mode");
+const power_base_1 = __importDefault(require("./power-base"));
+const MIN_SPEED = 10;
+const config = {
+    name: "Simulator",
+    description: "Simulates a ride with constant speed or power output",
+    properties: [
+        { key: 'mode', name: 'Simulation Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Speed', 'Power'], default: 'Power' },
+        { key: 'delay', name: 'Start Delay', description: 'Delay (in s) at start of training', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 2, min: 0, max: 30 },
+        { key: 'power', name: 'Power', description: 'Power (in W) at start of training', condition: (s) => !s.mode || s.mode === 'Power', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 150, min: 25, max: 800 },
+        { key: 'speed', name: 'Speed', description: 'Speed (in km/h) at start of training', condition: (s) => s.mode === 'Speed', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 30, min: 5, max: 50 },
+        { key: 'bikeType', name: 'Bike Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' }
+    ]
+};
+class SimulatorCyclingMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.prevUpdateTS = 0;
+        this.hasBikeUpdate = false;
+        this.event = {};
+        this.logger = adapter.logger || new gd_eventlog_1.EventLogger('SIMMode');
+        this.data = {};
+        this.logger.logEvent({ message: 'constructor', props });
+    }
+    getName() {
+        return config.name;
+    }
+    getDescription() {
+        return config.description;
+    }
+    getProperties() {
+        return config.properties;
+    }
+    getProperty(name) {
+        return config.properties.find(p => p.name === name);
+    }
+    getBikeInitRequest() {
+        return {};
+    }
+    sendBikeUpdate(request) {
+        this.logger.logEvent({ message: 'bike update request', request });
+        const r = request || { refresh: true };
+        if (r.refresh) {
+            if (Object.keys(r).length === 1)
+                return this.prevRequest || {};
+            delete r.refresh;
+        }
+        if (request.slope !== undefined) {
+            if (!this.data)
+                this.data = {};
+            this.data.slope = request.slope;
+        }
+        this.prevRequest = request ? JSON.parse(JSON.stringify(request)) : {};
+        return r;
+    }
+    updateData(bikeData) {
+        const prevData = JSON.parse(JSON.stringify(this.data || {}));
+        const prevSpeed = prevData.speed;
+        const prevRequest = this.prevRequest || {};
+        const data = this.data || {};
+        const bikeType = (this.getSetting('bikeType') || 'Race').toLowerCase();
+        const mode = this.getSetting('mode');
+        delete this.event.gearUpdated;
+        delete this.event.rpmUpdated;
+        try {
+            let rpm = 90;
+            let power = (!mode || mode.toLowerCase() === 'power') ? Number(this.getSetting('power')) : bikeData.power || 0;
+            let slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            let speed = mode.toLowerCase() === 'speed' ? Number(this.getSetting('speed')) : bikeData.speed || 0;
+            let m = this.getWeight();
+            let distanceInternal = prevData.distanceInternal || 0;
+            let ts = Date.now();
+            let duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
+            const t = this.getTimeSinceLastUpdate();
+            let distance = 0;
+            if (!mode || mode.toLowerCase() === 'power') {
+                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+                speed = res.speed;
+                distance = res.distance;
+            }
+            else if (mode.toLowerCase() === 'speed') {
+                const res = this.calculatePowerAndDistance(speed, slope, m, t, { bikeType });
+                power = res.power;
+                distance = res.distance;
+            }
+            if (prevRequest.targetPower) {
+                power = prevRequest.targetPower;
+                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+                speed = res.speed;
+                distance = res.distance;
+            }
+            if (prevRequest.maxPower && power > prevRequest.maxPower) {
+                power = prevRequest.maxPower;
+                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+                speed = res.speed;
+                distance = res.distance;
+            }
+            else if (prevRequest.minPower && power < prevRequest.minPower) {
+                power = prevRequest.minPower;
+                const res = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+                speed = res.speed;
+                distance = res.distance;
+            }
+            if (power === 0 && speed < MIN_SPEED) {
+                data.speed = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
+                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
+            }
+            else {
+                data.speed = speed;
+                data.distanceInternal = distanceInternal + distance;
+            }
+            data.speed = speed;
+            data.power = Math.round(power);
+            data.distanceInternal = distanceInternal + distance;
+            data.slope = slope;
+            data.pedalRpm = rpm;
+            if (data.time !== undefined)
+                data.time += duration;
+            else
+                data.time = 0;
+            data.heartrate = bikeData.heartrate;
+            data.isPedalling = true;
+            this.prevUpdateTS = ts;
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+        }
+        this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest, prevSpeed });
+        this.data = data;
+        return data;
+    }
+}
+exports.default = SimulatorCyclingMode;
+SimulatorCyclingMode.isERG = true;

package/lib/{DeviceProtocol.d.ts → protocol.d.ts}

@@ -1,74 +1,74 @@
-import { User } from "./types/user";
-export declare const INTERFACE: {
-    SERIAL: string;
-    ANT: string;
-    BLE: string;
-    BLUETOOTH: string;
-    TCPIP: string;
-    SIMULATOR: string;
-};
-export declare type Device = {
-    getID(): string;
-    getName(): string;
-    getPort(): string;
-    getProtocol(): DeviceProtocol;
-    getProtocolName(): string;
-};
-export interface DeviceSettings {
-    name: string;
-    port?: string;
-    userSettings?: User;
-    bikeSettings?: any;
-}
-export declare type DeviceFoundCallback = (device: Device, protocol: DeviceProtocol) => void;
-export declare type ScanFinishedCallback = (id: number) => void;
-export declare type ScanProps = {
-    id: number;
-    onDeviceFound?: DeviceFoundCallback;
-    onScanFinished?: ScanFinishedCallback;
-};
-export interface DeviceProtocol {
-    add(props: DeviceSettings): any;
-    getName(): string;
-    getInterfaces(): Array<string>;
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-    scan(props: ScanProps): void;
-    stopScan(): void;
-    isScanning(): boolean;
-    getDevices(): Array<any>;
-    setAnt(antClass: any): void;
-    getAnt(): any;
-    setSerialPort(serialClass: any): void;
-    getSerialPort(): any;
-    setNetImpl(netClass: any): void;
-    getNetImpl(): any;
-}
-export default class DeviceProtocolBase {
-    devices: Array<Device>;
-    constructor();
-    getName(): string;
-    getInterfaces(): Array<string>;
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-    scan(props: ScanProps): void;
-    stopScan(): void;
-    isScanning(): boolean;
-    add(props: DeviceSettings): void;
-    getDevices(): Array<Device>;
-    setAnt(antClass: any): void;
-    getAnt(): any;
-    setSerialPort(serialClass: any): void;
-    getSerialPort(): void;
-    setNetImpl(netClass: any): void;
-    getNetImpl(): any;
-    setBinding(_bindingClass: any): void;
-    static setAnt(antClass: any): void;
-    static getAnt(): any;
-    static setSerialPort(serialClass: any): void;
-    static getSerialPort(): any;
-    static setNetImpl(netClass: any): void;
-    static getNetImpl(): any;
-}
+import { User } from "./types/user";
+export declare const INTERFACE: {
+    SERIAL: string;
+    ANT: string;
+    BLE: string;
+    BLUETOOTH: string;
+    TCPIP: string;
+    SIMULATOR: string;
+};
+export declare type Device = {
+    getID(): string;
+    getName(): string;
+    getPort(): string;
+    getProtocol(): DeviceProtocol;
+    getProtocolName(): string;
+};
+export interface DeviceSettings {
+    name: string;
+    port?: string;
+    userSettings?: User;
+    bikeSettings?: any;
+}
+export declare type DeviceFoundCallback = (device: Device, protocol: DeviceProtocol) => void;
+export declare type ScanFinishedCallback = (id: number) => void;
+export declare type ScanProps = {
+    id: number;
+    onDeviceFound?: DeviceFoundCallback;
+    onScanFinished?: ScanFinishedCallback;
+};
+export interface DeviceProtocol {
+    add(props: DeviceSettings): any;
+    getName(): string;
+    getInterfaces(): Array<string>;
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    scan(props: ScanProps): void;
+    stopScan(): void;
+    isScanning(): boolean;
+    getDevices(): Array<any>;
+    setAnt(antClass: any): void;
+    getAnt(): any;
+    setSerialPort(serialClass: any): void;
+    getSerialPort(): any;
+    setNetImpl(netClass: any): void;
+    getNetImpl(): any;
+}
+export default class DeviceProtocolBase {
+    devices: Array<Device>;
+    constructor();
+    getName(): string;
+    getInterfaces(): Array<string>;
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    scan(props: ScanProps): void;
+    stopScan(): void;
+    isScanning(): boolean;
+    add(props: DeviceSettings): void;
+    getDevices(): Array<Device>;
+    setAnt(antClass: any): void;
+    getAnt(): any;
+    setSerialPort(serialClass: any): void;
+    getSerialPort(): void;
+    setNetImpl(netClass: any): void;
+    getNetImpl(): any;
+    setBinding(_bindingClass: any): void;
+    static setAnt(antClass: any): void;
+    static getAnt(): any;
+    static setSerialPort(serialClass: any): void;
+    static getSerialPort(): any;
+    static setNetImpl(netClass: any): void;
+    static getNetImpl(): any;
+}

package/lib/{DeviceProtocol.js → protocol.js}

@@ -1,41 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.INTERFACE = void 0;
-exports.INTERFACE = {
-    SERIAL: 'serial',
-    ANT: 'ant',
-    BLE: 'ble',
-    BLUETOOTH: 'bluetooth',
-    TCPIP: 'tcpip',
-    SIMULATOR: 'simulator'
-};
-let _ant, _serial, _net;
-class DeviceProtocolBase {
-    constructor() {
-        this.devices = [];
-    }
-    getName() { throw new Error('not implemented'); }
-    getInterfaces() { throw new Error('not implemented'); }
-    isBike() { throw new Error('not implemented'); }
-    isHrm() { throw new Error('not implemented'); }
-    isPower() { throw new Error('not implemented'); }
-    scan(props) { throw new Error('not implemented'); }
-    stopScan() { throw new Error('not implemented'); }
-    isScanning() { throw new Error('not implemented'); }
-    add(props) { throw new Error('Method not implemented.'); }
-    getDevices() { return this.devices; }
-    setAnt(antClass) { DeviceProtocolBase.setAnt(antClass); }
-    getAnt() { return DeviceProtocolBase.getAnt(); }
-    setSerialPort(serialClass) { DeviceProtocolBase.setSerialPort(serialClass); }
-    getSerialPort() { DeviceProtocolBase.getSerialPort(); }
-    setNetImpl(netClass) { DeviceProtocolBase.setNetImpl(netClass); }
-    getNetImpl() { return DeviceProtocolBase.getNetImpl(); }
-    setBinding(_bindingClass) { }
-    static setAnt(antClass) { _ant = antClass; }
-    static getAnt() { return _ant; }
-    static setSerialPort(serialClass) { _serial = serialClass; }
-    static getSerialPort() { return _serial; }
-    static setNetImpl(netClass) { _net = netClass; }
-    static getNetImpl() { return _net; }
-}
-exports.default = DeviceProtocolBase;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERFACE = void 0;
+exports.INTERFACE = {
+    SERIAL: 'serial',
+    ANT: 'ant',
+    BLE: 'ble',
+    BLUETOOTH: 'bluetooth',
+    TCPIP: 'tcpip',
+    SIMULATOR: 'simulator'
+};
+let _ant, _serial, _net;
+class DeviceProtocolBase {
+    constructor() {
+        this.devices = [];
+    }
+    getName() { throw new Error('not implemented'); }
+    getInterfaces() { throw new Error('not implemented'); }
+    isBike() { throw new Error('not implemented'); }
+    isHrm() { throw new Error('not implemented'); }
+    isPower() { throw new Error('not implemented'); }
+    scan(props) { throw new Error('not implemented'); }
+    stopScan() { throw new Error('not implemented'); }
+    isScanning() { throw new Error('not implemented'); }
+    add(props) { throw new Error('Method not implemented.'); }
+    getDevices() { return this.devices; }
+    setAnt(antClass) { DeviceProtocolBase.setAnt(antClass); }
+    getAnt() { return DeviceProtocolBase.getAnt(); }
+    setSerialPort(serialClass) { DeviceProtocolBase.setSerialPort(serialClass); }
+    getSerialPort() { DeviceProtocolBase.getSerialPort(); }
+    setNetImpl(netClass) { DeviceProtocolBase.setNetImpl(netClass); }
+    getNetImpl() { return DeviceProtocolBase.getNetImpl(); }
+    setBinding(_bindingClass) { }
+    static setAnt(antClass) { _ant = antClass; }
+    static getAnt() { return _ant; }
+    static setSerialPort(serialClass) { _serial = serialClass; }
+    static getSerialPort() { return _serial; }
+    static setNetImpl(netClass) { _net = netClass; }
+    static getNetImpl() { return _net; }
+}
+exports.default = DeviceProtocolBase;

package/lib/{DeviceRegistry.d.ts → registry.d.ts}

@@ -1,8 +1,8 @@
-import { DeviceProtocol } from './DeviceProtocol';
-export default class DeviceRegistry {
-    static _reset(): void;
-    static _get(): any[];
-    static register(protocol: DeviceProtocol): void;
-    static findByName(name: string): DeviceProtocol;
-    static findByInterface(interf: string): Array<DeviceProtocol>;
-}
+import { DeviceProtocol } from './protocol';
+export default class DeviceRegistry {
+    static _reset(): void;
+    static _get(): any[];
+    static register(protocol: DeviceProtocol): void;
+    static findByName(name: string): DeviceProtocol;
+    static findByInterface(interf: string): Array<DeviceProtocol>;
+}

package/lib/{DeviceRegistry.js → registry.js}

@@ -1,33 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-let _protocols = [];
-class DeviceRegistry {
-    static _reset() {
-        _protocols = [];
-    }
-    static _get() {
-        return _protocols;
-    }
-    static register(protocol) {
-        if (!protocol)
-            return;
-        const idx = _protocols.findIndex(d => d.getName() === protocol.getName());
-        if (idx !== -1) {
-            _protocols[idx] = protocol;
-        }
-        else {
-            _protocols.push(protocol);
-        }
-    }
-    static findByName(name) {
-        if (!name)
-            return;
-        return _protocols.find(d => d.getName() === name);
-    }
-    static findByInterface(interf) {
-        if (!interf)
-            return;
-        return _protocols.filter(d => d.getInterfaces().findIndex(i => i === interf) !== -1);
-    }
-}
-exports.default = DeviceRegistry;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+let _protocols = [];
+class DeviceRegistry {
+    static _reset() {
+        _protocols = [];
+    }
+    static _get() {
+        return _protocols;
+    }
+    static register(protocol) {
+        if (!protocol)
+            return;
+        const idx = _protocols.findIndex(d => d.getName() === protocol.getName());
+        if (idx !== -1) {
+            _protocols[idx] = protocol;
+        }
+        else {
+            _protocols.push(protocol);
+        }
+    }
+    static findByName(name) {
+        if (!name)
+            return;
+        return _protocols.find(d => d.getName() === name);
+    }
+    static findByInterface(interf) {
+        if (!interf)
+            return;
+        return _protocols.filter(d => d.getInterfaces().findIndex(i => i === interf) !== -1);
+    }
+}
+exports.default = DeviceRegistry;