incyclist-devices 2.1.0 → 2.1.2

package/lib/serial/serial-interface.js

@@ -12,86 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SinglePathScanner = exports.SerialInterfaceType = void 0;
 const events_1 = __importDefault(require("events"));
 const serialport_1 = __importDefault(require("./serialport"));
 const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("../utils/utils");
-const adapters_1 = __importDefault(require("../adapters"));
-const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+const adapter_factory_1 = __importDefault(require("./factories/adapter-factory"));
+const serial_scanner_1 = require("./serial-scanner");
 const DEFAULT_SCAN_TIMEOUT = 10000;
-exports.SerialInterfaceType = {
-    SERIAL: 'serial',
-    TCPIP: 'tcpip'
-};
-class SinglePathScanner {
-    constructor(path, serial, props) {
-        this.path = path;
-        this.serial = serial;
-        this.result = undefined;
-        this.isScanning = false;
-        this.isFound = false;
-        this.props = props;
-        this.logger = props.logger || new gd_eventlog_1.EventLogger('SerialScanner');
-    }
-    logEvent(event) {
-        if (this.logger) {
-            this.logger.logEvent(event);
-        }
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
-            console.log('~~~ SerialScanner', event);
-        }
-    }
-    onStopRequest(resolve) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'stopping scan', path: this.path });
-            if (!this.isFound)
-                yield this.serial.closePort(this.path);
-            this.isScanning = false;
-            resolve(this.result);
-        });
-    }
-    scan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isScanning)
-                return;
-            this.isScanning = true;
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.logEvent({ message: 'starting scan', path: this.path, interface: this.serial.getName() });
-                this.serial.scanEvents.on('timeout', () => this.onStopRequest(resolve));
-                this.serial.scanEvents.on('stop', () => this.onStopRequest(resolve));
-                let found = false;
-                while (!found && this.isScanning) {
-                    try {
-                        const { protocol } = this.props;
-                        let host, port;
-                        if (this.serial.getName() === exports.SerialInterfaceType.TCPIP) {
-                            [host, port] = this.path.split(':');
-                        }
-                        else {
-                            port = this.path;
-                        }
-                        const adapterSettings = { interface: this.serial.getName(), host, port, protocol };
-                        const adapter = adapters_1.default.create(adapterSettings);
-                        found = yield adapter.check();
-                        if (found) {
-                            this.isFound = true;
-                            const name = adapter.getName();
-                            resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
-                        }
-                        yield (0, utils_1.sleep)(100);
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
-                        yield (0, utils_1.sleep)(100);
-                    }
-                }
-            }));
-        });
-    }
-}
-exports.SinglePathScanner = SinglePathScanner;
 class SerialInterface extends events_1.default {
     static getInstance(props) {
         const { ifaceName, binding, logger } = props;
@@ -312,7 +239,7 @@ class SerialInterface extends events_1.default {
                 return [];
             }
             this.logEvent({ message: 'scanning on ', interface: this.ifaceName, paths: paths.map(p => p.path).join(','), timeout });
-            const scanners = paths.map(p => new SinglePathScanner(p.path, this, Object.assign(Object.assign({}, props), { logger: this.logger })));
+            const scanners = paths.map(p => new serial_scanner_1.SinglePathScanner(p.path, this, Object.assign(Object.assign({}, props), { logger: this.logger })));
             try {
                 yield Promise.all(scanners.map(s => s.scan()
                     .then((device) => __awaiter(this, void 0, void 0, function* () {

package/lib/serial/serial-scanner.d.ts

@@ -0,0 +1,16 @@
+import { EventLogger } from "gd-eventlog";
+import SerialInterface from "./serial-interface";
+import { SerialDeviceSettings, SerialScannerProps } from "./types";
+export declare class SinglePathScanner {
+    path: string;
+    serial: SerialInterface;
+    result: SerialDeviceSettings;
+    isScanning: boolean;
+    props: SerialScannerProps;
+    logger: EventLogger;
+    isFound: boolean;
+    constructor(path: string, serial: SerialInterface, props: SerialScannerProps);
+    logEvent(event: any): void;
+    onStopRequest(resolve: any): Promise<void>;
+    scan(): Promise<SerialDeviceSettings | undefined>;
+}

package/lib/serial/serial-scanner.js

@@ -0,0 +1,87 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SinglePathScanner = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const types_1 = require("./types");
+const adapter_factory_1 = __importDefault(require("./factories/adapter-factory"));
+const utils_1 = require("../utils/utils");
+class SinglePathScanner {
+    constructor(path, serial, props) {
+        this.path = path;
+        this.serial = serial;
+        this.result = undefined;
+        this.isScanning = false;
+        this.isFound = false;
+        this.props = props;
+        this.logger = props.logger || new gd_eventlog_1.EventLogger('SerialScanner');
+    }
+    logEvent(event) {
+        if (this.logger) {
+            this.logger.logEvent(event);
+        }
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            console.log('~~~ SerialScanner', event);
+        }
+    }
+    onStopRequest(resolve) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'stopping scan', path: this.path });
+            if (!this.isFound)
+                yield this.serial.closePort(this.path);
+            this.isScanning = false;
+            resolve(this.result);
+        });
+    }
+    scan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isScanning)
+                return;
+            this.isScanning = true;
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                this.logEvent({ message: 'starting scan', path: this.path, interface: this.serial.getName() });
+                this.serial.scanEvents.on('timeout', () => this.onStopRequest(resolve));
+                this.serial.scanEvents.on('stop', () => this.onStopRequest(resolve));
+                let found = false;
+                while (!found && this.isScanning) {
+                    try {
+                        const { protocol } = this.props;
+                        let host, port;
+                        if (this.serial.getName() === types_1.SerialInterfaceType.TCPIP) {
+                            [host, port] = this.path.split(':');
+                        }
+                        else {
+                            port = this.path;
+                        }
+                        const adapterSettings = { interface: this.serial.getName(), host, port, protocol };
+                        const adapter = adapter_factory_1.default.getInstance().createInstance(adapterSettings);
+                        found = yield adapter.check();
+                        if (found) {
+                            this.isFound = true;
+                            const name = adapter.getName();
+                            resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
+                        }
+                        yield (0, utils_1.sleep)(100);
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
+                        yield (0, utils_1.sleep)(100);
+                    }
+                }
+            }));
+        });
+    }
+}
+exports.SinglePathScanner = SinglePathScanner;

package/lib/serial/serialport.d.ts

@@ -1,17 +1,5 @@
 import { BindingInterface } from '@serialport/bindings-interface';
-export type InterfaceBinding = {
-    name: string;
-    binding: BindingInterface;
-};
-export type InterfaceImplementation = {
-    name: string;
-    Serialport: any;
-    implementation?: any;
-};
-export type SerialPortProps = {
-    interface: string;
-    port?: string;
-};
+import { InterfaceBinding, InterfaceImplementation } from './types';
 export default class SerialPortProvider {
     static _instance: SerialPortProvider;
     interfaces: InterfaceBinding[];

package/lib/serial/types.d.ts

@@ -0,0 +1,45 @@
+import { EventLogger } from "gd-eventlog";
+import SerialInterface from "./base/serial-interface";
+import { BindingInterface } from "@serialport/bindings-interface";
+import { SerialPortStream } from "@serialport/stream";
+import { DeviceSettings, IncyclistScanProps, InterfaceProps } from "../types";
+export type SerialCommProps = {
+    serial: SerialInterface;
+    path: string;
+    logger?: EventLogger;
+};
+export type InterfaceBinding = {
+    name: string;
+    binding: BindingInterface;
+};
+export type InterfaceImplementation = {
+    name: string;
+    Serialport: any;
+    implementation?: any;
+};
+export type SerialPortProps = {
+    interface: string;
+    port?: string;
+};
+export declare enum SerialInterfaceType {
+    SERIAL = "serial",
+    TCPIP = "tcpip"
+}
+export interface SerialInterfaceProps extends InterfaceProps {
+    ifaceName: string;
+    binding?: BindingInterface;
+}
+export type PortMapping = {
+    path: string;
+    port: SerialPortStream;
+};
+export interface SerialScannerProps extends IncyclistScanProps {
+    port?: string;
+    protocol: string;
+}
+export interface SerialDeviceSettings extends DeviceSettings {
+    protocol: string;
+    host?: string;
+    port?: string;
+    interface: string | SerialInterface;
+}

package/lib/serial/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerialInterfaceType = void 0;
+var SerialInterfaceType;
+(function (SerialInterfaceType) {
+    SerialInterfaceType["SERIAL"] = "serial";
+    SerialInterfaceType["TCPIP"] = "tcpip";
+})(SerialInterfaceType || (exports.SerialInterfaceType = SerialInterfaceType = {}));
+;

package/lib/simulator/Simulator.d.ts

@@ -1,21 +1,18 @@
 /// <reference types="node" />
-import { ControllableDevice } from '../base/adpater';
-import ICyclingMode, { CyclingMode, IncyclistBikeData } from '../modes/types';
-import { DeviceProperties, DeviceSettings } from '../types/device';
+import SimulatorCyclingMode from '../modes/simulator';
 import IncyclistDevice from '../base/adpater';
-import { IncyclistDeviceAdapter } from '../types/adapter';
+import { IAdapter, IncyclistBikeData, DeviceProperties, DeviceSettings } from '../types';
 interface SimulatorProperties extends DeviceProperties {
     isBot?: boolean;
     settings?: any;
     activity?: any;
 }
-export declare class SimulatorControl extends ControllableDevice<SimulatorProperties> {
-    getSupportedCyclingModes(): Array<typeof CyclingMode>;
-    getDefaultCyclingMode(): ICyclingMode;
-    sendInitCommands(): Promise<boolean>;
-}
-export declare class Simulator extends IncyclistDevice<SimulatorControl, SimulatorProperties> {
+export declare class Simulator extends IncyclistDevice<SimulatorProperties> {
     static NAME: string;
+    protected static controllers: {
+        modes: (typeof SimulatorCyclingMode)[];
+        default: typeof SimulatorCyclingMode;
+    };
     speed: number;
     power: number;
     cadence: number;
@@ -35,7 +32,7 @@ export declare class Simulator extends IncyclistDevice<SimulatorControl, Simulat
     };
     constructor(settings: DeviceSettings, props?: SimulatorProperties);
     isEqual(settings: DeviceSettings): boolean;
-    isSame(device: IncyclistDeviceAdapter): boolean;
+    isSame(device: IAdapter): boolean;
     getID(): string;
     getName(): string;
     getUniqueName(): string;
@@ -47,8 +44,8 @@ export declare class Simulator extends IncyclistDevice<SimulatorControl, Simulat
     faster(): void;
     slower(): void;
     update(): void;
-    canSendUpdate(): boolean;
+    canEmitData(): boolean;
     calculateDistance(speedKps: any, timeS: any): number;
-    sendUpdate(request: any): import("../modes/types").UpdateRequest;
+    sendUpdate(request: any): import("..").UpdateRequest;
 }
 export {};

package/lib/simulator/Simulator.js

@@ -12,32 +12,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Simulator = exports.SimulatorControl = void 0;
-const adpater_1 = require("../base/adpater");
+exports.Simulator = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
 const simulator_1 = __importDefault(require("../modes/simulator"));
-const capabilities_1 = require("../types/capabilities");
-const adpater_2 = __importDefault(require("../base/adpater"));
+const adpater_1 = __importDefault(require("../base/adpater"));
+const types_1 = require("../types");
 const DEFAULT_PROPS = { isBot: false };
-class SimulatorControl extends adpater_1.ControllableDevice {
-    getSupportedCyclingModes() {
-        return [simulator_1.default];
-    }
-    getDefaultCyclingMode() {
-        return new simulator_1.default(this.adapter);
-    }
-    sendInitCommands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
-        });
-    }
-}
-exports.SimulatorControl = SimulatorControl;
-class Simulator extends adpater_2.default {
+class Simulator extends adpater_1.default {
     constructor(settings, props = DEFAULT_PROPS) {
         super(settings, props);
         this.logger = new gd_eventlog_1.EventLogger(Simulator.NAME);
-        this.setControl(new SimulatorControl(this, props));
         this.speed = 0;
         this.power = 0;
         this.cadence = 90;
@@ -51,8 +35,8 @@ class Simulator extends adpater_2.default {
         const modeSettings = this.isBot ? props.settings : this.getCyclingMode().getSettings();
         this.setCyclingMode(name, modeSettings);
         this.capabilities = [
-            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Gear,
-            capabilities_1.IncyclistCapability.Control
+            types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence, types_1.IncyclistCapability.Gear,
+            types_1.IncyclistCapability.Control
         ];
     }
     isEqual(settings) {
@@ -187,7 +171,7 @@ class Simulator extends adpater_2.default {
         }
         this.emitData(data);
     }
-    canSendUpdate() {
+    canEmitData() {
         return true;
     }
     calculateDistance(speedKps, timeS) {
@@ -201,3 +185,7 @@ class Simulator extends adpater_2.default {
 }
 exports.Simulator = Simulator;
 Simulator.NAME = 'Simulator';
+Simulator.controllers = {
+    modes: [simulator_1.default],
+    default: simulator_1.default
+};

package/lib/types/Command.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+export interface Command {
+    logStr?: string;
+    message: string | Buffer;
+    timeout?: number;
+    onError: (err: Error) => void;
+    onResponse: (response: string | Buffer) => void;
+}

package/lib/types/Command.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/adapter.d.ts

@@ -2,61 +2,50 @@
 import EventEmitter from "events";
 import ICyclingMode, { CyclingMode } from "../modes/types";
 import { IncyclistCapability } from "./capabilities";
-import { DeviceData } from "./data";
+import { IncyclistAdapterData } from "./data";
 import { DeviceProperties, DeviceSettings } from "./device";
 import { User } from "./user";
-import { EventLogger } from "gd-eventlog";
-export type OnDeviceDataCallback = (data: DeviceData) => void;
+export type OnDeviceDataCallback = (data: IncyclistAdapterData) => void;
+export type ControllerConfig = {
+    modes?: Array<typeof CyclingMode>;
+    default?: typeof CyclingMode;
+};
 export interface IBike {
-    isControllable(): boolean;
     setCyclingMode(mode: ICyclingMode | string, settings?: any, sendInitCommands?: boolean): void;
     getSupportedCyclingModes(): Array<typeof CyclingMode>;
     getCyclingMode(): ICyclingMode;
     getDefaultCyclingMode(): ICyclingMode;
     setBikeProps(props: DeviceProperties): void;
     sendInitCommands(): Promise<boolean>;
+    sendUpdate(request: any): any;
     setUser(user: User): void;
     getWeight(): number;
     getUser(): User;
 }
-export interface IncyclistDeviceAdapter extends EventEmitter, IBike {
-    getLogger(): EventLogger;
-    connect(): Promise<boolean>;
-    close(): Promise<boolean>;
-    check(): Promise<boolean>;
-    isEqual(settings: DeviceSettings): boolean;
+export interface ISensor {
+    isControllable(): boolean;
     getCapabilities(): IncyclistCapability[];
     hasCapability(capability: IncyclistCapability): boolean;
     addCapability(capability: IncyclistCapability): void;
-    isControllable(): boolean;
+    getMaxUpdateFrequency(): any;
+    setMaxUpdateFrequency(value: number): any;
+    update(): any;
+}
+export interface IAdapter extends EventEmitter, IBike, ISensor {
     getName(): string;
+    getID(): string;
     getUniqueName(): string;
-    getSettings(): DeviceSettings;
     getDisplayName(): string;
-    update(): any;
+    getSettings(): DeviceSettings;
+    isSame(adapter: IAdapter): boolean;
+    isEqual(settings: DeviceSettings): boolean;
+    getInterface(): string;
+    check(): Promise<boolean>;
     start(props?: DeviceProperties): Promise<boolean>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
-    sendUpdate(request: any): any;
-    getMaxUpdateFrequency(): any;
-    setMaxUpdateFrequency(value: number): any;
-    getInterface(): string;
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
     onData(callback: OnDeviceDataCallback): any;
 }
-export declare class Controllable<P extends DeviceProperties> implements IBike {
-    protected adapter: IncyclistDeviceAdapter;
-    protected props: P;
-    protected user: User;
-    constructor(adapter: IncyclistDeviceAdapter, props?: P);
-    isControllable(): boolean;
-    setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
-    getSupportedCyclingModes(): Array<typeof CyclingMode>;
-    getCyclingMode(): ICyclingMode;
-    getDefaultCyclingMode(): ICyclingMode;
-    sendInitCommands(): Promise<boolean>;
-    setUser(user: User): void;
-    getUser(): User;
-    setBikeProps(props: P): void;
-    getWeight(): number;
-}

package/lib/types/adapter.js

@@ -1,70 +1,2 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Controllable = void 0;
-const adpater_1 = require("../base/adpater");
-class Controllable {
-    constructor(adapter, props) {
-        this.adapter = adapter;
-        this.props = props || {};
-        this.user = {};
-    }
-    isControllable() {
-        throw new Error("Method not implemented.");
-    }
-    setCyclingMode(mode, settings, sendInitCommands) {
-        throw new Error("Method not implemented.");
-    }
-    getSupportedCyclingModes() {
-        throw new Error("Method not implemented.");
-    }
-    getCyclingMode() {
-        throw new Error("Method not implemented.");
-    }
-    getDefaultCyclingMode() {
-        throw new Error("Method not implemented.");
-    }
-    sendInitCommands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("Method not implemented.");
-        });
-    }
-    setUser(user) {
-        this.user = user;
-        if (!user.weight)
-            this.user.weight = adpater_1.DEFAULT_USER_WEIGHT;
-    }
-    getUser() {
-        return this.user;
-    }
-    setBikeProps(props) {
-        const { user, userWeight } = props || {};
-        if (user)
-            this.setUser(user);
-        if (userWeight)
-            this.user.weight = userWeight;
-        const keys = Object.keys(props);
-        keys.forEach(k => {
-            const p = props[k];
-            if (p === null)
-                delete this.props[k];
-            else if (p !== undefined)
-                this.props[k] = p;
-        });
-    }
-    getWeight() {
-        const { user = {}, props = adpater_1.DEFAULT_PROPS } = this;
-        const userWeight = user.weight || props.userWeight || adpater_1.DEFAULT_USER_WEIGHT;
-        const bikeWeight = props.bikeWeight || adpater_1.DEFAULT_BIKE_WEIGHT;
-        return userWeight + bikeWeight;
-    }
-}
-exports.Controllable = Controllable;

package/lib/types/command.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="node" />
-export interface Command {
-    logStr?: string;
-    message: string | Buffer;
-    timeout?: number;
-    onError: (err: Error) => void;
-    onResponse: (response: string | Buffer) => void;
-}

package/lib/types/command.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/data.d.ts

@@ -1,4 +1,4 @@
-export type DeviceData = {
+export type IncyclistAdapterData = {
     speed?: number;
     slope?: number;
     power?: number;
@@ -10,3 +10,14 @@ export type DeviceData = {
     deviceDistanceCounter?: number;
     internalDistanceCounter?: number;
 };
+export type IncyclistBikeData = {
+    isPedalling?: boolean;
+    power: number;
+    pedalRpm: number;
+    speed: number;
+    heartrate?: number;
+    distanceInternal?: number;
+    time?: number;
+    gear?: number;
+    slope?: number;
+};

package/lib/types/device.d.ts

@@ -1,30 +1,15 @@
 import { EventLogger } from "gd-eventlog";
 import { IncyclistInterface } from "./interface";
 import { User } from "./user";
-export declare const INTERFACE: {
-    SERIAL: string;
-    TCPIP: string;
-    ANT: string;
-    BLE: string;
-    USB: string;
-    SIMULATOR: string;
-};
+export declare enum INTERFACE {
+    SERIAL = "serial",
+    TCPIP = "tcpip",
+    ANT = "ant",
+    BLE = "ble",
+    USB = "usb",
+    SIMULATOR = "simulator"
+}
 export type DeviceType = 'race' | 'mountain' | 'triathlon';
-export type Device = {
-    getID(): string;
-    getName(): string;
-    getInterface(): string;
-};
-export type DaumBikeData = {
-    cadence: number;
-    speed: number;
-    power: number;
-    heartrate: number;
-    distanceInternal: number;
-    gear: number;
-    time: number;
-    slope?: number;
-};
 export type DeviceProperties = {
     user?: User;
     userWeight?: number;

package/lib/types/device.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.INTERFACE = void 0;
-exports.INTERFACE = {
-    SERIAL: 'serial',
-    TCPIP: 'tcpip',
-    ANT: 'ant',
-    BLE: 'ble',
-    USB: 'usb',
-    SIMULATOR: 'simulator'
-};
+var INTERFACE;
+(function (INTERFACE) {
+    INTERFACE["SERIAL"] = "serial";
+    INTERFACE["TCPIP"] = "tcpip";
+    INTERFACE["ANT"] = "ant";
+    INTERFACE["BLE"] = "ble";
+    INTERFACE["USB"] = "usb";
+    INTERFACE["SIMULATOR"] = "simulator";
+})(INTERFACE || (exports.INTERFACE = INTERFACE = {}));

package/lib/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './adapter';
+export * from './capabilities';
+export * from './data';
+export * from './device';
+export * from './interface';
+export * from './user';