incyclist-devices 1.4.100 → 1.5.0

package/lib/{Device.d.ts → 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 './protocol';
+import CyclingMode from './cycling-mode';
+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;
+    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;
+    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 → 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;

package/lib/kettler/comms.d.ts

@@ -1,59 +1,59 @@
-/// <reference types="node" />
-import { DeviceProtocol } from "../DeviceProtocol";
-import { EventLogger } from "gd-eventlog";
-import { Command } from "../types/command";
-import EventEmitter from "events";
-export declare type SerialCommsProps = {
-    logger?: EventLogger;
-    protocol: DeviceProtocol;
-    port: string;
-    settings?: any;
-};
-export declare enum SerialCommsState {
-    Idle = 0,
-    Connecting = 1,
-    Connected = 2,
-    Disconnecting = 3,
-    Disconnected = 4,
-    Error = 5
-}
-export declare enum SendState {
-    Idle = 0,
-    Sending = 1,
-    Receiving = 2
-}
-export default class KettlerSerialComms<T extends Command> extends EventEmitter {
-    private logger;
-    private port;
-    private sp;
-    private queue;
-    private state;
-    private settings;
-    private worker;
-    private sendState;
-    private currentCmd;
-    private currentTimeout;
-    private protocol;
-    constructor(opts: SerialCommsProps);
-    getPort(): string;
-    setPort(port: any): void;
-    getLogger(): EventLogger;
-    isConnected(): boolean;
-    stateIn: (allowedStates: SerialCommsState[]) => boolean;
-    _setState(state: SerialCommsState): void;
-    _setSendState(state: SendState): void;
-    _setCurrentCmd(cmd: T): void;
-    stopCurrentTimeoutCheck(): void;
-    onPortOpen(): void;
-    onPortClose(): Promise<void>;
-    onPortError(err: any): void;
-    open(): void;
-    close(): void;
-    startWorker(): void;
-    stopWorker(): void;
-    clearTimeout(): void;
-    onData(data: string | Buffer): void;
-    write(cmd: Command): void;
-    sendNextCommand(): Command | undefined;
-    send(cmd: Command): void;
-}
+/// <reference types="node" />
+import { DeviceProtocol } from "../protocol";
+import { EventLogger } from "gd-eventlog";
+import { Command } from "../types/command";
+import EventEmitter from "events";
+export declare type SerialCommsProps = {
+    logger?: EventLogger;
+    protocol: DeviceProtocol;
+    port: string;
+    settings?: any;
+};
+export declare enum SerialCommsState {
+    Idle = 0,
+    Connecting = 1,
+    Connected = 2,
+    Disconnecting = 3,
+    Disconnected = 4,
+    Error = 5
+}
+export declare enum SendState {
+    Idle = 0,
+    Sending = 1,
+    Receiving = 2
+}
+export default class KettlerSerialComms<T extends Command> extends EventEmitter {
+    private logger;
+    private port;
+    private sp;
+    private queue;
+    private state;
+    private settings;
+    private worker;
+    private sendState;
+    private currentCmd;
+    private currentTimeout;
+    private protocol;
+    constructor(opts: SerialCommsProps);
+    getPort(): string;
+    setPort(port: any): void;
+    getLogger(): EventLogger;
+    isConnected(): boolean;
+    stateIn: (allowedStates: SerialCommsState[]) => boolean;
+    _setState(state: SerialCommsState): void;
+    _setSendState(state: SendState): void;
+    _setCurrentCmd(cmd: T): void;
+    stopCurrentTimeoutCheck(): void;
+    onPortOpen(): void;
+    onPortClose(): Promise<void>;
+    onPortError(err: any): void;
+    open(): void;
+    close(): void;
+    startWorker(): void;
+    stopWorker(): void;
+    clearTimeout(): void;
+    onData(data: string | Buffer): void;
+    write(cmd: Command): void;
+    sendNextCommand(): Command | undefined;
+    send(cmd: Command): void;
+}