incyclist-devices 1.5.38 → 2.0.0

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/device.d.ts

@@ -1,94 +0,0 @@
-/// <reference types="node" />
-import { DeviceProtocol, Device } from './protocol';
-import CyclingMode from './cycling-mode';
-import EventEmitter from 'events';
-export declare const DEFAULT_BIKE_WEIGHT = 10;
-export declare const DEFAULT_USER_WEIGHT = 75;
-export declare type DeviceData = {
-    speed?: number;
-    slope?: number;
-    power?: number;
-    cadence?: number;
-    heartrate?: number;
-    distance?: number;
-    timestamp?: number;
-    deviceTime?: number;
-    deviceDistanceCounter?: number;
-    internalDistanceCounter?: number;
-};
-export declare type OnDeviceDataCallback = (data: DeviceData) => void;
-export declare type OnDeviceStartCallback = (completed: number, total: number) => void;
-export interface Bike {
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    getSupportedCyclingModes(): Array<any>;
-    getCyclingMode(): CyclingMode;
-    getDefaultCyclingMode(): CyclingMode;
-    setUserSettings(userSettings: any): void;
-    setBikeSettings(bikeSettings: any): void;
-}
-export interface DeviceAdapter extends Device {
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
-    isSame(device: DeviceAdapter): boolean;
-    getID(): string;
-    getDisplayName(): string;
-    getName(): string;
-    getPort(): string;
-    getProtocol(): DeviceProtocol;
-    getProtocolName(): string;
-    setIgnoreHrm(ignore: boolean): void;
-    setIgnorePower(ignore: boolean): void;
-    setIgnoreBike(ignore: boolean): void;
-    select(): void;
-    unselect(): void;
-    isSelected(): boolean;
-    setDetected(detected?: boolean): void;
-    isDetected(): boolean;
-    start(props?: any): Promise<any>;
-    stop(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-    sendUpdate(request: any): void;
-    onData(callback: OnDeviceDataCallback): void;
-}
-export default class IncyclistDevice extends EventEmitter implements DeviceAdapter {
-    protocol: DeviceProtocol;
-    detected: boolean;
-    selected: boolean;
-    onDataFn: OnDeviceDataCallback;
-    settings: any;
-    constructor(proto: DeviceProtocol, settings?: any);
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
-    isSame(device: DeviceAdapter): boolean;
-    getID(): string;
-    getDisplayName(): string;
-    getName(): string;
-    getPort(): string;
-    getProtocol(): DeviceProtocol;
-    getProtocolName(): string;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    getCyclingMode(): CyclingMode;
-    setIgnoreHrm(ignore: any): void;
-    setIgnorePower(ignore: any): void;
-    setIgnoreBike(ignore: any): void;
-    select(): void;
-    unselect(): void;
-    isSelected(): boolean;
-    setDetected(detected?: boolean): void;
-    isDetected(): boolean;
-    update(): void;
-    check(): void;
-    connect(): void;
-    close(): void;
-    start(props?: any): Promise<any>;
-    stop(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-    sendUpdate(request: any): void;
-    onData(callback: OnDeviceDataCallback): void;
-}

package/lib/device.js

@@ -1,76 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
-const events_1 = __importDefault(require("events"));
-exports.DEFAULT_BIKE_WEIGHT = 10;
-exports.DEFAULT_USER_WEIGHT = 75;
-class IncyclistDevice extends events_1.default {
-    constructor(proto, settings) {
-        super();
-        this.protocol = proto;
-        this.detected = false;
-        this.selected = false;
-        this.onDataFn = undefined;
-        this.settings = settings || {};
-    }
-    isBike() { throw new Error('not implemented'); }
-    isPower() { throw new Error('not implemented'); }
-    isHrm() { throw new Error('not implemented'); }
-    isSame(device) { throw new Error('not implemented'); }
-    getID() { throw new Error('not implemented'); }
-    getDisplayName() { return this.getName(); }
-    getName() { throw new Error('not implemented'); }
-    getPort() { throw new Error('not implemented'); }
-    getProtocol() { return this.protocol; }
-    getProtocolName() {
-        return this.protocol ? this.protocol.getName() : undefined;
-    }
-    getSupportedCyclingModes() { throw new Error('not implemented'); }
-    getDefaultCyclingMode() { throw new Error('not implemented'); }
-    setCyclingMode(mode, settings) {
-        let selectedMode;
-        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.settings.cyclingMode = new CyclingModeClass(this, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.settings.cyclingMode = selectedMode;
-        this.settings.cyclingMode.setSettings(settings);
-    }
-    getCyclingMode() {
-        if (!this.settings.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.settings.cyclingMode;
-    }
-    setIgnoreHrm(ignore) { }
-    setIgnorePower(ignore) { }
-    setIgnoreBike(ignore) { }
-    select() { this.selected = true; }
-    unselect() { this.selected = false; }
-    isSelected() { return this.selected; }
-    setDetected(detected = true) { this.detected = detected; }
-    isDetected() { return this.detected; }
-    update() { }
-    check() { }
-    connect() { }
-    close() { }
-    start(props) { throw new Error('not implemented'); }
-    stop() { throw new Error('not implemented'); }
-    pause() { throw new Error('not implemented'); }
-    resume() { throw new Error('not implemented'); }
-    sendUpdate(request) { }
-    onData(callback) {
-        this.onDataFn = callback;
-    }
-}
-exports.default = IncyclistDevice;

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 {};