incyclist-devices 1.5.38 → 2.0.0-beta.1

package/lib/daum/classic/DaumClassicProtocol.js

@@ -1,185 +0,0 @@
-"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/premium/DaumPremiumAdapter.d.ts

@@ -1,16 +0,0 @@
-import DaumAdapter from '../DaumAdapter';
-export default class DaumPremiumDevice extends DaumAdapter {
-    static NAME: string;
-    constructor(protocol: any, bike: any);
-    getName(): string;
-    getPort(): any;
-    getInterface(): any;
-    getSupportedCyclingModes(): Array<any>;
-    check(): Promise<unknown>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-    startRide(props: any): Promise<boolean>;
-    start(props: any): Promise<boolean>;
-    launch(props: any, isRelaunch?: boolean): Promise<boolean>;
-    getCurrentBikeData(): Promise<any>;
-}

package/lib/daum/premium/DaumPremiumProtocol.d.ts

@@ -1,32 +0,0 @@
-import DeviceProtocolBase, { DeviceProtocol, DeviceSettings } from '../../protocol';
-import { EventLogger } from 'gd-eventlog';
-export interface DaumPremiumProtocolState {
-    activeScans: Array<any>;
-    scanning: boolean;
-    stopScanning?: boolean;
-}
-interface DaumPremiumSettings extends DeviceSettings {
-    interface: string;
-}
-interface DaumPremiumTCPSettings extends DaumPremiumSettings {
-    host: string;
-}
-export default class DaumPremiumProtocol extends DeviceProtocolBase implements DeviceProtocol {
-    state: DaumPremiumProtocolState;
-    logger: EventLogger;
-    constructor();
-    add(settings: DaumPremiumSettings | DaumPremiumTCPSettings): any;
-    getName(): string;
-    getInterfaces(): string[];
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-    scan(props: any): void;
-    addDevice(DeviceClass: any, opts: any, portName: any): any;
-    scanTcpip(opts: any): void;
-    scanSerial(opts: any): void;
-    isScanning(): boolean;
-    stopScan(): Promise<boolean>;
-    scanCommand(device: any, opts: any): void;
-}
-export {};

package/lib/daum/premium/DaumPremiumProtocol.js

@@ -1,207 +0,0 @@
-"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 = require("../premium/bike");
-const DaumPremiumAdapter_1 = __importDefault(require("./DaumPremiumAdapter"));
-const gd_eventlog_1 = require("gd-eventlog");
-const PROTOCOL_NAME = "Daum Premium";
-const DefaultState = {
-    activeScans: [],
-    scanning: false,
-    stopScanning: false
-};
-class DaumPremiumProtocol extends protocol_1.default {
-    constructor() {
-        super();
-        this.state = DefaultState;
-        this.logger = new gd_eventlog_1.EventLogger('DaumPremium');
-        this.devices = [];
-    }
-    add(settings) {
-        if (settings.interface && settings.interface === protocol_1.INTERFACE.TCPIP) {
-            bike_1.Daum8iTcp.setNetImpl(protocol_1.default.getNetImpl());
-            const { host } = settings;
-            const portName = `${host}:51955`;
-            return this.addDevice(bike_1.Daum8iTcp, { host, port: 51955, interface: protocol_1.INTERFACE.TCPIP }, portName);
-        }
-        if (settings.interface && settings.interface === protocol_1.INTERFACE.SERIAL) {
-            bike_1.Daum8iSerial.setSerialPort(protocol_1.default.getSerialPort());
-            const { port } = settings;
-            return this.addDevice(bike_1.Daum8iSerial, { port, interface: protocol_1.INTERFACE.SERIAL }, port);
-        }
-    }
-    getName() {
-        return PROTOCOL_NAME;
-    }
-    getInterfaces() {
-        return [protocol_1.INTERFACE.SERIAL, protocol_1.INTERFACE.TCPIP];
-    }
-    isBike() {
-        return true;
-    }
-    isHrm() {
-        return true;
-    }
-    isPower() {
-        return true;
-    }
-    scan(props) {
-        const opts = props || {};
-        this.logger.logEvent({ message: 'start scan', opts });
-        this.state.scanning = true;
-        if (opts.interface === protocol_1.INTERFACE.TCPIP) {
-            this.scanTcpip(opts);
-        }
-        else if (opts.interface === protocol_1.INTERFACE.SERIAL) {
-            this.scanSerial(opts);
-        }
-    }
-    addDevice(DeviceClass, opts, portName) {
-        let device;
-        if (this.devices.length === 0) {
-            const bike = new DeviceClass(opts);
-            device = new DaumPremiumAdapter_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 DeviceClass(opts);
-                device = new DaumPremiumAdapter_1.default(this, bike);
-                this.devices.push(device);
-            }
-            else {
-                device = this.devices[idx];
-                if (device.isSelected() || device.isDetected())
-                    device = undefined;
-            }
-        }
-        return device;
-    }
-    scanTcpip(opts) {
-        bike_1.Daum8iTcp.setNetImpl(protocol_1.default.getNetImpl());
-        const { host, port } = opts;
-        let device = this.addDevice(bike_1.Daum8iTcp, opts, `${host}:${port || 51955}`);
-        if (device) {
-            const iv = setInterval(() => { this.scanCommand(device, opts); }, 500);
-            this.state.activeScans.push({ iv, device });
-        }
-    }
-    scanSerial(opts) {
-        bike_1.Daum8iSerial.setSerialPort(protocol_1.default.getSerialPort());
-        let device = this.addDevice(bike_1.Daum8iSerial, opts, opts.port);
-        if (device) {
-            const iv = setInterval(() => { this.scanCommand(device, opts); }, 500);
-            this.state.activeScans.push({ iv, device });
-        }
-    }
-    isScanning() {
-        return this.state.scanning;
-    }
-    stopScan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stop scan', activeScans: this.state.activeScans });
-            this.state.stopScanning = true;
-            if (this.state.activeScans.length > 0) {
-                this.state.activeScans.forEach(scan => {
-                    clearInterval(scan.iv);
-                    scan.iv = undefined;
-                    scan.scanning = false;
-                });
-                this.state.activeScans = [];
-            }
-            const devices = this.devices;
-            for (let i = 0; i < devices.length; i++) {
-                const d = devices[i];
-                if (!d.isSelected() && !d.isDetected()) {
-                    try {
-                        yield d.getBike().saveClose(true);
-                    }
-                    catch (err) {
-                        this.logger.logEvent({ message: 'stop scan error', error: err.message });
-                    }
-                }
-            }
-            for (let i = 0; i < devices.length; i++) {
-                const d = devices[i];
-                if (!d.isSelected() && !d.isDetected()) {
-                    try {
-                        yield d.getBike().unblock();
-                    }
-                    catch (err) {
-                    }
-                }
-            }
-            this.state.scanning = false;
-            this.state.stopScanning = false;
-            this.logger.logEvent({ message: 'stop scan completed' });
-            return true;
-        });
-    }
-    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;
-        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 = DaumPremiumProtocol;
-const premium = new DaumPremiumProtocol();
-registry_1.default.register(premium);

package/lib/daum/premium/tcpserial.d.ts

@@ -1,33 +0,0 @@
-import { EventLogger } from 'gd-eventlog';
-export default class TcpSocketPort {
-    callbacks: any;
-    enabled: boolean;
-    host: string;
-    port: number;
-    net: any;
-    props: any;
-    socket: any;
-    id: number;
-    isOpen: boolean;
-    isClosed: boolean;
-    path: string;
-    outputQueue: Array<any>;
-    iv: any;
-    logger: EventLogger;
-    constructor(props: any);
-    flush(): void;
-    open(retry?: boolean): void;
-    close(): void;
-    onTimeout(): void;
-    onConnect(): void;
-    onError(err: any): void;
-    on(event: any, callback: any): void;
-    removeAllListeners(): void;
-    emit(event: any, ...args: any[]): void;
-    write(message: any): void;
-    unpipe(): void;
-    pipe(transformer: any): any;
-    static setResponse(command: any, fn: any): void;
-    static getReponseHandler(command: any): any;
-    static reset(): void;
-}

package/lib/daum/premium/tcpserial.js

@@ -1,123 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const net_1 = __importDefault(require("net"));
-const gd_eventlog_1 = require("gd-eventlog");
-var __responses = {};
-class TcpSocketPort {
-    constructor(props) {
-        this.callbacks = {};
-        this.isOpen = false;
-        this.isClosed = false;
-        this.props = props || {};
-        this.logger = new gd_eventlog_1.EventLogger('TCPSocket') || props.logger;
-        this.enabled = this.props.enabled || true;
-        this.host = this.props.host || '127.0.0.1';
-        this.port = this.props.port || 10000;
-        this.net = this.props.net || net_1.default;
-        this.path = `${this.host}:${this.port}`;
-        if (this.enabled)
-            this.socket = new this.net.Socket();
-        this.outputQueue = [];
-        this.iv = undefined;
-    }
-    flush() {
-    }
-    open(retry = false) {
-        try {
-            if (!retry) {
-                this.id = Date.now();
-                this.socket.on('timeout', () => { this.onTimeout(); });
-                this.socket.on('connect', () => { this.onConnect(); });
-                this.socket.on('error', (err) => { this.onError(err); });
-                this.socket.on('ready', () => {
-                    this.logger.logEvent({ message: 'ready' });
-                });
-            }
-            this.logger.logEvent({ message: 'opening', id: this.id, retry });
-            this.socket.connect(this.port, this.host);
-        }
-        catch (err) {
-            this.logger.logEvent({ message: 'opening error', id: this.id, error: err.message, stack: err.stack });
-            this.emit('error', err);
-        }
-    }
-    close() {
-        this.logger.logEvent({ message: 'closing', id: this.id });
-        this.isOpen = false;
-        this.isClosed = true;
-        try {
-            this.socket.removeAllListeners();
-            this.socket.destroy();
-            this.socket.on('error', () => { });
-        }
-        catch (err) {
-            console.log(err);
-        }
-        this.emit('close');
-        setTimeout(() => { this.removeAllListeners(); }, 100);
-    }
-    onTimeout() {
-        if (this.isOpen)
-            return;
-        this.logger.logEvent({ message: 'timeout', id: this.id });
-        try {
-            this.socket.end();
-        }
-        catch (_a) { }
-        if (this.isClosed)
-            return;
-        this.emit('error', new Error('timeout'));
-    }
-    onConnect() {
-        this.logger.logEvent({ message: 'connected', id: this.id });
-        this.isOpen = true;
-        this.isClosed = false;
-        this.emit('open');
-    }
-    onError(err) {
-        this.logger.logEvent({ message: 'error', error: err.message });
-        if (this.callbacks['error'])
-            this.callbacks['error'](err);
-    }
-    on(event, callback) {
-        if (event === 'open' || event === 'close' || event === 'error') {
-            this.callbacks[event] = callback;
-            return;
-        }
-        this.socket.on(event, callback);
-    }
-    removeAllListeners() {
-        this.callbacks = {};
-    }
-    emit(event, ...args) {
-        if (event === 'open' || event === 'close' || event === 'error') {
-            if (this.callbacks[event])
-                this.callbacks[event](...args);
-        }
-    }
-    write(message) {
-        this.socket.write(new Uint8Array(message));
-    }
-    unpipe() {
-        delete this.callbacks['data'];
-        this.socket.unpipe();
-    }
-    pipe(transformer) {
-        return this.socket.pipe(transformer);
-    }
-    static setResponse(command, fn) {
-        if (!__responses)
-            this.reset();
-        __responses[command] = fn;
-    }
-    static getReponseHandler(command) {
-        return __responses[command];
-    }
-    static reset() {
-        __responses = {};
-    }
-}
-exports.default = TcpSocketPort;

package/lib/kettler/ergo-racer/protocol.d.ts

@@ -1,41 +0,0 @@
-/// <reference types="node" />
-import DeviceProtocolBase, { DeviceProtocol, DeviceSettings, ScanProps } from '../../protocol';
-import KettlerRacerAdapter from './adapter';
-export interface KettlerRacerScanProps extends ScanProps {
-    port: string;
-}
-declare enum ScanState {
-    IDLE = 0,
-    SCANNING = 1,
-    STOPPING = 2,
-    STOPPED = 3
-}
-export interface ScanDescription {
-    device: KettlerRacerAdapter;
-    port: string;
-    iv: NodeJS.Timeout;
-    state: ScanState;
-    props: KettlerRacerScanProps;
-}
-export default class KettlerRacerProtocol extends DeviceProtocolBase implements DeviceProtocol {
-    private state;
-    private logger;
-    private activeScans;
-    constructor();
-    getSerialPort(): any;
-    getInterfaces(): string[];
-    getName(): string;
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-    add(settings: DeviceSettings): any;
-    scan(props: KettlerRacerScanProps): void;
-    checkDevice(port: string): boolean;
-    doScan(port: string): Promise<void>;
-    doStopScan(job: ScanDescription): Promise<void>;
-    isJobStopped(job: ScanDescription): boolean;
-    waitForStop(timeout?: number): Promise<boolean>;
-    stopScan(): Promise<boolean>;
-    isScanning(): boolean;
-}
-export {};