incyclist-devices 1.5.38 → 2.0.0

package/lib/serial/bindings/tcp.js

@@ -0,0 +1,284 @@
+"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.TCPPortBinding = exports.TCPBinding = exports.getSubnets = exports.scanSubNet = exports.scanPort = exports.CanceledError = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const os_1 = require("os");
+const net_1 = __importDefault(require("net"));
+function resolveNextTick() {
+    return new Promise(resolve => process.nextTick(() => resolve()));
+}
+class CanceledError extends Error {
+    constructor(message) {
+        super(message);
+        this.canceled = true;
+    }
+}
+exports.CanceledError = CanceledError;
+function scanPort(host, port) {
+    return new Promise((resolve) => {
+        try {
+            const socket = new net_1.default.Socket();
+            const cleanup = () => {
+                try {
+                    socket.destroy();
+                }
+                catch (err) { }
+                socket.removeAllListeners();
+            };
+            socket.setTimeout(1000);
+            socket.on('timeout', () => { resolve(false); ; cleanup(); });
+            socket.on('error', (err) => { resolve(false); cleanup(); });
+            socket.on('ready', () => { resolve(true); cleanup(); });
+            socket.connect(port, host);
+        }
+        catch (err) {
+            resolve(false);
+        }
+    });
+}
+exports.scanPort = scanPort;
+function scanSubNet(sn, port) {
+    const range = [];
+    for (let i = 1; i < 255; i++)
+        range.push(i);
+    return Promise.all(range.map(j => scanPort(`${sn}.${j}`, port).then(success => success ? `${sn}.${j}` : null).catch()))
+        .then(hosts => hosts.filter(h => h !== null))
+        .catch();
+}
+exports.scanSubNet = scanSubNet;
+function getSubnets() {
+    const nets = (0, os_1.networkInterfaces)();
+    const results = [];
+    const names = Object.keys(nets);
+    names.forEach(name => {
+        for (const net of nets[name]) {
+            if (net.family === 'IPv4' && !net.internal) {
+                results.push(net.address);
+            }
+        }
+    });
+    const address = Object.keys((0, os_1.networkInterfaces)())
+        .reduce((a, key) => [
+        ...a,
+        ...(0, os_1.networkInterfaces)()[key]
+    ], [])
+        .filter(iface => iface.family === 'IPv4' && !iface.internal && iface.netmask === '255.255.255.0')
+        .map(iface => {
+        const parts = iface.address.split('.');
+        return `${parts[0]}.${parts[1]}.${parts[2]}`;
+    });
+    const subnets = address.filter((x, i) => i === address.indexOf(x));
+    subnets.push('127.0.0');
+    return subnets;
+}
+exports.getSubnets = getSubnets;
+exports.TCPBinding = {
+    list(port) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!port)
+                return [];
+            const subnets = getSubnets();
+            const hosts = [];
+            yield Promise.all(subnets.map(sn => scanSubNet(sn, port).then(found => { hosts.push(...found); })));
+            return hosts.map(host => ({
+                path: `${host}:${port}`,
+                manufacturer: undefined,
+                locationId: undefined,
+                pnpId: undefined,
+                productId: undefined,
+                serialNumber: undefined,
+                vendorId: undefined
+            }));
+        });
+    },
+    open(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const asyncOpen = () => {
+                return new Promise((resolve, reject) => {
+                    let host, port;
+                    if (!options.path)
+                        return reject(new TypeError('"path" is not valid'));
+                    try {
+                        const res = options.path.split(':');
+                        if (res.length !== 2)
+                            return reject(new TypeError('"path" is not valid'));
+                        host = res[0];
+                        port = Number(res[1]);
+                        if (isNaN(port))
+                            return reject(new TypeError('"path" is not valid'));
+                    }
+                    catch (err) {
+                        return reject(new TypeError('"path" is not valid'));
+                    }
+                    const socket = new net_1.default.Socket();
+                    if (options.timeout)
+                        socket.setTimeout(options.timeout);
+                    socket.once('timeout', () => { reject(new Error('timeout')); });
+                    socket.once('error', (err) => { reject(err); });
+                    socket.once('connect', () => { resolve(socket); });
+                    socket.connect(port, host);
+                });
+            };
+            const openOptions = Object.assign({ dataBits: 8, lock: true, stopBits: 1, parity: 'none', rtscts: false, xon: false, xoff: false, xany: false, hupcl: true }, options);
+            const socket = yield asyncOpen();
+            return new TCPPortBinding(socket, openOptions);
+        });
+    }
+};
+class TCPPortBinding {
+    constructor(socket, options) {
+        this.logger = new gd_eventlog_1.EventLogger('TCPPort');
+        this.socket = socket;
+        this.openOptions = options;
+        this.pendingRead = null;
+        this.writeOperation = null;
+        this.data = null;
+        this.socket.on('data', this.onData.bind(this));
+        this.socket.on('error', this.onError.bind(this));
+        this.socket.on('close', () => { this.close(); });
+        this.socket.on('end', () => { this.close(); });
+        this.socket.on('timeout', () => { this.onError(new Error('socket timeout')); });
+    }
+    get isOpen() {
+        return this.socket !== null;
+    }
+    onData(data) {
+        if (!this.data)
+            this.data = Buffer.alloc(0);
+        const buffer = Buffer.from(data);
+        this.data = Buffer.concat([this.data, buffer]);
+        if (this.pendingRead) {
+            process.nextTick(this.pendingRead);
+            this.pendingRead = null;
+        }
+    }
+    onError(err) {
+        if (this.pendingRead) {
+            this.pendingRead(err);
+            this.socket = null;
+        }
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isOpen)
+                return;
+            this.data = Buffer.alloc(0);
+            const socket = this.socket;
+            socket.removeAllListeners();
+            socket.destroy();
+            socket.on('error', () => { });
+            setTimeout(() => { socket.removeAllListeners(); }, 500);
+            this.socket = null;
+            if (this.pendingRead) {
+                this.pendingRead(new CanceledError('port is closed'));
+            }
+        });
+    }
+    read(buffer, offset, length) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isOpen) {
+                throw new Error('Port is not open');
+            }
+            if (!Buffer.isBuffer(buffer)) {
+                throw new TypeError('"buffer" is not a Buffer');
+            }
+            if (typeof offset !== 'number' || isNaN(offset)) {
+                throw new TypeError(`"offset" is not an integer got "${isNaN(offset) ? 'NaN' : typeof offset}"`);
+            }
+            if (typeof length !== 'number' || isNaN(length)) {
+                throw new TypeError(`"length" is not an integer got "${isNaN(length) ? 'NaN' : typeof length}"`);
+            }
+            if (buffer.length < offset + length) {
+                throw new Error('buffer is too small');
+            }
+            yield resolveNextTick();
+            if (!this.data || this.data.length === 0) {
+                return new Promise((resolve, reject) => {
+                    this.pendingRead = err => {
+                        if (err) {
+                            return reject(err);
+                        }
+                        this.read(buffer, offset, length).then(resolve, reject);
+                    };
+                });
+            }
+            const lengthToRead = length === 65536 ? this.data.length : length;
+            const toCopy = this.data.slice(0, lengthToRead);
+            const bytesRead = toCopy.copy(buffer, offset);
+            this.data = this.data.slice(lengthToRead);
+            this.pendingRead = null;
+            return ({ buffer, bytesRead });
+        });
+    }
+    write(buffer) {
+        if (!this.isOpen) {
+            throw new Error('Port is not open');
+        }
+        this.writeOperation = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            yield resolveNextTick();
+            this.socket.write(buffer, () => {
+                resolve();
+            });
+        }));
+        return this.writeOperation;
+    }
+    update(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield resolveNextTick();
+        });
+    }
+    set(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield resolveNextTick();
+        });
+    }
+    get() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isOpen) {
+                throw new Error('Port is not open');
+            }
+            yield resolveNextTick();
+            return {
+                cts: true,
+                dsr: false,
+                dcd: false,
+            };
+        });
+    }
+    getBaudRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return { baudRate: 9600 };
+        });
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isOpen) {
+                throw new Error('Port is not open');
+            }
+            yield resolveNextTick();
+            this.data = Buffer.alloc(0);
+        });
+    }
+    drain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isOpen) {
+                throw new Error('Port is not open');
+            }
+            yield resolveNextTick();
+            yield this.writeOperation;
+        });
+    }
+}
+exports.TCPPortBinding = TCPPortBinding;

package/lib/serial/comm.d.ts

@@ -0,0 +1,7 @@
+import { EventLogger } from "gd-eventlog";
+import SerialInterface from "./serial-interface";
+export type SerialCommProps = {
+    serial: SerialInterface;
+    path: string;
+    logger?: EventLogger;
+};

package/lib/serial/comm.js

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

package/lib/{daum → serial/daum}/DaumAdapter.d.ts

@@ -1,11 +1,13 @@
 import { EventLogger } from 'gd-eventlog';
-import CyclingMode, { IncyclistBikeData } from '../cycling-mode';
-import IncyclistDevice, { Bike, DeviceAdapter, DeviceData } from '../device';
-import { User } from '../types/user';
+import CyclingMode, { IncyclistBikeData } from '../../modes/cycling-mode';
+import { Bike } from '../../types/adapter';
+import { DeviceProperties } from '../../types/device';
+import { SerialDeviceSettings, SerialIncyclistDevice } from '../adapter';
+import { DeviceData } from '../../types/data';
 interface DaumAdapter {
     getCurrentBikeData(): Promise<any>;
 }
-export default class DaumAdapterBase extends IncyclistDevice implements DeviceAdapter, DaumAdapter, Bike {
+export default class DaumAdapterBase extends SerialIncyclistDevice implements DaumAdapter, Bike {
     bike: any;
     ignoreHrm: boolean;
     ignoreBike: boolean;
@@ -19,42 +21,30 @@ export default class DaumAdapterBase extends IncyclistDevice implements DeviceAd
     requests: Array<any>;
     iv: any;
     logger: EventLogger;
-    cyclingMode: CyclingMode;
-    userSettings: User;
-    bikeSettings: any;
     tsPrevData: number;
     adapterTime: number;
     requestBusy: boolean;
     updateBusy: boolean;
-    constructor(props: any, bike: any);
+    constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
     setCyclingMode(mode: CyclingMode | string, settings?: any): void;
     getSupportedCyclingModes(): Array<any>;
     getCyclingMode(): CyclingMode;
     getDefaultCyclingMode(): CyclingMode;
-    setUserSettings(userSettings: User): void;
-    setBikeSettings(bikeSettings: any): void;
-    getWeight(): number;
     getCurrentBikeData(): Promise<any>;
     getBike(): any;
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
-    isSame(device: DeviceAdapter): boolean;
-    setIgnoreHrm(ignore: any): void;
-    setIgnoreBike(ignore: any): void;
+    isEqual(settings: SerialDeviceSettings): boolean;
+    isSame(device: SerialIncyclistDevice): boolean;
     isStopped(): boolean;
     initData(): void;
-    start(props?: any): Promise<any>;
+    start(props?: DeviceProperties): Promise<any>;
     stopUpdatePull(): void;
     startUpdatePull(): void;
-    connect(): void;
-    close(): any;
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
     logEvent(event: any): void;
     stop(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
+    canSendUpdate(): boolean;
     sendUpdate(request: any): Promise<unknown>;
-    sendData(): void;
     update(): Promise<void>;
     sendRequests(): Promise<void>;
     bikeSync(): Promise<void>;
@@ -63,5 +53,6 @@ export default class DaumAdapterBase extends IncyclistDevice implements DeviceAd
     sendRequest(request: any): Promise<any>;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<unknown>;
+    check(): Promise<boolean>;
 }
 export {};

package/lib/{daum → serial/daum}/DaumAdapter.js

@@ -1,23 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 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) {
@@ -31,19 +12,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const device_1 = __importStar(require("../device"));
 const ERGCyclingMode_1 = __importDefault(require("./ERGCyclingMode"));
 const SmartTrainerCyclingMode_1 = __importDefault(require("./SmartTrainerCyclingMode"));
 const DaumPowerMeterCyclingMode_1 = __importDefault(require("./DaumPowerMeterCyclingMode"));
-const utils_1 = require("../utils");
-class DaumAdapterBase extends device_1.default {
-    constructor(props, bike) {
-        super(props);
+const utils_1 = require("../../utils/utils");
+const adapter_1 = require("../adapter");
+const capabilities_1 = require("../../types/capabilities");
+class DaumAdapterBase extends adapter_1.SerialIncyclistDevice {
+    constructor(settings, props) {
+        super(settings, props);
         this.requests = [];
         this.adapterTime = 0;
         this.requestBusy = false;
         this.updateBusy = false;
-        this.bike = bike;
         this.stopped = false;
         this.paused = false;
         this.cyclingData = {
@@ -56,21 +37,23 @@ class DaumAdapterBase extends device_1.default {
             heartrate: 0
         };
         this.deviceData = {};
-        const options = props || {};
-        this.cyclingMode = options.cyclingMode;
-        this.setUserSettings(options.userSettings);
-        this.setBikeSettings(options.bikeSettings);
+        this.capabilities = [
+            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Gear, capabilities_1.IncyclistCapability.HeartRate,
+            capabilities_1.IncyclistCapability.Control
+        ];
     }
     setCyclingMode(mode, settings) {
-        let selectedMode;
+        let selectedMode = this.cyclingMode;
         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.cyclingMode = new CyclingModeClass(this, settings);
-                return;
+            if (!this.cyclingMode || this.cyclingMode.getName() !== mode) {
+                const supported = this.getSupportedCyclingModes();
+                const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
+                if (CyclingModeClass) {
+                    this.cyclingMode = new CyclingModeClass(this, settings);
+                    return;
+                }
+                selectedMode = this.getDefaultCyclingMode();
             }
-            selectedMode = this.getDefaultCyclingMode();
         }
         else {
             selectedMode = mode;
@@ -89,42 +72,18 @@ class DaumAdapterBase extends device_1.default {
     getDefaultCyclingMode() {
         return new ERGCyclingMode_1.default(this);
     }
-    setUserSettings(userSettings) {
-        this.userSettings = userSettings || {};
-        if (this.bike) {
-            if (!this.bike.settings)
-                this.bike.settings = { user: {} };
-            if (!this.bike.settings.user)
-                this.bike.settings.user = {};
-            this.bike.settings.user.weight = this.userSettings.weight || device_1.DEFAULT_USER_WEIGHT;
-        }
-    }
-    setBikeSettings(bikeSettings) {
-        this.bikeSettings = bikeSettings || {};
-        if (this.bike) {
-            if (!this.bike.settings)
-                this.bike.settings = {};
-            this.bike.settings.weight = this.userSettings.weight || device_1.DEFAULT_BIKE_WEIGHT;
-        }
-    }
-    getWeight() {
-        const userWeight = Number(this.userSettings.weight || device_1.DEFAULT_USER_WEIGHT);
-        const bikeWeight = Number(this.bikeSettings.weight || device_1.DEFAULT_BIKE_WEIGHT);
-        return bikeWeight + userWeight;
-    }
     getCurrentBikeData() {
         throw new Error('Method not implemented.');
     }
     getBike() {
         return this.bike;
     }
-    isBike() {
-        return true;
-    }
-    isPower() {
-        return true;
-    }
-    isHrm() {
+    isEqual(settings) {
+        const as = this.settings;
+        if (settings.interface !== this.getInterface())
+            return false;
+        if (settings.protocol !== as.protocol || settings.port !== as.port)
+            return false;
         return true;
     }
     isSame(device) {
@@ -133,12 +92,6 @@ class DaumAdapterBase extends device_1.default {
         const adapter = device;
         return (adapter.getName() === this.getName() && adapter.getPort() === this.getPort());
     }
-    setIgnoreHrm(ignore) {
-        this.ignoreHrm = ignore;
-    }
-    setIgnoreBike(ignore) {
-        this.ignoreBike = ignore;
-    }
     isStopped() {
         return this.stopped;
     }
@@ -181,22 +134,35 @@ class DaumAdapterBase extends device_1.default {
             return;
         const ivSync = setInterval(() => {
             this.bikeSync();
-        }, 1000);
+        }, this.pullFrequency);
         const ivUpdate = setInterval(() => {
-            this.sendData();
+            this.emitData(this.deviceData);
             this.refreshRequests();
-        }, 1000);
+        }, this.pullFrequency);
         this.iv = {
             sync: ivSync,
             update: ivUpdate
         };
     }
     connect() {
-        if (!this.bike.isConnected())
-            this.bike.connect();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.bike.isConnected())
+                return true;
+            try {
+                const connected = yield this.bike.connect();
+                return connected;
+            }
+            catch (err) {
+                return false;
+            }
+        });
     }
     close() {
-        return this.bike.saveClose();
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.bike.isConnected())
+                return true;
+            return yield this.bike.close();
+        });
     }
     logEvent(event) {
         if (!this.logger)
@@ -217,7 +183,8 @@ class DaumAdapterBase extends device_1.default {
                         clearInterval(this.iv.update);
                     this.iv = undefined;
                 }
-                this.bike.stopWorker();
+                if (this.bike.stopWorker && typeof this.bike.stopWorker === 'function')
+                    this.bike.stopWorker();
                 this.logEvent({ message: 'stop request completed' });
                 this.paused = undefined;
                 resolve(true);
@@ -228,19 +195,10 @@ class DaumAdapterBase extends device_1.default {
             }
         });
     }
-    pause() {
-        this.logEvent({ message: 'pause' });
-        return new Promise(resolve => {
-            this.paused = true;
-            resolve(true);
-        });
-    }
-    resume() {
-        this.logEvent({ message: 'resume' });
-        return new Promise(resolve => {
-            this.paused = false;
-            resolve(true);
-        });
+    canSendUpdate() {
+        if (this.paused || this.stopped)
+            return false;
+        return super.canSendUpdate();
     }
     sendUpdate(request) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -250,10 +208,6 @@ class DaumAdapterBase extends device_1.default {
             return yield this.processClientRequest(request);
         });
     }
-    sendData() {
-        if (this.onDataFn)
-            this.onDataFn(this.deviceData);
-    }
     update() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.stopped)
@@ -261,9 +215,11 @@ class DaumAdapterBase extends device_1.default {
             this.updateBusy = true;
             this.getCurrentBikeData()
                 .then(bikeData => {
+                console.log('~~~ bike data', bikeData);
                 this.updateData(this.cyclingData, bikeData);
-                this.transformData();
+                const data = this.transformData();
                 this.updateBusy = false;
+                this.emitData(data);
             })
                 .catch(err => {
                 this.logEvent({ message: 'bike update error', error: err.message, stack: err.stack });
@@ -359,6 +315,7 @@ class DaumAdapterBase extends device_1.default {
             data = { heartrate: data.heartrate };
         }
         this.deviceData = data;
+        return data;
     }
     sendRequest(request) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -408,5 +365,8 @@ class DaumAdapterBase extends device_1.default {
             resolve(bikeRequest);
         }));
     }
+    check() {
+        throw new Error('Method not implemented.');
+    }
 }
 exports.default = DaumAdapterBase;

package/lib/{daum → serial/daum}/DaumPowerMeterCyclingMode.d.ts

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

package/lib/{daum → serial/daum}/DaumPowerMeterCyclingMode.js

@@ -3,7 +3,7 @@ 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"));
+const power_meter_1 = __importDefault(require("../../modes/power-meter"));
 class DaumPowerMeterCyclingMode extends power_meter_1.default {
     constructor() {
         super(...arguments);

package/lib/{daum → serial/daum}/ERGCyclingMode.d.ts

@@ -1,7 +1,7 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../cycling-mode";
+import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../../modes/cycling-mode";
 import DaumAdapter from "./DaumAdapter";
-import PowerBasedCyclingModeBase from "../modes/power-base";
-export declare type ERGEvent = {
+import PowerBasedCyclingModeBase from "../../modes/power-base";
+export type ERGEvent = {
     rpmUpdated?: boolean;
     gearUpdated?: boolean;
     starting?: boolean;

package/lib/{daum → serial/daum}/ERGCyclingMode.js

@@ -3,9 +3,9 @@ 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 cycling_mode_1 = require("../../modes/cycling-mode");
+const calculations_1 = __importDefault(require("../../utils/calculations"));
+const power_base_1 = __importDefault(require("../../modes/power-base"));
 const MIN_SPEED = 10;
 const config = {
     name: "ERG",