incyclist-devices 1.4.100 → 1.5.0

package/lib/daum/DaumPowerMeterCyclingMode.d.ts

@@ -1,8 +1,8 @@
-import CyclingMode, { UpdateRequest } from "../CyclingMode";
-import PowerMeterCyclingMode from "../modes/power-meter";
-export default class DaumPowerMeterCyclingMode extends PowerMeterCyclingMode implements CyclingMode {
-    prevRequest: UpdateRequest;
-    hasBikeUpdate: boolean;
-    getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-}
+import CyclingMode, { UpdateRequest } from "../cycling-mode";
+import PowerMeterCyclingMode from "../modes/power-meter";
+export default class DaumPowerMeterCyclingMode extends PowerMeterCyclingMode implements CyclingMode {
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+}

package/lib/daum/DaumPowerMeterCyclingMode.js

@@ -1,21 +1,21 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const power_meter_1 = __importDefault(require("../modes/power-meter"));
-class DaumPowerMeterCyclingMode extends power_meter_1.default {
-    constructor() {
-        super(...arguments);
-        this.hasBikeUpdate = false;
-    }
-    getBikeInitRequest() {
-        return { slope: 0 };
-    }
-    sendBikeUpdate(request) {
-        super.sendBikeUpdate(request);
-        this.prevRequest = {};
-        return {};
-    }
-}
-exports.default = DaumPowerMeterCyclingMode;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const power_meter_1 = __importDefault(require("../modes/power-meter"));
+class DaumPowerMeterCyclingMode extends power_meter_1.default {
+    constructor() {
+        super(...arguments);
+        this.hasBikeUpdate = false;
+    }
+    getBikeInitRequest() {
+        return { slope: 0 };
+    }
+    sendBikeUpdate(request) {
+        super.sendBikeUpdate(request);
+        this.prevRequest = {};
+        return {};
+    }
+}
+exports.default = DaumPowerMeterCyclingMode;

package/lib/daum/ERGCyclingMode.d.ts

@@ -1,26 +1,26 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../CyclingMode";
-import DaumAdapter from "./DaumAdapter";
-import PowerBasedCyclingModeBase from "../modes/power-base";
-export declare type ERGEvent = {
-    rpmUpdated?: boolean;
-    gearUpdated?: boolean;
-    starting?: boolean;
-    tsStart?: number;
-};
-export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
-    prevRequest: UpdateRequest;
-    hasBikeUpdate: boolean;
-    chain: number[];
-    cassette: number[];
-    event: ERGEvent;
-    static isERG: boolean;
-    constructor(adapter: DaumAdapter, props?: any);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(bikeData: IncyclistBikeData): any;
-    calculateTargetPower(request: any, updateMode?: boolean): any;
-}
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../cycling-mode";
+import DaumAdapter from "./DaumAdapter";
+import PowerBasedCyclingModeBase from "../modes/power-base";
+export declare type ERGEvent = {
+    rpmUpdated?: boolean;
+    gearUpdated?: boolean;
+    starting?: boolean;
+    tsStart?: number;
+};
+export default class ERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
+    prevRequest: UpdateRequest;
+    hasBikeUpdate: boolean;
+    chain: number[];
+    cassette: number[];
+    event: ERGEvent;
+    static isERG: boolean;
+    constructor(adapter: DaumAdapter, props?: any);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData): any;
+    calculateTargetPower(request: any, updateMode?: boolean): any;
+}

package/lib/daum/ERGCyclingMode.js

@@ -1,201 +1,201 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const CyclingMode_1 = require("../CyclingMode");
-const calculations_1 = __importDefault(require("../calculations"));
-const power_base_1 = __importDefault(require("../modes/power-base"));
-const MIN_SPEED = 10;
-const config = {
-    name: "ERG",
-    description: "Calculates speed based on power and slope. Power is either set by workout or calculated based on gear and cadence",
-    properties: [
-        { key: 'bikeType', name: 'Bike Type', description: '', type: CyclingMode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
-        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: CyclingMode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
-    ]
-};
-class ERGCyclingMode extends power_base_1.default {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.hasBikeUpdate = false;
-        this.event = {};
-        this.initLogger('ERGMode');
-    }
-    getName() {
-        return config.name;
-    }
-    getDescription() {
-        return config.description;
-    }
-    getProperties() {
-        return config.properties;
-    }
-    getProperty(name) {
-        return config.properties.find(p => p.name === name);
-    }
-    getBikeInitRequest() {
-        const startPower = this.getSetting('startPower');
-        return { targetPower: startPower };
-    }
-    sendBikeUpdate(request) {
-        const getData = () => {
-            if (!this.data)
-                return {};
-            const { gear, pedalRpm, slope, power, speed } = this.data;
-            return { gear, pedalRpm, slope, power, speed };
-        };
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event: this.event });
-        let newRequest = {};
-        try {
-            if (!request || request.reset || Object.keys(request).length === 0) {
-                this.prevRequest = {};
-                return request || {};
-            }
-            const prevData = this.data || {};
-            if (request.slope !== undefined) {
-                if (!this.data)
-                    this.data = {};
-                this.data.slope = request.slope;
-            }
-            if (request.targetPower !== undefined) {
-                delete request.slope;
-                delete request.refresh;
-            }
-            if (this.event.starting && request.targetPower === undefined) {
-                const startPower = this.getSetting('startPower');
-                if (this.event.tsStart && Date.now() - this.event.tsStart > 5000) {
-                    delete this.event.starting;
-                    delete this.event.tsStart;
-                }
-                const target = this.calculateTargetPower(request);
-                if (target <= startPower && (!request.minPower || target >= request.minPower)) {
-                    return {};
-                }
-                else {
-                    delete this.event.starting;
-                    delete this.event.tsStart;
-                }
-            }
-            if (request.refresh) {
-                delete request.refresh;
-                if (this.prevRequest !== undefined && !this.event.gearUpdated && !this.event.rpmUpdated) {
-                    newRequest.targetPower = this.prevRequest.targetPower;
-                }
-                else {
-                    newRequest.targetPower = this.calculateTargetPower(request);
-                }
-                if (this.prevRequest !== undefined && Object.keys(this.prevRequest).length > 0) {
-                    request = Object.assign({}, this.prevRequest);
-                }
-                else {
-                    newRequest.targetPower = this.calculateTargetPower(request);
-                }
-            }
-            if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
-                request.targetPower = request.maxPower;
-            }
-            if (request.targetPower === undefined) {
-                newRequest.targetPower = this.calculateTargetPower(request);
-            }
-            else {
-                newRequest.targetPower = request.targetPower;
-            }
-            delete request.slope;
-            if (request.maxPower !== undefined) {
-                if (newRequest.targetPower !== undefined && newRequest.targetPower > request.maxPower) {
-                    newRequest.targetPower = request.maxPower;
-                }
-                newRequest.maxPower = request.maxPower;
-            }
-            if (request.minPower !== undefined) {
-                if (newRequest.targetPower !== undefined && newRequest.targetPower < request.minPower) {
-                    newRequest.targetPower = request.minPower;
-                }
-                newRequest.minPower = request.minPower;
-            }
-            if (newRequest.targetPower !== undefined && prevData.power !== undefined && newRequest.targetPower === prevData.power) {
-                delete newRequest.targetPower;
-            }
-            this.prevRequest = JSON.parse(JSON.stringify(request));
-        }
-        catch (err) {
-            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message || err, stack: err.stack });
-        }
-        return newRequest;
-    }
-    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').toLowerCase();
-        delete this.event.gearUpdated;
-        delete this.event.rpmUpdated;
-        if (prevData === {} || prevData.speed === undefined || prevData.speed === 0) {
-            this.event.starting = true;
-            this.event.tsStart = Date.now();
-        }
-        try {
-            const rpm = bikeData.pedalRpm || 0;
-            const gear = bikeData.gear || 0;
-            let power = bikeData.power || 0;
-            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
-            const distanceInternal = prevData.distanceInternal || 0;
-            if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
-                power = 0;
-            }
-            const m = this.getWeight();
-            const t = this.getTimeSinceLastUpdate();
-            const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
-            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.power = Math.round(power);
-            data.slope = slope;
-            data.pedalRpm = rpm;
-            data.gear = gear;
-            if (data.time !== undefined && !(this.event.starting && !bikeData.pedalRpm))
-                data.time += t;
-            else
-                data.time = 0;
-            data.heartrate = bikeData.heartrate;
-            data.isPedalling = bikeData.isPedalling;
-            if (gear !== prevData.gear) {
-                this.event.gearUpdated = true;
-            }
-            if (rpm && rpm !== prevData.pedalRpm) {
-                this.event.rpmUpdated = true;
-            }
-        }
-        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;
-    }
-    calculateTargetPower(request, updateMode = true) {
-        const bikeType = this.getSetting('bikeType').toLowerCase();
-        const defaultPower = this.getSetting('startPower');
-        let m = this.getWeight();
-        const prevData = this.data || {};
-        let target;
-        if (prevData.pedalRpm && prevData.gear && (!updateMode || prevData.pedalRpm !== 0)) {
-            const speed = calculations_1.default.calculateSpeedDaum(prevData.gear, prevData.pedalRpm, bikeType);
-            var power = calculations_1.default.calculatePower(m, speed / 3.6, 0, { bikeType });
-            target = Math.round(power);
-        }
-        else {
-            target = Math.round(request.targetPower || defaultPower);
-        }
-        return target;
-    }
-}
-exports.default = ERGCyclingMode;
-ERGCyclingMode.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 cycling_mode_1 = require("../cycling-mode");
+const calculations_1 = __importDefault(require("../calculations"));
+const power_base_1 = __importDefault(require("../modes/power-base"));
+const MIN_SPEED = 10;
+const config = {
+    name: "ERG",
+    description: "Calculates speed based on power and slope. Power is either set by workout or calculated based on gear and cadence",
+    properties: [
+        { key: 'bikeType', name: 'Bike Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
+        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
+    ]
+};
+class ERGCyclingMode extends power_base_1.default {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.hasBikeUpdate = false;
+        this.event = {};
+        this.initLogger('ERGMode');
+    }
+    getName() {
+        return config.name;
+    }
+    getDescription() {
+        return config.description;
+    }
+    getProperties() {
+        return config.properties;
+    }
+    getProperty(name) {
+        return config.properties.find(p => p.name === name);
+    }
+    getBikeInitRequest() {
+        const startPower = this.getSetting('startPower');
+        return { targetPower: startPower };
+    }
+    sendBikeUpdate(request) {
+        const getData = () => {
+            if (!this.data)
+                return {};
+            const { gear, pedalRpm, slope, power, speed } = this.data;
+            return { gear, pedalRpm, slope, power, speed };
+        };
+        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData(), event: this.event });
+        let newRequest = {};
+        try {
+            if (!request || request.reset || Object.keys(request).length === 0) {
+                this.prevRequest = {};
+                return request || {};
+            }
+            const prevData = this.data || {};
+            if (request.slope !== undefined) {
+                if (!this.data)
+                    this.data = {};
+                this.data.slope = request.slope;
+            }
+            if (request.targetPower !== undefined) {
+                delete request.slope;
+                delete request.refresh;
+            }
+            if (this.event.starting && request.targetPower === undefined) {
+                const startPower = this.getSetting('startPower');
+                if (this.event.tsStart && Date.now() - this.event.tsStart > 5000) {
+                    delete this.event.starting;
+                    delete this.event.tsStart;
+                }
+                const target = this.calculateTargetPower(request);
+                if (target <= startPower && (!request.minPower || target >= request.minPower)) {
+                    return {};
+                }
+                else {
+                    delete this.event.starting;
+                    delete this.event.tsStart;
+                }
+            }
+            if (request.refresh) {
+                delete request.refresh;
+                if (this.prevRequest !== undefined && !this.event.gearUpdated && !this.event.rpmUpdated) {
+                    newRequest.targetPower = this.prevRequest.targetPower;
+                }
+                else {
+                    newRequest.targetPower = this.calculateTargetPower(request);
+                }
+                if (this.prevRequest !== undefined && Object.keys(this.prevRequest).length > 0) {
+                    request = Object.assign({}, this.prevRequest);
+                }
+                else {
+                    newRequest.targetPower = this.calculateTargetPower(request);
+                }
+            }
+            if (request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
+                request.targetPower = request.maxPower;
+            }
+            if (request.targetPower === undefined) {
+                newRequest.targetPower = this.calculateTargetPower(request);
+            }
+            else {
+                newRequest.targetPower = request.targetPower;
+            }
+            delete request.slope;
+            if (request.maxPower !== undefined) {
+                if (newRequest.targetPower !== undefined && newRequest.targetPower > request.maxPower) {
+                    newRequest.targetPower = request.maxPower;
+                }
+                newRequest.maxPower = request.maxPower;
+            }
+            if (request.minPower !== undefined) {
+                if (newRequest.targetPower !== undefined && newRequest.targetPower < request.minPower) {
+                    newRequest.targetPower = request.minPower;
+                }
+                newRequest.minPower = request.minPower;
+            }
+            if (newRequest.targetPower !== undefined && prevData.power !== undefined && newRequest.targetPower === prevData.power) {
+                delete newRequest.targetPower;
+            }
+            this.prevRequest = JSON.parse(JSON.stringify(request));
+        }
+        catch (err) {
+            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message || err, stack: err.stack });
+        }
+        return newRequest;
+    }
+    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').toLowerCase();
+        delete this.event.gearUpdated;
+        delete this.event.rpmUpdated;
+        if (prevData === {} || prevData.speed === undefined || prevData.speed === 0) {
+            this.event.starting = true;
+            this.event.tsStart = Date.now();
+        }
+        try {
+            const rpm = bikeData.pedalRpm || 0;
+            const gear = bikeData.gear || 0;
+            let power = bikeData.power || 0;
+            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+            const distanceInternal = prevData.distanceInternal || 0;
+            if (!bikeData.pedalRpm || bikeData.isPedalling === false) {
+                power = 0;
+            }
+            const m = this.getWeight();
+            const t = this.getTimeSinceLastUpdate();
+            const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+            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.power = Math.round(power);
+            data.slope = slope;
+            data.pedalRpm = rpm;
+            data.gear = gear;
+            if (data.time !== undefined && !(this.event.starting && !bikeData.pedalRpm))
+                data.time += t;
+            else
+                data.time = 0;
+            data.heartrate = bikeData.heartrate;
+            data.isPedalling = bikeData.isPedalling;
+            if (gear !== prevData.gear) {
+                this.event.gearUpdated = true;
+            }
+            if (rpm && rpm !== prevData.pedalRpm) {
+                this.event.rpmUpdated = true;
+            }
+        }
+        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;
+    }
+    calculateTargetPower(request, updateMode = true) {
+        const bikeType = this.getSetting('bikeType').toLowerCase();
+        const defaultPower = this.getSetting('startPower');
+        let m = this.getWeight();
+        const prevData = this.data || {};
+        let target;
+        if (prevData.pedalRpm && prevData.gear && (!updateMode || prevData.pedalRpm !== 0)) {
+            const speed = calculations_1.default.calculateSpeedDaum(prevData.gear, prevData.pedalRpm, bikeType);
+            var power = calculations_1.default.calculatePower(m, speed / 3.6, 0, { bikeType });
+            target = Math.round(power);
+        }
+        else {
+            target = Math.round(request.targetPower || defaultPower);
+        }
+        return target;
+    }
+}
+exports.default = ERGCyclingMode;
+ERGCyclingMode.isERG = true;

package/lib/daum/SmartTrainerCyclingMode.d.ts

@@ -1,41 +1,41 @@
-import { EventLogger } from "gd-eventlog";
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest, CyclingModeBase } from "../CyclingMode";
-import DaumAdapter from "./DaumAdapter";
-interface STUpdateRequest extends UpdateRequest {
-    calculatedPower?: number;
-    delta?: number;
-    enforced?: boolean;
-    belowMin?: boolean;
-    aboveMax?: boolean;
-}
-export declare enum direction {
-    up = "up",
-    down = "down"
-}
-interface STEvent {
-    gearUpdate?: direction;
-    rpmUpdate?: boolean;
-    targetNotReached?: number;
-}
-export default class SmartTrainerCyclingMode extends CyclingModeBase implements CyclingMode {
-    logger: EventLogger;
-    data: IncyclistBikeData;
-    prevRequest: STUpdateRequest;
-    prevUpdateTS: number;
-    chain: number[];
-    cassette: number[];
-    event: STEvent;
-    constructor(adapter: DaumAdapter, props?: Settings);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    getBikeInitRequest(): STUpdateRequest;
-    useGearSimulation(): boolean;
-    getMinMaxGears(source: string): [number, number];
-    sendBikeUpdate(request: STUpdateRequest): STUpdateRequest;
-    updateData(bikeData: IncyclistBikeData): any;
-    calculateSpeed(gear: any, rpm: any, slope: any, bikeSpeed: any, props?: any): any;
-    calculateTargetPower(request: STUpdateRequest, speed?: number): STUpdateRequest;
-}
-export {};
+import { EventLogger } from "gd-eventlog";
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest, CyclingModeBase } from "../cycling-mode";
+import DaumAdapter from "./DaumAdapter";
+interface STUpdateRequest extends UpdateRequest {
+    calculatedPower?: number;
+    delta?: number;
+    enforced?: boolean;
+    belowMin?: boolean;
+    aboveMax?: boolean;
+}
+export declare enum direction {
+    up = "up",
+    down = "down"
+}
+interface STEvent {
+    gearUpdate?: direction;
+    rpmUpdate?: boolean;
+    targetNotReached?: number;
+}
+export default class SmartTrainerCyclingMode extends CyclingModeBase implements CyclingMode {
+    logger: EventLogger;
+    data: IncyclistBikeData;
+    prevRequest: STUpdateRequest;
+    prevUpdateTS: number;
+    chain: number[];
+    cassette: number[];
+    event: STEvent;
+    constructor(adapter: DaumAdapter, props?: Settings);
+    getName(): string;
+    getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    getBikeInitRequest(): STUpdateRequest;
+    useGearSimulation(): boolean;
+    getMinMaxGears(source: string): [number, number];
+    sendBikeUpdate(request: STUpdateRequest): STUpdateRequest;
+    updateData(bikeData: IncyclistBikeData): any;
+    calculateSpeed(gear: any, rpm: any, slope: any, bikeSpeed: any, props?: any): any;
+    calculateTargetPower(request: STUpdateRequest, speed?: number): STUpdateRequest;
+}
+export {};