incyclist-devices 2.1.32 → 2.1.35

package/lib/serial/serial-interface.js

@@ -1,288 +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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const events_1 = __importDefault(require("events"));
-const serialport_1 = __importDefault(require("./serialport"));
-const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("../utils/utils");
-const adapter_factory_1 = __importDefault(require("./factories/adapter-factory"));
-const serial_scanner_1 = require("./serial-scanner");
-const DEFAULT_SCAN_TIMEOUT = 10000;
-class SerialInterface extends events_1.default {
-    static getInstance(props) {
-        const { ifaceName, binding, logger } = props;
-        let instance = SerialInterface._instances.find(i => i.ifaceName === ifaceName);
-        if (!instance) {
-            if (binding)
-                instance = new SerialInterface(props);
-            else {
-                instance = new SerialInterface({ ifaceName, binding: serialport_1.default.getInstance().getBinding(ifaceName), logger });
-                if (instance)
-                    SerialInterface._instances.push(instance);
-            }
-        }
-        return instance;
-    }
-    static _add(instance) {
-        let existingIdx = SerialInterface._instances.findIndex(i => i.ifaceName === instance.ifaceName);
-        if (existingIdx !== -1)
-            SerialInterface._instances[existingIdx] = instance;
-        else
-            SerialInterface._instances.push(instance);
-    }
-    constructor(props) {
-        super();
-        const { ifaceName, binding } = props;
-        this.ifaceName = ifaceName;
-        this.binding = undefined;
-        this.ports = [];
-        this.inUse = [];
-        this.isScanning = false;
-        this.isStopScanRequested = false;
-        this.scanEvents = new events_1.default();
-        this.scanEvents.setMaxListeners(100);
-        this.logger = props.logger || new gd_eventlog_1.EventLogger(`Serial:${ifaceName}`);
-        this.connected = false;
-        this.logEvent({ message: 'new serial interface', ifaceName });
-        if (binding) {
-            this.setBinding(binding);
-        }
-        SerialInterface._add(this);
-    }
-    logEvent(event) {
-        if (this.logger) {
-            this.logger.logEvent(event);
-        }
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
-            console.log('~~~ Serial', event);
-        }
-    }
-    setBinding(binding) {
-        this.binding = binding;
-        serialport_1.default.getInstance().setBinding(this.ifaceName, binding);
-    }
-    getName() {
-        return this.ifaceName;
-    }
-    isConnected() {
-        return this.connected;
-    }
-    setInUse(path) {
-        this.logEvent({ message: 'block port for further scans', port: path });
-        if (!this.inUse.includes(path))
-            this.inUse.push(path);
-    }
-    releaseInUse(path) {
-        if (this.inUse.includes(path)) {
-            this.logEvent({ message: 're-enable port for further scans', port: path });
-            const idx = this.inUse.findIndex(r => r === path);
-            this.inUse.splice(idx, 1);
-        }
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'connecting', interface: this.ifaceName });
-            const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
-            if (!binding || !this.binding) {
-                this.connected = false;
-                this.logEvent({ message: 'connecting error', interface: this.ifaceName, reason: 'no binfing found' });
-                return false;
-            }
-            try {
-                const SerialPort = this.binding;
-                yield SerialPort.list();
-                this.connected = true;
-                return true;
-            }
-            catch (err) {
-                this.logEvent({ message: 'connecting error', interface: this.ifaceName, reason: err.message });
-                this.connected = false;
-                return false;
-            }
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.connected = false;
-            return true;
-        });
-    }
-    openPort(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'opening port', port: path });
-            const existing = this.ports.findIndex(p => p.path === path);
-            if (existing !== -1) {
-                const port = this.ports[existing].port;
-                if (port.isOpen) {
-                    this.logEvent({ message: 'opening port - port already exists', port: path });
-                    return port;
-                }
-                else {
-                    this.ports.splice(existing, 1);
-                }
-            }
-            const port = serialport_1.default.getInstance().getSerialPort(this.ifaceName, { path });
-            if (!port) {
-                this.logEvent({ message: 'opening port - port does not exist', port: path });
-                return null;
-            }
-            return new Promise((resolve) => {
-                port.once('error', (err) => {
-                    this.logEvent({ message: 'error', path, error: err.message || err, stack: err.stack });
-                    port.removeAllListeners();
-                    resolve(null);
-                });
-                port.once('open', () => {
-                    this.logEvent({ message: 'port opened', path });
-                    port.removeAllListeners();
-                    this.ports.push({ path, port });
-                    resolve(port);
-                });
-                port.open();
-            });
-        });
-    }
-    closePort(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'closing port', port: path });
-            const existing = this.ports.findIndex(p => p.path === path);
-            if (existing === -1)
-                return true;
-            const port = this.ports[existing].port;
-            if (!port.isOpen)
-                return true;
-            port.on('error', () => { });
-            try {
-                port.flush();
-                yield port.drain();
-            }
-            catch (_a) { }
-            return new Promise(resolve => {
-                port.close(err => {
-                    if (!err) {
-                        this.ports.splice(existing, 1);
-                        port.removeAllListeners();
-                        resolve(true);
-                    }
-                    resolve(false);
-                });
-            });
-        });
-    }
-    scan(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isScanning)
-                return [];
-            if (!this.isConnected())
-                yield this.connect();
-            const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
-            if (!binding || !this.binding)
-                return [];
-            const { port, timeout = DEFAULT_SCAN_TIMEOUT } = props;
-            let paths;
-            const detected = [];
-            let timeOutExpired = false;
-            let toExpiresAt = Date.now() + timeout;
-            if (timeout) {
-                this.toScan = setTimeout(() => {
-                    timeOutExpired = true;
-                    this.scanEvents.emit('timeout');
-                }, timeout);
-            }
-            this.isScanning = true;
-            let attemptNo = 0;
-            const isTcpip = this.getName() === 'tcpip';
-            do {
-                if (attemptNo === 0)
-                    this.logEvent({ message: 'checking for ports', interface: this.ifaceName, port, excludes: this.inUse });
-                else
-                    this.logEvent({ message: 'checking for ports retry', interface: this.ifaceName, retry: attemptNo });
-                attemptNo++;
-                try {
-                    if (isTcpip) {
-                        const _binding = binding;
-                        paths = (yield _binding.list(port, this.inUse)) || [];
-                    }
-                    else {
-                        paths = (yield binding.list()) || [];
-                    }
-                }
-                catch (err) {
-                    this.logEvent({ message: 'error', fn: 'scan#detect ports', error: err.message, interface: this.ifaceName, port, excludes: this.inUse });
-                }
-                paths = paths.filter(p => !this.inUse.includes(p.path));
-                if (!paths || paths.length === 0) {
-                    this.logEvent({ message: 'scanning: no ports detected', interface: this.ifaceName, paths: paths.map(p => p.path), timeout });
-                    yield (0, utils_1.sleep)(1000);
-                }
-                if (Date.now() > toExpiresAt)
-                    timeOutExpired = true;
-            } while (this.isScanning && !timeOutExpired && paths.length === 0);
-            if (paths.length === 0) {
-                this.logEvent({ message: 'nothing to scan ' });
-                if (this.toScan) {
-                    clearTimeout(this.toScan);
-                    this.toScan = null;
-                }
-                return [];
-            }
-            this.logEvent({ message: 'scanning on ', interface: this.ifaceName, paths: paths.map(p => p.path).join(','), timeout });
-            const scanners = paths.map(p => new serial_scanner_1.SinglePathScanner(p.path, this, Object.assign(Object.assign({}, props), { logger: this.logger })));
-            try {
-                yield Promise.all(scanners.map(s => s.scan()
-                    .then((device) => __awaiter(this, void 0, void 0, function* () {
-                    if (device) {
-                        const adapter = adapter_factory_1.default.getInstance().createInstance(device);
-                        const path = adapter.getPort();
-                        this.inUse.push(path);
-                        yield adapter.pause();
-                        detected.push(device);
-                        this.emit('device', device);
-                    }
-                }))
-                    .catch()));
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
-            }
-            if (this.toScan) {
-                clearTimeout(this.toScan);
-                this.toScan = null;
-            }
-            this.isScanning = false;
-            this.logEvent({ message: 'scan finished on', interface: this.ifaceName, paths: paths.map(p => p.path), devices: detected.map(d => {
-                    const res = Object.assign({}, d);
-                    res.interface = this.ifaceName;
-                    return res;
-                }) });
-            return detected;
-        });
-    }
-    stopScan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isScanning)
-                return true;
-            if (this.toScan) {
-                clearTimeout(this.toScan);
-                this.toScan = null;
-            }
-            this.isScanning = false;
-            this.scanEvents.emit('stop');
-            return true;
-        });
-    }
-}
-SerialInterface._instances = [];
-exports.default = SerialInterface;

package/lib/serial/serial-scanner.d.ts

@@ -1,16 +0,0 @@
-import { EventLogger } from "gd-eventlog";
-import SerialInterface from "./serial-interface";
-import { SerialDeviceSettings, SerialScannerProps } from "./types";
-export declare class SinglePathScanner {
-    path: string;
-    serial: SerialInterface;
-    result: SerialDeviceSettings;
-    isScanning: boolean;
-    props: SerialScannerProps;
-    logger: EventLogger;
-    isFound: boolean;
-    constructor(path: string, serial: SerialInterface, props: SerialScannerProps);
-    logEvent(event: any): void;
-    onStopRequest(resolve: any): Promise<void>;
-    scan(): Promise<SerialDeviceSettings | undefined>;
-}

package/lib/serial/serial-scanner.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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SinglePathScanner = void 0;
-const gd_eventlog_1 = require("gd-eventlog");
-const types_1 = require("./types");
-const adapter_factory_1 = __importDefault(require("./factories/adapter-factory"));
-const utils_1 = require("../utils/utils");
-class SinglePathScanner {
-    constructor(path, serial, props) {
-        this.path = path;
-        this.serial = serial;
-        this.result = undefined;
-        this.isScanning = false;
-        this.isFound = false;
-        this.props = props;
-        this.logger = props.logger || new gd_eventlog_1.EventLogger('SerialScanner');
-    }
-    logEvent(event) {
-        if (this.logger) {
-            this.logger.logEvent(event);
-        }
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
-            console.log('~~~ SerialScanner', event);
-        }
-    }
-    onStopRequest(resolve) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'stopping scan', path: this.path });
-            if (!this.isFound)
-                yield this.serial.closePort(this.path);
-            this.isScanning = false;
-            resolve(this.result);
-        });
-    }
-    scan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isScanning)
-                return;
-            this.isScanning = true;
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.logEvent({ message: 'starting scan', path: this.path, interface: this.serial.getName() });
-                this.serial.scanEvents.on('timeout', () => this.onStopRequest(resolve));
-                this.serial.scanEvents.on('stop', () => this.onStopRequest(resolve));
-                let found = false;
-                while (!found && this.isScanning) {
-                    try {
-                        const { protocol } = this.props;
-                        let host, port;
-                        if (this.serial.getName() === types_1.SerialInterfaceType.TCPIP) {
-                            [host, port] = this.path.split(':');
-                        }
-                        else {
-                            port = this.path;
-                        }
-                        const adapterSettings = { interface: this.serial.getName(), host, port, protocol };
-                        const adapter = adapter_factory_1.default.getInstance().createInstance(adapterSettings);
-                        found = yield adapter.check();
-                        if (found) {
-                            this.isFound = true;
-                            const name = adapter.getName();
-                            resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
-                        }
-                        yield (0, utils_1.sleep)(100);
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
-                        yield (0, utils_1.sleep)(100);
-                    }
-                }
-            }));
-        });
-    }
-}
-exports.SinglePathScanner = SinglePathScanner;

package/lib/serial/serialport.d.ts

@@ -1,17 +0,0 @@
-import { BindingInterface } from '@serialport/bindings-interface';
-import { InterfaceBinding, InterfaceImplementation } from './types';
-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/serial/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;

package/lib/types/Command.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="node" />
-export interface Command {
-    logStr?: string;
-    message: string | Buffer;
-    timeout?: number;
-    onError: (err: Error) => void;
-    onResponse: (response: string | Buffer) => void;
-}

package/lib/types/Command.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/types.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="node" />
-export interface Command {
-    logStr?: string;
-    message: string | Buffer;
-    timeout?: number;
-    onError: (err: Error) => void;
-    onResponse: (response: string | Buffer) => void;
-}

package/lib/types/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });