incyclist-devices 1.5.38 → 2.0.0-beta.1

package/lib/kettler/ergo-racer/protocol.js

@@ -1,203 +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 gd_eventlog_1 = require("gd-eventlog");
-const registry_1 = __importDefault(require("../../registry"));
-const adapter_1 = __importDefault(require("./adapter"));
-const PROTOCOL_NAME = 'Kettler Racer';
-var ScanState;
-(function (ScanState) {
-    ScanState[ScanState["IDLE"] = 0] = "IDLE";
-    ScanState[ScanState["SCANNING"] = 1] = "SCANNING";
-    ScanState[ScanState["STOPPING"] = 2] = "STOPPING";
-    ScanState[ScanState["STOPPED"] = 3] = "STOPPED";
-})(ScanState || (ScanState = {}));
-class KettlerRacerProtocol extends protocol_1.default {
-    constructor() {
-        super();
-        this.state = ScanState.IDLE;
-        this.logger = new gd_eventlog_1.EventLogger('KettlerRacer');
-        this.activeScans = [];
-        this.devices = [];
-    }
-    getSerialPort() {
-        return protocol_1.default.getSerialPort();
-    }
-    getInterfaces() {
-        return [protocol_1.INTERFACE.SERIAL];
-    }
-    getName() {
-        return PROTOCOL_NAME;
-    }
-    isBike() {
-        return true;
-    }
-    isHrm() {
-        return true;
-    }
-    isPower() {
-        return true;
-    }
-    add(settings) {
-        this.logger.logEvent({ message: 'adding device', settings });
-        if (this.devices.length > 0) {
-            const found = this.devices.find(d => d.getPort() === settings.port);
-            if (found)
-                return found;
-        }
-        let device = new adapter_1.default(this, settings);
-        this.devices.push(device);
-        return device;
-    }
-    scan(props) {
-        this.logger.logEvent({ message: 'start scan', id: props.id, port: props.port });
-        this.state = ScanState.SCANNING;
-        const isAlreadyKnownOrScanning = this.checkDevice(props.port);
-        if (!isAlreadyKnownOrScanning) {
-            const port = props.port;
-            const name = PROTOCOL_NAME;
-            const device = new adapter_1.default(this, { name, port });
-            const iv = setInterval(() => { this.doScan(port); }, 1000);
-            this.activeScans.push({ iv, device, port, state: ScanState.IDLE, props });
-        }
-    }
-    checkDevice(port) {
-        if (this.devices.length > 0 && this.devices.findIndex(d => d.getPort() === port) >= 0)
-            return true;
-        if (this.activeScans.length > 0 && this.activeScans.findIndex(d => d.port === port) >= 0)
-            return true;
-        return false;
-    }
-    doScan(port) {
-        const job = this.activeScans.find(d => d.port === port);
-        if (!job)
-            return;
-        if (this.state === ScanState.STOPPING || job.state === ScanState.STOPPING)
-            return;
-        const device = job.device;
-        if (device && (device.isDetected() || device.isSelected()))
-            return;
-        this.state = ScanState.SCANNING;
-        job.state = ScanState.SCANNING;
-        return device.check()
-            .then((found) => __awaiter(this, void 0, void 0, function* () {
-            if (found) {
-                if (this.state === ScanState.STOPPING || this.state === ScanState.STOPPED)
-                    return;
-                const { onDeviceFound, onScanFinished, id } = job.props;
-                device.setDetected();
-                if (onDeviceFound)
-                    onDeviceFound(device, device.getProtocol());
-                if (onScanFinished) {
-                    onScanFinished(id);
-                }
-            }
-            job.state = ScanState.STOPPED;
-            try {
-                yield device.waitForClosed();
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'scanCommand warning: Could not close port', error: err.message });
-            }
-            clearInterval(job.iv);
-            job.iv = null;
-            job.state = ScanState.STOPPED;
-            const idxActiveScan = this.activeScans.findIndex(d => d.state !== ScanState.STOPPED);
-            if (idxActiveScan === -1) {
-                this.state = ScanState.STOPPED;
-            }
-        }))
-            .catch(() => {
-            job.state = ScanState.STOPPED;
-        });
-    }
-    doStopScan(job) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!job)
-                return;
-            if (job.state === ScanState.STOPPING || job.state === ScanState.STOPPED)
-                return;
-            job.state = ScanState.STOPPING;
-            clearInterval(job.iv);
-            job.iv = null;
-        });
-    }
-    isJobStopped(job) {
-        return job.state === ScanState.STOPPED && !job.iv;
-    }
-    waitForStop(timeout) {
-        return new Promise((resolve) => {
-            let timedOut = false;
-            if (timeout)
-                setTimeout(() => { timedOut = true; }, timeout);
-            const iv = setInterval(() => {
-                const idxActiveScan = this.activeScans.findIndex(d => this.isJobStopped(d) === false);
-                if (idxActiveScan === -1) {
-                    clearInterval(iv);
-                    resolve(true);
-                    return;
-                }
-                if (timedOut) {
-                    clearInterval(iv);
-                    resolve(false);
-                    return;
-                }
-            }, 500);
-        });
-    }
-    stopScan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.state === ScanState.STOPPING || this.state === ScanState.STOPPED)
-                return;
-            this.state = ScanState.STOPPING;
-            this.logger.logEvent({ message: 'stop scan', activeScans: this.activeScans.map(j => j.port) });
-            this.activeScans.forEach(job => this.doStopScan(job));
-            const stopped = yield this.waitForStop();
-            if (!stopped) {
-                this.logger.logEvent({ message: 'scanCommand warning: stop scan timeout' });
-            }
-            else {
-                this.logger.logEvent({ message: 'stop scan completed' });
-            }
-            this.activeScans = [];
-            this.state = ScanState.IDLE;
-            return true;
-        });
-    }
-    isScanning() {
-        return this.state === ScanState.SCANNING;
-    }
-}
-exports.default = KettlerRacerProtocol;
-registry_1.default.register(new KettlerRacerProtocol());

package/lib/protocol.d.ts

@@ -1,74 +0,0 @@
-import { User } from "./types/user";
-export declare const INTERFACE: {
-    SERIAL: string;
-    ANT: string;
-    BLE: string;
-    BLUETOOTH: string;
-    TCPIP: string;
-    SIMULATOR: string;
-};
-export declare type Device = {
-    getID(): string;
-    getName(): string;
-    getPort(): string;
-    getProtocol(): DeviceProtocol;
-    getProtocolName(): string;
-};
-export interface DeviceSettings {
-    name: string;
-    port?: string;
-    userSettings?: User;
-    bikeSettings?: any;
-}
-export declare type DeviceFoundCallback = (device: Device, protocol: DeviceProtocol) => void;
-export declare type ScanFinishedCallback = (id: number) => void;
-export declare type ScanProps = {
-    id: number;
-    onDeviceFound?: DeviceFoundCallback;
-    onScanFinished?: ScanFinishedCallback;
-};
-export interface DeviceProtocol {
-    add(props: DeviceSettings): any;
-    getName(): string;
-    getInterfaces(): Array<string>;
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-    scan(props: ScanProps): void;
-    stopScan(): void;
-    isScanning(): boolean;
-    getDevices(): Array<any>;
-    setAnt(antClass: any): void;
-    getAnt(): any;
-    setSerialPort(serialClass: any): void;
-    getSerialPort(): any;
-    setNetImpl(netClass: any): void;
-    getNetImpl(): any;
-}
-export default class DeviceProtocolBase {
-    devices: Array<Device>;
-    constructor();
-    getName(): string;
-    getInterfaces(): Array<string>;
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-    scan(props: ScanProps): void;
-    stopScan(): void;
-    isScanning(): boolean;
-    add(props: DeviceSettings): void;
-    getDevices(): Array<Device>;
-    setAnt(antClass: any): void;
-    getAnt(): any;
-    setSerialPort(serialClass: any): void;
-    getSerialPort(): void;
-    setNetImpl(netClass: any): void;
-    getNetImpl(): any;
-    setBinding(_bindingClass: any): void;
-    static setAnt(antClass: any): void;
-    static getAnt(): any;
-    static setSerialPort(serialClass: any): void;
-    static getSerialPort(): any;
-    static setNetImpl(netClass: any): void;
-    static getNetImpl(): any;
-}

package/lib/protocol.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.INTERFACE = void 0;
-exports.INTERFACE = {
-    SERIAL: 'serial',
-    ANT: 'ant',
-    BLE: 'ble',
-    BLUETOOTH: 'bluetooth',
-    TCPIP: 'tcpip',
-    SIMULATOR: 'simulator'
-};
-let _ant, _serial, _net;
-class DeviceProtocolBase {
-    constructor() {
-        this.devices = [];
-    }
-    getName() { throw new Error('not implemented'); }
-    getInterfaces() { throw new Error('not implemented'); }
-    isBike() { throw new Error('not implemented'); }
-    isHrm() { throw new Error('not implemented'); }
-    isPower() { throw new Error('not implemented'); }
-    scan(props) { throw new Error('not implemented'); }
-    stopScan() { throw new Error('not implemented'); }
-    isScanning() { throw new Error('not implemented'); }
-    add(props) { throw new Error('Method not implemented.'); }
-    getDevices() { return this.devices; }
-    setAnt(antClass) { DeviceProtocolBase.setAnt(antClass); }
-    getAnt() { return DeviceProtocolBase.getAnt(); }
-    setSerialPort(serialClass) { DeviceProtocolBase.setSerialPort(serialClass); }
-    getSerialPort() { DeviceProtocolBase.getSerialPort(); }
-    setNetImpl(netClass) { DeviceProtocolBase.setNetImpl(netClass); }
-    getNetImpl() { return DeviceProtocolBase.getNetImpl(); }
-    setBinding(_bindingClass) { }
-    static setAnt(antClass) { _ant = antClass; }
-    static getAnt() { return _ant; }
-    static setSerialPort(serialClass) { _serial = serialClass; }
-    static getSerialPort() { return _serial; }
-    static setNetImpl(netClass) { _net = netClass; }
-    static getNetImpl() { return _net; }
-}
-exports.default = DeviceProtocolBase;

package/lib/registry.d.ts

@@ -1,8 +0,0 @@
-import { DeviceProtocol } from './protocol';
-export default class DeviceRegistry {
-    static _reset(): void;
-    static _get(): any[];
-    static register(protocol: DeviceProtocol): void;
-    static findByName(name: string): DeviceProtocol;
-    static findByInterface(interf: string): Array<DeviceProtocol>;
-}

package/lib/registry.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-let _protocols = [];
-class DeviceRegistry {
-    static _reset() {
-        _protocols = [];
-    }
-    static _get() {
-        return _protocols;
-    }
-    static register(protocol) {
-        if (!protocol)
-            return;
-        const idx = _protocols.findIndex(d => d.getName() === protocol.getName());
-        if (idx !== -1) {
-            _protocols[idx] = protocol;
-        }
-        else {
-            _protocols.push(protocol);
-        }
-    }
-    static findByName(name) {
-        if (!name)
-            return;
-        return _protocols.find(d => d.getName() === name);
-    }
-    static findByInterface(interf) {
-        if (!interf)
-            return;
-        return _protocols.filter(d => d.getInterfaces().findIndex(i => i === interf) !== -1);
-    }
-}
-exports.default = DeviceRegistry;

package/lib/serialport/bindings/tcp.d.ts

@@ -1,20 +0,0 @@
-/// <reference types="node" />
-import { BindingPortInterface, OpenOptions, PortStatus, SetOptions, UpdateOptions } from "@serialport/bindings-interface";
-export declare class TCPPortBinding implements BindingPortInterface {
-    openOptions: Required<OpenOptions>;
-    isOpen: boolean;
-    close(): Promise<void>;
-    read(buffer: Buffer, offset: number, length: number): Promise<{
-        buffer: Buffer;
-        bytesRead: number;
-    }>;
-    write(buffer: Buffer): Promise<void>;
-    update(options: UpdateOptions): Promise<void>;
-    set(options: SetOptions): Promise<void>;
-    get(): Promise<PortStatus>;
-    getBaudRate(): Promise<{
-        baudRate: number;
-    }>;
-    flush(): Promise<void>;
-    drain(): Promise<void>;
-}

package/lib/serialport/bindings/tcp.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TCPPortBinding = void 0;
-class TCPPortBinding {
-    close() {
-        throw new Error("Method not implemented.");
-    }
-    read(buffer, offset, length) {
-        throw new Error("Method not implemented.");
-    }
-    write(buffer) {
-        throw new Error("Method not implemented.");
-    }
-    update(options) {
-        throw new Error("Method not implemented.");
-    }
-    set(options) {
-        throw new Error("Method not implemented.");
-    }
-    get() {
-        throw new Error("Method not implemented.");
-    }
-    getBaudRate() {
-        throw new Error("Method not implemented.");
-    }
-    flush() {
-        throw new Error("Method not implemented.");
-    }
-    drain() {
-        throw new Error("Method not implemented.");
-    }
-}
-exports.TCPPortBinding = TCPPortBinding;

package/lib/serialport/index.d.ts

@@ -1,2 +0,0 @@
-import SerialPortProvider, { useSerialPortProvider } from './serialport';
-export { SerialPortProvider, useSerialPortProvider };

package/lib/serialport/index.js

@@ -1,29 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useSerialPortProvider = exports.SerialPortProvider = void 0;
-const serialport_1 = __importStar(require("./serialport"));
-exports.SerialPortProvider = serialport_1.default;
-Object.defineProperty(exports, "useSerialPortProvider", { enumerable: true, get: function () { return serialport_1.useSerialPortProvider; } });

package/lib/serialport/serialport.d.ts

@@ -1,29 +0,0 @@
-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;
-};
-export default class SerialPortProvider {
-    static _instance: SerialPortProvider;
-    interfaces: InterfaceBinding[];
-    implemenations: InterfaceImplementation[];
-    static getInstance(): SerialPortProvider;
-    constructor();
-    setBinding(ifaceName: string, binding: BindingInterface): void;
-    getBinding(ifaceName: string): BindingInterface;
-    getSerialPort(ifaceName: string, props: any): any;
-    list(ifaceName: string): Promise<any>;
-    setLegacyClass(ifaceName: string, Serialport: any): void;
-    getLegacyInfo(ifaceName: string): InterfaceImplementation;
-    getLegacyClass(ifaceName: string): any;
-}
-export declare const useSerialPortProvider: () => SerialPortProvider;

package/lib/serialport/serialport.js

@@ -1,87 +0,0 @@
-"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.useSerialPortProvider = void 0;
-const { SerialPortStream } = require('@serialport/stream');
-const DEFAULT_BAUD_RATE = 9600;
-class SerialPortProvider {
-    static getInstance() {
-        if (!SerialPortProvider._instance)
-            SerialPortProvider._instance = new SerialPortProvider();
-        return SerialPortProvider._instance;
-    }
-    constructor() {
-        this.interfaces = [];
-        this.implemenations = [];
-    }
-    setBinding(ifaceName, binding) {
-        const existing = this.interfaces.find(ib => ib.name === ifaceName);
-        if (existing)
-            existing.binding = binding;
-        else
-            this.interfaces.push({ name: ifaceName, binding });
-    }
-    getBinding(ifaceName) {
-        const existing = this.interfaces.find(ib => ib.name === ifaceName);
-        if (existing)
-            return existing.binding;
-    }
-    getSerialPort(ifaceName, props) {
-        const binding = this.getBinding(ifaceName);
-        if (binding) {
-            props.binding = binding;
-            if (props.autoOpen === undefined)
-                props.autoOpen = false;
-            if (!props.baudRate)
-                props.baudRate = DEFAULT_BAUD_RATE;
-            return new SerialPortStream(props);
-        }
-        const legacy = this.getLegacyInfo(ifaceName);
-        if (legacy && legacy.Serialport) {
-            const portName = props.path;
-            if (props.autoOpen === undefined)
-                props.autoOpen = false;
-            const settings = Object.assign({}, props);
-            delete settings.path;
-            return new legacy.Serialport(portName, settings);
-        }
-    }
-    list(ifaceName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const Binding = this.getBinding(ifaceName);
-            if (Binding)
-                return yield Binding.list();
-            const legacy = this.getLegacyInfo(ifaceName);
-            if (legacy && legacy.Serialport && legacy.Serialport.list) {
-                return yield legacy.Serialport.list();
-            }
-            return [];
-        });
-    }
-    setLegacyClass(ifaceName, Serialport) {
-        const existing = this.getLegacyInfo(ifaceName);
-        if (existing)
-            existing.Serialport = Serialport;
-        else
-            this.implemenations.push({ name: ifaceName, Serialport });
-    }
-    getLegacyInfo(ifaceName) {
-        return this.implemenations.find(ib => ib.name === ifaceName);
-    }
-    getLegacyClass(ifaceName) {
-        const existing = this.implemenations.find(ib => ib.name === ifaceName);
-        if (existing)
-            return existing.Serialport;
-    }
-}
-exports.default = SerialPortProvider;
-const useSerialPortProvider = () => SerialPortProvider.getInstance();
-exports.useSerialPortProvider = useSerialPortProvider;