incyclist-devices 1.5.10 → 1.5.12

package/lib/calculations.d.ts

@@ -1,13 +1,13 @@
-export declare class IllegalArgumentException extends Error {
-    constructor(message: any);
-}
-export default class C {
-    static calculateSpeed(m: number, power: number, slope: number, props?: any): number;
-    static calculatePower(m: number, v: number, slope: number, props?: any): number;
-    static calculateSpeedDaum(gear: number, rpm: number, bikeType?: string | number): number;
-    static calculateSpeedBike(gear: number, rpm: number, chain: number[], cassette: number[], props?: {
-        numGears?: number;
-        wheelCirc?: number;
-    }): number;
-}
-export declare function solveCubic(p: any, q: any): any[];
+export declare class IllegalArgumentException extends Error {
+    constructor(message: any);
+}
+export default class C {
+    static calculateSpeed(m: number, power: number, slope: number, props?: any): number;
+    static calculatePower(m: number, v: number, slope: number, props?: any): number;
+    static calculateSpeedDaum(gear: number, rpm: number, bikeType?: string | number): number;
+    static calculateSpeedBike(gear: number, rpm: number, chain: number[], cassette: number[], props?: {
+        numGears?: number;
+        wheelCirc?: number;
+    }): number;
+}
+export declare function solveCubic(p: any, q: any): any[];

package/lib/calculations.js

@@ -1,150 +1,150 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.solveCubic = exports.IllegalArgumentException = void 0;
-const g = 9.80665;
-const rho = 1.2041;
-const cwABike = {
-    race: 0.35,
-    triathlon: 0.29,
-    mountain: 0.57
-};
-const cRR = 0.0036;
-class IllegalArgumentException extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "IllegalArgumentException";
-    }
-}
-exports.IllegalArgumentException = IllegalArgumentException;
-class C {
-    static calculateSpeed(m, power, slope, props = {}) {
-        if (m === undefined || m === null || m < 0)
-            throw new IllegalArgumentException("m must be a positive number");
-        if (power === undefined || power === null || power < 0)
-            throw new IllegalArgumentException("power must be a positive number");
-        if (slope === undefined || slope === null)
-            slope = 0;
-        const _rho = props.rho || rho;
-        const _cRR = props.cRR || cRR;
-        const _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
-        let sl = Math.atan(slope / 100);
-        let c1 = 0.5 * _rho * _cwA;
-        let c2 = (sl + _cRR) * m * g;
-        let p = c2 / c1;
-        let q = -1.0 * power / c1;
-        var v = solveCubic(p, q).filter(value => value >= 0);
-        if (v.length === 1)
-            return v[0] * 3.6;
-        if (v.length > 1) {
-            if (props.previous) {
-                let speed = undefined;
-                let minDiff = undefined;
-                v.forEach(s => {
-                    if (!minDiff) {
-                        minDiff = Math.abs(s - props.previous);
-                        speed = s;
-                        return;
-                    }
-                    const diff = Math.abs(s - props.previous);
-                    if (diff < minDiff) {
-                        minDiff = diff;
-                        speed = s;
-                    }
-                });
-                return speed * 3.6;
-            }
-            for (var i = 0; i < v.length; i++)
-                if (v[i] > 0)
-                    return v[i] * 3.6;
-        }
-        return 0;
-    }
-    static calculatePower(m, v, slope, props = {}) {
-        if (m === undefined || m === null || m < 0)
-            throw new IllegalArgumentException("m must be a positive number");
-        if (v === undefined || v === null || v < 0)
-            throw new IllegalArgumentException("v must be a positive number");
-        if (slope === undefined || slope === null)
-            slope = 0;
-        let _rho = props.rho || rho;
-        let _cRR = props.cRR || cRR;
-        let _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
-        let sl = Math.sin(Math.atan(slope / 100));
-        let P = (0.5 * _rho * _cwA) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
-        return P;
-    }
-    static calculateSpeedDaum(gear, rpm, bikeType) {
-        if (bikeType === 0 || bikeType === undefined || bikeType === "race" || bikeType === 'triathlon') {
-            let lengthRPM = 210;
-            let gearRatio = 1.75 + (gear - 1) * 0.098767;
-            let distRotation = lengthRPM * gearRatio;
-            let speed = rpm * distRotation * 0.0006;
-            return speed;
-        }
-        else {
-            let lengthRPM = 185;
-            let gearRatio = 0.67 + (gear - 1) * 0.1485;
-            let distRotation = lengthRPM * gearRatio;
-            let speed = rpm * distRotation * 0.0006;
-            return speed;
-        }
-    }
-    static calculateSpeedBike(gear, rpm, chain, cassette, props) {
-        if (chain.length !== 2 || cassette.length !== 2)
-            throw new IllegalArgumentException("chain and cassette must be an array of 2 numbers");
-        if (cassette[0] < 1 || cassette[1] < 1)
-            throw new IllegalArgumentException("cassette must be an array of 2 positive numbers");
-        const bikeProps = props || {};
-        const minGearRatio = chain[0] / cassette[1];
-        const maxGearRatio = chain[1] / cassette[0];
-        const numGears = bikeProps.numGears || 28;
-        const wheelCirc = bikeProps.wheelCirc || 2125;
-        const gearRatio = minGearRatio + (maxGearRatio - minGearRatio) * (gear - 1) / (numGears - 1);
-        let distRotation = wheelCirc * gearRatio / 1000;
-        let speed = rpm * distRotation * 60 / 1000;
-        return speed;
-    }
-}
-exports.default = C;
-function acosh(x) {
-    return Math.log(x + Math.sqrt(x * x - 1.0));
-}
-function asinh(x) {
-    return Math.log(x + Math.sqrt(x * x + 1.0));
-}
-function sqrtN(x, n) {
-    let exp = 1.0 / n;
-    if (Math.sign(x) === 1 || n % 2 === 0) {
-        return Math.pow(x, exp);
-    }
-    return Math.sign(x) * Math.pow(Math.abs(x), exp);
-}
-function solveCubic(p, q) {
-    let D = Math.pow(q / 2.0, 2) + Math.pow(p / 3.0, 3);
-    let R = Math.sign(q) * Math.sqrt(Math.abs(p) / 3.0);
-    if (p === 0) {
-        return [sqrtN(-1 * q, 3)];
-    }
-    if (D === 0) {
-        return [3 * q / p, -3 * q / (2 * p)];
-    }
-    if (D < 0 && p < 0) {
-        const results = [];
-        let phi = Math.acos(q / (2 * Math.pow(R, 3)));
-        results[0] = -2 * R * Math.cos(phi / 3);
-        results[1] = -2 * R * Math.cos(phi / 3 + 2 * Math.PI / 3);
-        results[2] = -2 * R * Math.cos(phi / 3 + 4 * Math.PI / 3);
-        return results;
-    }
-    if (D > 0 && p < 0) {
-        const results = [];
-        let phi = acosh(q / (2 * Math.pow(R, 3)));
-        results[0] = -2 * R * Math.cosh(phi / 3);
-        return results;
-    }
-    const results = [];
-    let phi = asinh(q / (2 * Math.pow(R, 3)));
-    results[0] = -2 * R * Math.sinh(phi / 3);
-    return results;
-}
-exports.solveCubic = solveCubic;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solveCubic = exports.IllegalArgumentException = void 0;
+const g = 9.80665;
+const rho = 1.2041;
+const cwABike = {
+    race: 0.35,
+    triathlon: 0.29,
+    mountain: 0.57
+};
+const cRR = 0.0036;
+class IllegalArgumentException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "IllegalArgumentException";
+    }
+}
+exports.IllegalArgumentException = IllegalArgumentException;
+class C {
+    static calculateSpeed(m, power, slope, props = {}) {
+        if (m === undefined || m === null || m < 0)
+            throw new IllegalArgumentException("m must be a positive number");
+        if (power === undefined || power === null || power < 0)
+            throw new IllegalArgumentException("power must be a positive number");
+        if (slope === undefined || slope === null)
+            slope = 0;
+        const _rho = props.rho || rho;
+        const _cRR = props.cRR || cRR;
+        const _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
+        let sl = Math.atan(slope / 100);
+        let c1 = 0.5 * _rho * _cwA;
+        let c2 = (sl + _cRR) * m * g;
+        let p = c2 / c1;
+        let q = -1.0 * power / c1;
+        var v = solveCubic(p, q).filter(value => value >= 0);
+        if (v.length === 1)
+            return v[0] * 3.6;
+        if (v.length > 1) {
+            if (props.previous) {
+                let speed = undefined;
+                let minDiff = undefined;
+                v.forEach(s => {
+                    if (!minDiff) {
+                        minDiff = Math.abs(s - props.previous);
+                        speed = s;
+                        return;
+                    }
+                    const diff = Math.abs(s - props.previous);
+                    if (diff < minDiff) {
+                        minDiff = diff;
+                        speed = s;
+                    }
+                });
+                return speed * 3.6;
+            }
+            for (var i = 0; i < v.length; i++)
+                if (v[i] > 0)
+                    return v[i] * 3.6;
+        }
+        return 0;
+    }
+    static calculatePower(m, v, slope, props = {}) {
+        if (m === undefined || m === null || m < 0)
+            throw new IllegalArgumentException("m must be a positive number");
+        if (v === undefined || v === null || v < 0)
+            throw new IllegalArgumentException("v must be a positive number");
+        if (slope === undefined || slope === null)
+            slope = 0;
+        let _rho = props.rho || rho;
+        let _cRR = props.cRR || cRR;
+        let _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
+        let sl = Math.sin(Math.atan(slope / 100));
+        let P = (0.5 * _rho * _cwA) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
+        return P;
+    }
+    static calculateSpeedDaum(gear, rpm, bikeType) {
+        if (bikeType === 0 || bikeType === undefined || bikeType === "race" || bikeType === 'triathlon') {
+            let lengthRPM = 210;
+            let gearRatio = 1.75 + (gear - 1) * 0.098767;
+            let distRotation = lengthRPM * gearRatio;
+            let speed = rpm * distRotation * 0.0006;
+            return speed;
+        }
+        else {
+            let lengthRPM = 185;
+            let gearRatio = 0.67 + (gear - 1) * 0.1485;
+            let distRotation = lengthRPM * gearRatio;
+            let speed = rpm * distRotation * 0.0006;
+            return speed;
+        }
+    }
+    static calculateSpeedBike(gear, rpm, chain, cassette, props) {
+        if (chain.length !== 2 || cassette.length !== 2)
+            throw new IllegalArgumentException("chain and cassette must be an array of 2 numbers");
+        if (cassette[0] < 1 || cassette[1] < 1)
+            throw new IllegalArgumentException("cassette must be an array of 2 positive numbers");
+        const bikeProps = props || {};
+        const minGearRatio = chain[0] / cassette[1];
+        const maxGearRatio = chain[1] / cassette[0];
+        const numGears = bikeProps.numGears || 28;
+        const wheelCirc = bikeProps.wheelCirc || 2125;
+        const gearRatio = minGearRatio + (maxGearRatio - minGearRatio) * (gear - 1) / (numGears - 1);
+        let distRotation = wheelCirc * gearRatio / 1000;
+        let speed = rpm * distRotation * 60 / 1000;
+        return speed;
+    }
+}
+exports.default = C;
+function acosh(x) {
+    return Math.log(x + Math.sqrt(x * x - 1.0));
+}
+function asinh(x) {
+    return Math.log(x + Math.sqrt(x * x + 1.0));
+}
+function sqrtN(x, n) {
+    let exp = 1.0 / n;
+    if (Math.sign(x) === 1 || n % 2 === 0) {
+        return Math.pow(x, exp);
+    }
+    return Math.sign(x) * Math.pow(Math.abs(x), exp);
+}
+function solveCubic(p, q) {
+    let D = Math.pow(q / 2.0, 2) + Math.pow(p / 3.0, 3);
+    let R = Math.sign(q) * Math.sqrt(Math.abs(p) / 3.0);
+    if (p === 0) {
+        return [sqrtN(-1 * q, 3)];
+    }
+    if (D === 0) {
+        return [3 * q / p, -3 * q / (2 * p)];
+    }
+    if (D < 0 && p < 0) {
+        const results = [];
+        let phi = Math.acos(q / (2 * Math.pow(R, 3)));
+        results[0] = -2 * R * Math.cos(phi / 3);
+        results[1] = -2 * R * Math.cos(phi / 3 + 2 * Math.PI / 3);
+        results[2] = -2 * R * Math.cos(phi / 3 + 4 * Math.PI / 3);
+        return results;
+    }
+    if (D > 0 && p < 0) {
+        const results = [];
+        let phi = acosh(q / (2 * Math.pow(R, 3)));
+        results[0] = -2 * R * Math.cosh(phi / 3);
+        return results;
+    }
+    const results = [];
+    let phi = asinh(q / (2 * Math.pow(R, 3)));
+    results[0] = -2 * R * Math.sinh(phi / 3);
+    return results;
+}
+exports.solveCubic = solveCubic;

package/lib/cycling-mode.d.ts

@@ -1,76 +1,76 @@
-import { Device } from "./protocol";
-export declare type UpdateRequest = {
-    slope?: number;
-    minPower?: number;
-    maxPower?: number;
-    targetPower?: number;
-    reset?: boolean;
-    refresh?: boolean;
-};
-export declare enum CyclingModeProperyType {
-    Integer = "Integer",
-    Boolean = "Boolean",
-    Float = "Float",
-    String = "String",
-    SingleSelect = "SingleSelect",
-    MultiSelect = "MultiSelect"
-}
-export declare type CyclingModeProperty = {
-    key: string;
-    name: string;
-    description: string;
-    type: CyclingModeProperyType;
-    min?: number;
-    max?: number;
-    default?: any;
-    options?: any[];
-};
-export declare type IncyclistBikeData = {
-    isPedalling: boolean;
-    power: number;
-    pedalRpm: number;
-    speed: number;
-    heartrate: number;
-    distanceInternal: number;
-    time?: number;
-    gear?: number;
-    slope?: number;
-};
-export declare type Settings = {
-    [key: string]: any;
-};
-export default interface CyclingMode {
-    getName(): string;
-    getDescription(): string;
-    getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(data: IncyclistBikeData): IncyclistBikeData;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    setSettings(settings: any): any;
-    setSetting(name: string, value: any): void;
-    getSetting(name: string): any;
-    getSettings(): Settings;
-    setModeProperty(name: string, value: any): void;
-    getModeProperty(name: string): any;
-}
-export declare class CyclingModeBase implements CyclingMode {
-    adapter: Device;
-    settings: Settings;
-    properties: Settings;
-    constructor(adapter: Device, props?: any);
-    setAdapter(adapter: Device): void;
-    getBikeInitRequest(): UpdateRequest;
-    getName(): string;
-    getDescription(): string;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(data: IncyclistBikeData): IncyclistBikeData;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    setSettings(settings?: any): void;
-    setSetting(name: string, value: any): void;
-    getSetting(name: string): any;
-    getSettings(): Settings;
-    setModeProperty(name: string, value: any): void;
-    getModeProperty(name: string): any;
-}
+import { Device } from "./protocol";
+export declare type UpdateRequest = {
+    slope?: number;
+    minPower?: number;
+    maxPower?: number;
+    targetPower?: number;
+    reset?: boolean;
+    refresh?: boolean;
+};
+export declare enum CyclingModeProperyType {
+    Integer = "Integer",
+    Boolean = "Boolean",
+    Float = "Float",
+    String = "String",
+    SingleSelect = "SingleSelect",
+    MultiSelect = "MultiSelect"
+}
+export declare type CyclingModeProperty = {
+    key: string;
+    name: string;
+    description: string;
+    type: CyclingModeProperyType;
+    min?: number;
+    max?: number;
+    default?: any;
+    options?: any[];
+};
+export declare type IncyclistBikeData = {
+    isPedalling: boolean;
+    power: number;
+    pedalRpm: number;
+    speed: number;
+    heartrate: number;
+    distanceInternal: number;
+    time?: number;
+    gear?: number;
+    slope?: number;
+};
+export declare type Settings = {
+    [key: string]: any;
+};
+export default interface CyclingMode {
+    getName(): string;
+    getDescription(): string;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(data: IncyclistBikeData): IncyclistBikeData;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    setSettings(settings: any): any;
+    setSetting(name: string, value: any): void;
+    getSetting(name: string): any;
+    getSettings(): Settings;
+    setModeProperty(name: string, value: any): void;
+    getModeProperty(name: string): any;
+}
+export declare class CyclingModeBase implements CyclingMode {
+    adapter: Device;
+    settings: Settings;
+    properties: Settings;
+    constructor(adapter: Device, props?: any);
+    setAdapter(adapter: Device): void;
+    getBikeInitRequest(): UpdateRequest;
+    getName(): string;
+    getDescription(): string;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(data: IncyclistBikeData): IncyclistBikeData;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    setSettings(settings?: any): void;
+    setSetting(name: string, value: any): void;
+    getSetting(name: string): any;
+    getSettings(): Settings;
+    setModeProperty(name: string, value: any): void;
+    getModeProperty(name: string): any;
+}

package/lib/cycling-mode.js

@@ -1,79 +1,79 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CyclingModeBase = exports.CyclingModeProperyType = void 0;
-var CyclingModeProperyType;
-(function (CyclingModeProperyType) {
-    CyclingModeProperyType["Integer"] = "Integer";
-    CyclingModeProperyType["Boolean"] = "Boolean";
-    CyclingModeProperyType["Float"] = "Float";
-    CyclingModeProperyType["String"] = "String";
-    CyclingModeProperyType["SingleSelect"] = "SingleSelect";
-    CyclingModeProperyType["MultiSelect"] = "MultiSelect";
-})(CyclingModeProperyType = exports.CyclingModeProperyType || (exports.CyclingModeProperyType = {}));
-class CyclingModeBase {
-    constructor(adapter, props) {
-        this.settings = {};
-        this.properties = {};
-        if (!adapter)
-            throw new Error('IllegalArgument: adapter is null');
-        this.setAdapter(adapter);
-        this.setSettings(props);
-    }
-    setAdapter(adapter) {
-        this.adapter = adapter;
-    }
-    getBikeInitRequest() {
-        return {};
-    }
-    getName() {
-        throw new Error("Method not implemented.");
-    }
-    getDescription() {
-        throw new Error("Method not implemented.");
-    }
-    sendBikeUpdate(request) {
-        throw new Error("Method not implemented.");
-    }
-    updateData(data) {
-        throw new Error("Method not implemented.");
-    }
-    getProperties() {
-        throw new Error("Method not implemented.");
-    }
-    getProperty(name) {
-        throw new Error("Method not implemented.");
-    }
-    setSettings(settings) {
-        if (settings) {
-            this.settings = settings;
-        }
-    }
-    setSetting(name, value) {
-        this.settings[name] = value;
-    }
-    getSetting(name) {
-        const res = this.settings[name];
-        if (res !== undefined)
-            return res;
-        const prop = this.getProperties().find(p => p.key === name);
-        if (prop && prop.default !== undefined)
-            return prop.default;
-        return undefined;
-    }
-    getSettings() {
-        return this.settings;
-    }
-    setModeProperty(name, value) {
-        this.properties[name] = value;
-    }
-    getModeProperty(name) {
-        const res = this.properties[name];
-        if (res !== undefined)
-            return res;
-        const prop = this.getProperties().find(p => p.key === name);
-        if (prop && prop.default !== undefined)
-            return prop.default;
-        return undefined;
-    }
-}
-exports.CyclingModeBase = CyclingModeBase;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclingModeBase = exports.CyclingModeProperyType = void 0;
+var CyclingModeProperyType;
+(function (CyclingModeProperyType) {
+    CyclingModeProperyType["Integer"] = "Integer";
+    CyclingModeProperyType["Boolean"] = "Boolean";
+    CyclingModeProperyType["Float"] = "Float";
+    CyclingModeProperyType["String"] = "String";
+    CyclingModeProperyType["SingleSelect"] = "SingleSelect";
+    CyclingModeProperyType["MultiSelect"] = "MultiSelect";
+})(CyclingModeProperyType = exports.CyclingModeProperyType || (exports.CyclingModeProperyType = {}));
+class CyclingModeBase {
+    constructor(adapter, props) {
+        this.settings = {};
+        this.properties = {};
+        if (!adapter)
+            throw new Error('IllegalArgument: adapter is null');
+        this.setAdapter(adapter);
+        this.setSettings(props);
+    }
+    setAdapter(adapter) {
+        this.adapter = adapter;
+    }
+    getBikeInitRequest() {
+        return {};
+    }
+    getName() {
+        throw new Error("Method not implemented.");
+    }
+    getDescription() {
+        throw new Error("Method not implemented.");
+    }
+    sendBikeUpdate(request) {
+        throw new Error("Method not implemented.");
+    }
+    updateData(data) {
+        throw new Error("Method not implemented.");
+    }
+    getProperties() {
+        throw new Error("Method not implemented.");
+    }
+    getProperty(name) {
+        throw new Error("Method not implemented.");
+    }
+    setSettings(settings) {
+        if (settings) {
+            this.settings = settings;
+        }
+    }
+    setSetting(name, value) {
+        this.settings[name] = value;
+    }
+    getSetting(name) {
+        const res = this.settings[name];
+        if (res !== undefined)
+            return res;
+        const prop = this.getProperties().find(p => p.key === name);
+        if (prop && prop.default !== undefined)
+            return prop.default;
+        return undefined;
+    }
+    getSettings() {
+        return this.settings;
+    }
+    setModeProperty(name, value) {
+        this.properties[name] = value;
+    }
+    getModeProperty(name) {
+        const res = this.properties[name];
+        if (res !== undefined)
+            return res;
+        const prop = this.getProperties().find(p => p.key === name);
+        if (prop && prop.default !== undefined)
+            return prop.default;
+        return undefined;
+    }
+}
+exports.CyclingModeBase = CyclingModeBase;