incyclist-devices 1.5.11 → 1.5.13

package/lib/daum/classic/DaumClassicProtocol.d.ts

@@ -1,27 +1,27 @@
-import DeviceProtocolBase, { ScanProps, DeviceProtocol, DeviceSettings } from '../../protocol';
-import Adapter from './DaumClassicAdapter';
-import { EventLogger } from 'gd-eventlog';
-export interface DaumClassicProtocolState {
-    activeScans: Array<any>;
-    scanning: boolean;
-    stopScanning?: boolean;
-}
-export interface DaumClassicScanProps extends ScanProps {
-    port: string;
-}
-export default class DaumClassicProtocol extends DeviceProtocolBase implements DeviceProtocol {
-    logger: EventLogger;
-    state: DaumClassicProtocolState;
-    constructor();
-    add(settings: DeviceSettings): Adapter;
-    getName(): string;
-    getInterfaces(): Array<string>;
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-    scan(props: DaumClassicScanProps): void;
-    addDevice(opts: any, portName: any): any;
-    stopScan(): Promise<boolean>;
-    isScanning(): boolean;
-    scanCommand(device: any, opts: any): any;
-}
+import DeviceProtocolBase, { ScanProps, DeviceProtocol, DeviceSettings } from '../../protocol';
+import Adapter from './DaumClassicAdapter';
+import { EventLogger } from 'gd-eventlog';
+export interface DaumClassicProtocolState {
+    activeScans: Array<any>;
+    scanning: boolean;
+    stopScanning?: boolean;
+}
+export interface DaumClassicScanProps extends ScanProps {
+    port: string;
+}
+export default class DaumClassicProtocol extends DeviceProtocolBase implements DeviceProtocol {
+    logger: EventLogger;
+    state: DaumClassicProtocolState;
+    constructor();
+    add(settings: DeviceSettings): Adapter;
+    getName(): string;
+    getInterfaces(): Array<string>;
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    scan(props: DaumClassicScanProps): void;
+    addDevice(opts: any, portName: any): any;
+    stopScan(): Promise<boolean>;
+    isScanning(): boolean;
+    scanCommand(device: any, opts: any): any;
+}

package/lib/daum/classic/DaumClassicProtocol.js

@@ -1,185 +1,185 @@
-"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) {
-        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 });
-const protocol_1 = __importStar(require("../../protocol"));
-const registry_1 = __importDefault(require("../../registry"));
-const bike_1 = __importDefault(require("./bike"));
-const DaumClassicAdapter_1 = __importDefault(require("./DaumClassicAdapter"));
-const gd_eventlog_1 = require("gd-eventlog");
-const DaumClassicAdapter_2 = __importDefault(require("./DaumClassicAdapter"));
-const PROTOCOL_NAME = "Daum Classic";
-const DefaultState = {
-    activeScans: [],
-    scanning: false,
-    stopScanning: false
-};
-class DaumClassicProtocol extends protocol_1.default {
-    constructor() {
-        super();
-        this.state = DefaultState;
-        this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
-        this.devices = [];
-    }
-    add(settings) {
-        this.logger.logEvent({ message: 'adding device', settings });
-        const { port } = settings;
-        bike_1.default.setSerialPort(protocol_1.default.getSerialPort());
-        const bike = new bike_1.default({ port });
-        let device = new DaumClassicAdapter_2.default(this, bike);
-        this.devices.push(device);
-        return device;
-    }
-    getName() {
-        return PROTOCOL_NAME;
-    }
-    getInterfaces() {
-        return [protocol_1.INTERFACE.SERIAL];
-    }
-    isBike() {
-        return true;
-    }
-    isHrm() {
-        return true;
-    }
-    isPower() {
-        return true;
-    }
-    scan(props) {
-        this.logger.logEvent({ message: 'start scan', id: props.id, port: props.port });
-        bike_1.default.setSerialPort(protocol_1.default.getSerialPort());
-        this.state.scanning = true;
-        let device = this.addDevice(props, props.port);
-        if (device) {
-            const iv = setInterval(() => { this.scanCommand(device, props); }, 1000);
-            this.state.activeScans.push({ iv, device, props });
-        }
-    }
-    addDevice(opts, portName) {
-        let device;
-        if (this.devices.length === 0) {
-            const bike = new bike_1.default(opts);
-            device = new DaumClassicAdapter_1.default(this, bike);
-            this.devices.push(device);
-        }
-        else {
-            const devices = this.devices;
-            const idx = devices.findIndex(d => d.getBike().getPort() === portName);
-            if (idx === -1) {
-                const bike = new bike_1.default(opts);
-                device = new DaumClassicAdapter_1.default(this, bike);
-                this.devices.push(device);
-            }
-            else {
-                device = this.devices[idx];
-                if (device.isSelected() || device.isDetected())
-                    device = undefined;
-            }
-        }
-        return device;
-    }
-    stopScan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.state.stopScanning)
-                return;
-            this.state.stopScanning = true;
-            this.logger.logEvent({ message: 'stop scan', activeScans: this.state.activeScans });
-            const stopRequired = [];
-            if (this.state.activeScans.length > 0) {
-                this.state.activeScans.forEach(scan => {
-                    stopRequired.push(scan.scanning);
-                    clearInterval(scan.iv);
-                    scan.iv = undefined;
-                    scan.scanning = false;
-                });
-            }
-            for (let i = 0; i < this.state.activeScans.length; i++) {
-                const as = this.state.activeScans[i];
-                const toStop = stopRequired[i];
-                const d = as.device;
-                if (!d.isSelected() && !d.isDetected()) {
-                    try {
-                        yield d.close();
-                    }
-                    catch (err) {
-                        this.logger.logEvent({ message: 'stop scan error', error: err.message });
-                    }
-                }
-                if (toStop) {
-                    const { id, onScanFinished } = as.props;
-                    if (onScanFinished)
-                        onScanFinished(id);
-                }
-            }
-            this.state.activeScans = [];
-            this.state.scanning = false;
-            this.state.stopScanning = false;
-            this.logger.logEvent({ message: 'stop scan completed' });
-            return true;
-        });
-    }
-    isScanning() {
-        return this.state.scanning;
-    }
-    scanCommand(device, opts) {
-        const scan = this.state.activeScans.find(actScan => actScan.device.getBike().getPort() === device.getBike().getPort());
-        if (this.state.stopScanning || (scan && scan.scanning) || device.isDetected())
-            return;
-        scan.scanning = true;
-        return device.check()
-            .then(() => __awaiter(this, void 0, void 0, function* () {
-            if (this.state.stopScanning)
-                return;
-            const { onDeviceFound, onScanFinished, id } = opts;
-            device.setDetected();
-            if (onDeviceFound)
-                onDeviceFound(device, device.getProtocol());
-            if (onScanFinished) {
-                onScanFinished(id);
-            }
-            try {
-                yield device.getBike().saveClose();
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'scanCommand warning: Could not close port', error: err.message });
-            }
-            clearInterval(scan.iv);
-            scan.iv = undefined;
-            scan.scanning = false;
-        }))
-            .catch(() => {
-            scan.scanning = false;
-        });
-    }
-}
-exports.default = DaumClassicProtocol;
-registry_1.default.register(new DaumClassicProtocol());
+"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) {
+        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 });
+const protocol_1 = __importStar(require("../../protocol"));
+const registry_1 = __importDefault(require("../../registry"));
+const bike_1 = __importDefault(require("./bike"));
+const DaumClassicAdapter_1 = __importDefault(require("./DaumClassicAdapter"));
+const gd_eventlog_1 = require("gd-eventlog");
+const DaumClassicAdapter_2 = __importDefault(require("./DaumClassicAdapter"));
+const PROTOCOL_NAME = "Daum Classic";
+const DefaultState = {
+    activeScans: [],
+    scanning: false,
+    stopScanning: false
+};
+class DaumClassicProtocol extends protocol_1.default {
+    constructor() {
+        super();
+        this.state = DefaultState;
+        this.logger = new gd_eventlog_1.EventLogger('DaumClassic');
+        this.devices = [];
+    }
+    add(settings) {
+        this.logger.logEvent({ message: 'adding device', settings });
+        const { port } = settings;
+        bike_1.default.setSerialPort(protocol_1.default.getSerialPort());
+        const bike = new bike_1.default({ port });
+        let device = new DaumClassicAdapter_2.default(this, bike);
+        this.devices.push(device);
+        return device;
+    }
+    getName() {
+        return PROTOCOL_NAME;
+    }
+    getInterfaces() {
+        return [protocol_1.INTERFACE.SERIAL];
+    }
+    isBike() {
+        return true;
+    }
+    isHrm() {
+        return true;
+    }
+    isPower() {
+        return true;
+    }
+    scan(props) {
+        this.logger.logEvent({ message: 'start scan', id: props.id, port: props.port });
+        bike_1.default.setSerialPort(protocol_1.default.getSerialPort());
+        this.state.scanning = true;
+        let device = this.addDevice(props, props.port);
+        if (device) {
+            const iv = setInterval(() => { this.scanCommand(device, props); }, 1000);
+            this.state.activeScans.push({ iv, device, props });
+        }
+    }
+    addDevice(opts, portName) {
+        let device;
+        if (this.devices.length === 0) {
+            const bike = new bike_1.default(opts);
+            device = new DaumClassicAdapter_1.default(this, bike);
+            this.devices.push(device);
+        }
+        else {
+            const devices = this.devices;
+            const idx = devices.findIndex(d => d.getBike().getPort() === portName);
+            if (idx === -1) {
+                const bike = new bike_1.default(opts);
+                device = new DaumClassicAdapter_1.default(this, bike);
+                this.devices.push(device);
+            }
+            else {
+                device = this.devices[idx];
+                if (device.isSelected() || device.isDetected())
+                    device = undefined;
+            }
+        }
+        return device;
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.stopScanning)
+                return;
+            this.state.stopScanning = true;
+            this.logger.logEvent({ message: 'stop scan', activeScans: this.state.activeScans });
+            const stopRequired = [];
+            if (this.state.activeScans.length > 0) {
+                this.state.activeScans.forEach(scan => {
+                    stopRequired.push(scan.scanning);
+                    clearInterval(scan.iv);
+                    scan.iv = undefined;
+                    scan.scanning = false;
+                });
+            }
+            for (let i = 0; i < this.state.activeScans.length; i++) {
+                const as = this.state.activeScans[i];
+                const toStop = stopRequired[i];
+                const d = as.device;
+                if (!d.isSelected() && !d.isDetected()) {
+                    try {
+                        yield d.close();
+                    }
+                    catch (err) {
+                        this.logger.logEvent({ message: 'stop scan error', error: err.message });
+                    }
+                }
+                if (toStop) {
+                    const { id, onScanFinished } = as.props;
+                    if (onScanFinished)
+                        onScanFinished(id);
+                }
+            }
+            this.state.activeScans = [];
+            this.state.scanning = false;
+            this.state.stopScanning = false;
+            this.logger.logEvent({ message: 'stop scan completed' });
+            return true;
+        });
+    }
+    isScanning() {
+        return this.state.scanning;
+    }
+    scanCommand(device, opts) {
+        const scan = this.state.activeScans.find(actScan => actScan.device.getBike().getPort() === device.getBike().getPort());
+        if (this.state.stopScanning || (scan && scan.scanning) || device.isDetected())
+            return;
+        scan.scanning = true;
+        return device.check()
+            .then(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.state.stopScanning)
+                return;
+            const { onDeviceFound, onScanFinished, id } = opts;
+            device.setDetected();
+            if (onDeviceFound)
+                onDeviceFound(device, device.getProtocol());
+            if (onScanFinished) {
+                onScanFinished(id);
+            }
+            try {
+                yield device.getBike().saveClose();
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'scanCommand warning: Could not close port', error: err.message });
+            }
+            clearInterval(scan.iv);
+            scan.iv = undefined;
+            scan.scanning = false;
+        }))
+            .catch(() => {
+            scan.scanning = false;
+        });
+    }
+}
+exports.default = DaumClassicProtocol;
+registry_1.default.register(new DaumClassicProtocol());

package/lib/daum/classic/bike.d.ts

@@ -1,68 +1,68 @@
-import { EventLogger } from 'gd-eventlog';
-import { Queue } from '../../utils';
-import { User } from '../../types/user';
-declare type SuccessCallbackFn = (data: any) => void;
-declare type ErrorCallbackFn = (status: number, error: any) => void;
-interface CommandInstructions {
-    logStr: string;
-    payload: Array<number>;
-    expected: number;
-    callback: SuccessCallbackFn;
-    callbackErr: ErrorCallbackFn;
-    options?: any;
-}
-export default class Daum8008 {
-    logger: EventLogger;
-    portName: string;
-    settings: any;
-    bikeData: any;
-    sp: any;
-    error: Error;
-    opening: boolean;
-    connected: boolean;
-    closing: boolean;
-    closed: boolean;
-    cmdBusy: boolean;
-    queue: Queue<CommandInstructions>;
-    bikeCmdWorker: any;
-    cmdStart: number;
-    cmdCurrent: any;
-    isLoggingPaused: boolean;
-    constructor(opts?: any);
-    static setSerialPort(spClass: any): void;
-    static getClassName(): string;
-    getType(): string;
-    getPort(): string;
-    isConnected(): boolean;
-    pauseLogging(): void;
-    resumLogging(): void;
-    logEvent(e: any): void;
-    setUser(user: User, callback: any): void;
-    getUserWeight(): number;
-    getBikeWeight(): any;
-    connect(): void;
-    saveConnect(): Promise<unknown>;
-    close(): void;
-    saveClose(): Promise<unknown>;
-    onPortOpen(): void;
-    onPortClose(): void;
-    onPortError(err: any): void;
-    startWorker(): void;
-    sendDaum8008CommandfromQueue(): any;
-    sendDaum8008Command(logStr: any, payload: any, expected: any, callback?: any, callbackErr?: any, options?: any): void;
-    send(cmdInfo: any): void;
-    checkCockpit(bikeNo?: number): Promise<unknown>;
-    getAddress(): Promise<unknown>;
-    getVersion(bikeNo?: number): Promise<unknown>;
-    resetDevice(bikeNo?: number): Promise<unknown>;
-    startProg(bikeNo?: number): Promise<unknown>;
-    stopProg(bikeNo?: number): Promise<unknown>;
-    setProg(progNo?: number, bikeNo?: number): Promise<unknown>;
-    setBikeType(bikeType: any, bikeNo?: number): Promise<unknown>;
-    setPerson(user?: User, bikeNo?: number): Promise<unknown>;
-    runData(bikeNo?: number): Promise<unknown>;
-    setGear(gear: any, bikeNo?: number): Promise<unknown>;
-    setPower(power: any, bikeNo?: number): Promise<unknown>;
-    setSlope(slope: any, bikeNo?: number): Promise<unknown>;
-}
-export {};
+import { EventLogger } from 'gd-eventlog';
+import { Queue } from '../../utils';
+import { User } from '../../types/user';
+declare type SuccessCallbackFn = (data: any) => void;
+declare type ErrorCallbackFn = (status: number, error: any) => void;
+interface CommandInstructions {
+    logStr: string;
+    payload: Array<number>;
+    expected: number;
+    callback: SuccessCallbackFn;
+    callbackErr: ErrorCallbackFn;
+    options?: any;
+}
+export default class Daum8008 {
+    logger: EventLogger;
+    portName: string;
+    settings: any;
+    bikeData: any;
+    sp: any;
+    error: Error;
+    opening: boolean;
+    connected: boolean;
+    closing: boolean;
+    closed: boolean;
+    cmdBusy: boolean;
+    queue: Queue<CommandInstructions>;
+    bikeCmdWorker: any;
+    cmdStart: number;
+    cmdCurrent: any;
+    isLoggingPaused: boolean;
+    constructor(opts?: any);
+    static setSerialPort(spClass: any): void;
+    static getClassName(): string;
+    getType(): string;
+    getPort(): string;
+    isConnected(): boolean;
+    pauseLogging(): void;
+    resumLogging(): void;
+    logEvent(e: any): void;
+    setUser(user: User, callback: any): void;
+    getUserWeight(): number;
+    getBikeWeight(): any;
+    connect(): void;
+    saveConnect(): Promise<unknown>;
+    close(): void;
+    saveClose(): Promise<unknown>;
+    onPortOpen(): void;
+    onPortClose(): void;
+    onPortError(err: any): void;
+    startWorker(): void;
+    sendDaum8008CommandfromQueue(): any;
+    sendDaum8008Command(logStr: any, payload: any, expected: any, callback?: any, callbackErr?: any, options?: any): void;
+    send(cmdInfo: any): void;
+    checkCockpit(bikeNo?: number): Promise<unknown>;
+    getAddress(): Promise<unknown>;
+    getVersion(bikeNo?: number): Promise<unknown>;
+    resetDevice(bikeNo?: number): Promise<unknown>;
+    startProg(bikeNo?: number): Promise<unknown>;
+    stopProg(bikeNo?: number): Promise<unknown>;
+    setProg(progNo?: number, bikeNo?: number): Promise<unknown>;
+    setBikeType(bikeType: any, bikeNo?: number): Promise<unknown>;
+    setPerson(user?: User, bikeNo?: number): Promise<unknown>;
+    runData(bikeNo?: number): Promise<unknown>;
+    setGear(gear: any, bikeNo?: number): Promise<unknown>;
+    setPower(power: any, bikeNo?: number): Promise<unknown>;
+    setSlope(slope: any, bikeNo?: number): Promise<unknown>;
+}
+export {};