incyclist-devices 1.5.32 → 1.5.34

package/lib/daum/classic/DaumClassicAdapter.js

@@ -118,6 +118,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             try {
                 if (isRelaunch) {
                     yield this.stop();
+                    this.bike.connected = true;
                 }
                 yield this.performStart(props, isRelaunch);
                 if (!isRelaunch) {
@@ -128,9 +129,7 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                     }
                     catch (_a) { }
                 }
-                this.stopped = false;
-                this.paused = false;
-                this.startUpdatePull();
+                this.logger.logEvent({ message: 'start result: success', udid: this.udid });
                 return true;
             }
             catch (err) {

package/lib/daum/premium/bike.js

@@ -143,8 +143,8 @@ class Daum8i {
                         this.logEvent({ message: "creating SerialPort", port: this.port, settings });
                         this.sp = new __SerialPort(this.port, settings);
                     }
-                    this.sp.once('open', this.onPortOpen.bind(this));
-                    this.sp.once('close', this.onPortClose.bind(this));
+                    this.sp.on('open', this.onPortOpen.bind(this));
+                    this.sp.on('close', this.onPortClose.bind(this));
                     this.sp.on('error', (error) => { this.onPortError(error); });
                     this.sp.on('data', (data) => { this.onData(data); });
                 }
@@ -317,10 +317,15 @@ class Daum8i {
                     if (!isClosed)
                         resolve(false);
                 }, timeout);
-                this.sp.removeAllListeners('close');
-                this.sp.removeAllListeners('error');
+                try {
+                    this.sp.removeAllListeners('close');
+                    this.sp.removeAllListeners('error');
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'error', fn: 'closePort()', error: err.message });
+                }
                 this.sp.on('error', () => { });
-                this.sp.once('close', () => {
+                this.sp.on('close', () => {
                     clearTimeout(to);
                     isClosed = true;
                     resolve(true);

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

@@ -0,0 +1,20 @@
+/// <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

@@ -0,0 +1,33 @@
+"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

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

package/lib/serialport/index.js

@@ -0,0 +1,29 @@
+"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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,87 @@
+"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;

package/lib/serialport.d.ts

@@ -0,0 +1,29 @@
+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.js

@@ -0,0 +1,87 @@
+"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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.5.32",
+  "version": "1.5.34",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",