incyclist-devices 1.4.98 → 1.4.102

package/lib/CyclingMode.d.ts

@@ -1,76 +1,76 @@
-import { Device } from "./DeviceProtocol";
-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 "./DeviceProtocol";
+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/CyclingMode.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;

package/lib/Device.d.ts

@@ -1,92 +1,92 @@
-import { DeviceProtocol, Device } from './DeviceProtocol';
-import CyclingMode from './CyclingMode';
-export declare const DEFAULT_BIKE_WEIGHT = 10;
-export declare const DEFAULT_USER_WEIGHT = 75;
-export declare type DeviceData = {
-    speed?: number;
-    slope?: number;
-    power?: number;
-    cadence?: number;
-    heartrate?: number;
-    distance?: number;
-    timestamp?: number;
-    deviceTime?: number;
-    deviceDistanceCounter?: number;
-    internalDistanceCounter?: number;
-};
-export declare type OnDeviceDataCallback = (data: DeviceData) => void;
-export declare type OnDeviceStartCallback = (completed: number, total: number) => void;
-export interface Bike {
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    getSupportedCyclingModes(): Array<any>;
-    getCyclingMode(): CyclingMode;
-    getDefaultCyclingMode(): CyclingMode;
-    setUserSettings(userSettings: any): void;
-    setBikeSettings(bikeSettings: any): void;
-}
-export interface DeviceAdapter extends Device {
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
-    isSame(device: DeviceAdapter): boolean;
-    getID(): string;
-    getDisplayName(): string;
-    getName(): string;
-    getPort(): string;
-    getProtocol(): DeviceProtocol;
-    getProtocolName(): string | undefined;
-    setIgnoreHrm(ignore: boolean): void;
-    setIgnorePower(ignore: boolean): void;
-    setIgnoreBike(ignore: boolean): void;
-    select(): void;
-    unselect(): void;
-    isSelected(): boolean;
-    setDetected(detected?: boolean): void;
-    isDetected(): boolean;
-    start(props?: any): Promise<any>;
-    stop(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-    sendUpdate(request: any): void;
-    onData(callback: OnDeviceDataCallback): void;
-}
-export default class IncyclistDevice implements DeviceAdapter {
-    protocol: DeviceProtocol;
-    detected: boolean;
-    selected: boolean;
-    onDataFn: OnDeviceDataCallback;
-    settings: any;
-    constructor(proto: DeviceProtocol, settings?: any);
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
-    isSame(device: DeviceAdapter): boolean;
-    getID(): string;
-    getDisplayName(): string;
-    getName(): string;
-    getPort(): string;
-    getProtocol(): DeviceProtocol;
-    getProtocolName(): string | undefined;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    getCyclingMode(): CyclingMode;
-    setIgnoreHrm(ignore: any): void;
-    setIgnorePower(ignore: any): void;
-    setIgnoreBike(ignore: any): void;
-    select(): void;
-    unselect(): void;
-    isSelected(): boolean;
-    setDetected(detected?: boolean): void;
-    isDetected(): boolean;
-    update(): void;
-    check(): void;
-    connect(): void;
-    close(): void;
-    start(props?: any): Promise<any>;
-    stop(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-    sendUpdate(request: any): void;
-    onData(callback: OnDeviceDataCallback): void;
-}
+import { DeviceProtocol, Device } from './DeviceProtocol';
+import CyclingMode from './CyclingMode';
+export declare const DEFAULT_BIKE_WEIGHT = 10;
+export declare const DEFAULT_USER_WEIGHT = 75;
+export declare type DeviceData = {
+    speed?: number;
+    slope?: number;
+    power?: number;
+    cadence?: number;
+    heartrate?: number;
+    distance?: number;
+    timestamp?: number;
+    deviceTime?: number;
+    deviceDistanceCounter?: number;
+    internalDistanceCounter?: number;
+};
+export declare type OnDeviceDataCallback = (data: DeviceData) => void;
+export declare type OnDeviceStartCallback = (completed: number, total: number) => void;
+export interface Bike {
+    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getSupportedCyclingModes(): Array<any>;
+    getCyclingMode(): CyclingMode;
+    getDefaultCyclingMode(): CyclingMode;
+    setUserSettings(userSettings: any): void;
+    setBikeSettings(bikeSettings: any): void;
+}
+export interface DeviceAdapter extends Device {
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    isSame(device: DeviceAdapter): boolean;
+    getID(): string;
+    getDisplayName(): string;
+    getName(): string;
+    getPort(): string;
+    getProtocol(): DeviceProtocol;
+    getProtocolName(): string | undefined;
+    setIgnoreHrm(ignore: boolean): void;
+    setIgnorePower(ignore: boolean): void;
+    setIgnoreBike(ignore: boolean): void;
+    select(): void;
+    unselect(): void;
+    isSelected(): boolean;
+    setDetected(detected?: boolean): void;
+    isDetected(): boolean;
+    start(props?: any): Promise<any>;
+    stop(): Promise<boolean>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    sendUpdate(request: any): void;
+    onData(callback: OnDeviceDataCallback): void;
+}
+export default class IncyclistDevice implements DeviceAdapter {
+    protocol: DeviceProtocol;
+    detected: boolean;
+    selected: boolean;
+    onDataFn: OnDeviceDataCallback;
+    settings: any;
+    constructor(proto: DeviceProtocol, settings?: any);
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    isSame(device: DeviceAdapter): boolean;
+    getID(): string;
+    getDisplayName(): string;
+    getName(): string;
+    getPort(): string;
+    getProtocol(): DeviceProtocol;
+    getProtocolName(): string | undefined;
+    getSupportedCyclingModes(): any[];
+    getDefaultCyclingMode(): CyclingMode;
+    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getCyclingMode(): CyclingMode;
+    setIgnoreHrm(ignore: any): void;
+    setIgnorePower(ignore: any): void;
+    setIgnoreBike(ignore: any): void;
+    select(): void;
+    unselect(): void;
+    isSelected(): boolean;
+    setDetected(detected?: boolean): void;
+    isDetected(): boolean;
+    update(): void;
+    check(): void;
+    connect(): void;
+    close(): void;
+    start(props?: any): Promise<any>;
+    stop(): Promise<boolean>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    sendUpdate(request: any): void;
+    onData(callback: OnDeviceDataCallback): void;
+}

package/lib/Device.js

@@ -1,71 +1,71 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
-exports.DEFAULT_BIKE_WEIGHT = 10;
-exports.DEFAULT_USER_WEIGHT = 75;
-class IncyclistDevice {
-    constructor(proto, settings) {
-        this.protocol = proto;
-        this.detected = false;
-        this.selected = false;
-        this.onDataFn = undefined;
-        this.settings = settings || {};
-    }
-    isBike() { throw new Error('not implemented'); }
-    isPower() { throw new Error('not implemented'); }
-    isHrm() { throw new Error('not implemented'); }
-    isSame(device) { throw new Error('not implemented'); }
-    getID() { throw new Error('not implemented'); }
-    getDisplayName() { return this.getName(); }
-    getName() { throw new Error('not implemented'); }
-    getPort() { throw new Error('not implemented'); }
-    getProtocol() { return this.protocol; }
-    getProtocolName() {
-        return this.protocol ? this.protocol.getName() : undefined;
-    }
-    getSupportedCyclingModes() { throw new Error('not implemented'); }
-    getDefaultCyclingMode() { throw new Error('not implemented'); }
-    setCyclingMode(mode, settings) {
-        let selectedMode;
-        if (typeof mode === 'string') {
-            const supported = this.getSupportedCyclingModes();
-            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
-            if (CyclingModeClass) {
-                this.settings.cyclingMode = new CyclingModeClass(this, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.settings.cyclingMode = selectedMode;
-        this.settings.cyclingMode.setSettings(settings);
-    }
-    getCyclingMode() {
-        if (!this.settings.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.settings.cyclingMode;
-    }
-    setIgnoreHrm(ignore) { }
-    setIgnorePower(ignore) { }
-    setIgnoreBike(ignore) { }
-    select() { this.selected = true; }
-    unselect() { this.selected = false; }
-    isSelected() { return this.selected; }
-    setDetected(detected = true) { this.detected = detected; }
-    isDetected() { return this.detected; }
-    update() { }
-    check() { }
-    connect() { }
-    close() { }
-    start(props) { throw new Error('not implemented'); }
-    stop() { throw new Error('not implemented'); }
-    pause() { throw new Error('not implemented'); }
-    resume() { throw new Error('not implemented'); }
-    sendUpdate(request) { }
-    onData(callback) {
-        this.onDataFn = callback;
-    }
-}
-exports.default = IncyclistDevice;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
+exports.DEFAULT_BIKE_WEIGHT = 10;
+exports.DEFAULT_USER_WEIGHT = 75;
+class IncyclistDevice {
+    constructor(proto, settings) {
+        this.protocol = proto;
+        this.detected = false;
+        this.selected = false;
+        this.onDataFn = undefined;
+        this.settings = settings || {};
+    }
+    isBike() { throw new Error('not implemented'); }
+    isPower() { throw new Error('not implemented'); }
+    isHrm() { throw new Error('not implemented'); }
+    isSame(device) { throw new Error('not implemented'); }
+    getID() { throw new Error('not implemented'); }
+    getDisplayName() { return this.getName(); }
+    getName() { throw new Error('not implemented'); }
+    getPort() { throw new Error('not implemented'); }
+    getProtocol() { return this.protocol; }
+    getProtocolName() {
+        return this.protocol ? this.protocol.getName() : undefined;
+    }
+    getSupportedCyclingModes() { throw new Error('not implemented'); }
+    getDefaultCyclingMode() { throw new Error('not implemented'); }
+    setCyclingMode(mode, settings) {
+        let selectedMode;
+        if (typeof mode === 'string') {
+            const supported = this.getSupportedCyclingModes();
+            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
+            if (CyclingModeClass) {
+                this.settings.cyclingMode = new CyclingModeClass(this, settings);
+                return;
+            }
+            selectedMode = this.getDefaultCyclingMode();
+        }
+        else {
+            selectedMode = mode;
+        }
+        this.settings.cyclingMode = selectedMode;
+        this.settings.cyclingMode.setSettings(settings);
+    }
+    getCyclingMode() {
+        if (!this.settings.cyclingMode)
+            this.setCyclingMode(this.getDefaultCyclingMode());
+        return this.settings.cyclingMode;
+    }
+    setIgnoreHrm(ignore) { }
+    setIgnorePower(ignore) { }
+    setIgnoreBike(ignore) { }
+    select() { this.selected = true; }
+    unselect() { this.selected = false; }
+    isSelected() { return this.selected; }
+    setDetected(detected = true) { this.detected = detected; }
+    isDetected() { return this.detected; }
+    update() { }
+    check() { }
+    connect() { }
+    close() { }
+    start(props) { throw new Error('not implemented'); }
+    stop() { throw new Error('not implemented'); }
+    pause() { throw new Error('not implemented'); }
+    resume() { throw new Error('not implemented'); }
+    sendUpdate(request) { }
+    onData(callback) {
+        this.onDataFn = callback;
+    }
+}
+exports.default = IncyclistDevice;