incyclist-devices 2.0.38 → 2.1.1

package/lib/serial/daum/premium/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseTimeout = exports.BusyTimeout = exports.ACKTimeout = exports.CheckSumError = void 0;
+exports.ACTUAL_BIKE_TYPE = exports.BusyTimeout = exports.ACKTimeout = exports.CheckSumError = void 0;
 class CheckSumError extends Error {
     constructor() {
         super();
@@ -22,10 +22,10 @@ class BusyTimeout extends Error {
     }
 }
 exports.BusyTimeout = BusyTimeout;
-class ResponseTimeout extends Error {
-    constructor() {
-        super();
-        this.message = 'RESP timeout';
-    }
-}
-exports.ResponseTimeout = ResponseTimeout;
+var ACTUAL_BIKE_TYPE;
+(function (ACTUAL_BIKE_TYPE) {
+    ACTUAL_BIKE_TYPE["ALLROUND"] = "allround";
+    ACTUAL_BIKE_TYPE["RACE"] = "race";
+    ACTUAL_BIKE_TYPE["MOUNTAIN"] = "mountain";
+    ACTUAL_BIKE_TYPE["TRIATHLON"] = "triathlon";
+})(ACTUAL_BIKE_TYPE || (exports.ACTUAL_BIKE_TYPE = ACTUAL_BIKE_TYPE = {}));

package/lib/serial/daum/premium/utils.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
-import { IncyclistBikeData } from "../../..";
-import { Route } from "../../../types/route";
-import { User } from "../../../types/user";
+import { User, IncyclistBikeData } from "../../../types";
+import { Route } from "./types";
 export declare const DEBUG_LOGGER: {
     log: (e: any, ...args: any[]) => void;
     logEvent: (event: any) => void;

package/lib/serial/daum/premium/utils.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePersonData = exports.getPersonData = exports.parseTrainingData = exports.routeToEpp = exports.FileTimeSupport = exports.getBikeType = exports.BikeType = exports.ReservedCommands = exports.getAsciiArrayFromStr = exports.ascii = exports.hexstr = exports.getMessageData = exports.buildMessage = exports.checkSum = exports.esc2bin = exports.bin2esc = exports.validatePath = exports.validateHost = exports.responseLog = exports.DEBUG_LOGGER = void 0;
-const user_1 = require("../../../types/user");
+const types_1 = require("../../../types");
 const win32filetime_1 = __importDefault(require("win32filetime"));
 const sum = (arr) => arr.reduce((a, b) => a + b, 0);
 exports.DEBUG_LOGGER = {
@@ -323,7 +323,7 @@ function getPersonData(user) {
         buffer.writeUInt8(0, offset);
         offset += 1;
     }
-    buffer.writeInt32LE(user && user.sex === user_1.Gender.FEMALE ? 2 : 1, offset);
+    buffer.writeInt32LE(user && user.sex === types_1.Gender.FEMALE ? 2 : 1, offset);
     offset += 4;
     buffer.writeInt32LE(user && user.age !== undefined ? user.age : 1, offset);
     offset += 4;
@@ -344,7 +344,7 @@ function parsePersonData(buffer) {
     const length = buffer.readInt32LE(120);
     const weight = buffer.readFloatLE(124);
     const age = valAge > 1 ? valAge : undefined;
-    const sex = valSex === 2 ? user_1.Gender.FEMALE : user_1.Gender.MALE;
+    const sex = valSex === 2 ? types_1.Gender.FEMALE : types_1.Gender.MALE;
     return { length, weight, age, sex };
 }
 exports.parsePersonData = parsePersonData;

package/lib/serial/daum/types.d.ts

@@ -0,0 +1,14 @@
+export declare abstract class DaumSerialComms {
+    serial: any;
+    abstract getPort(): string;
+    abstract pauseLogging(): void;
+    abstract resumeLogging(): void;
+    abstract isConnected(): boolean;
+    abstract connect(): Promise<boolean>;
+    abstract close(): Promise<boolean>;
+    abstract setTargetSlope(slope: number): Promise<void>;
+    abstract setTargetPower(power: number): Promise<void>;
+}
+export declare class ResponseTimeout extends Error {
+    constructor();
+}

package/lib/serial/daum/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseTimeout = exports.DaumSerialComms = void 0;
+class DaumSerialComms {
+}
+exports.DaumSerialComms = DaumSerialComms;
+class ResponseTimeout extends Error {
+    constructor() {
+        super();
+        this.message = 'RESP timeout';
+    }
+}
+exports.ResponseTimeout = ResponseTimeout;

package/lib/serial/factories/adapter-factory.d.ts

@@ -0,0 +1,14 @@
+import { DeviceProperties } from '../../types';
+import { SerialIncyclistDevice } from '../base/adapter';
+import { SerialDeviceSettings } from "../types";
+export default class SerialAdapterFactory {
+    static _instance: SerialAdapterFactory;
+    adapters: Array<{
+        protocol: string;
+        AdapterClass: typeof SerialIncyclistDevice<DeviceProperties>;
+    }>;
+    static getInstance(): SerialAdapterFactory;
+    constructor();
+    registerAdapter(protocol: string, AdapterClass: typeof SerialIncyclistDevice<DeviceProperties>): void;
+    createInstance(props: SerialDeviceSettings, settings?: any): SerialIncyclistDevice<DeviceProperties>;
+}

package/lib/serial/factories/adapter-factory.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SerialAdapterFactory {
+    static getInstance() {
+        if (!SerialAdapterFactory._instance)
+            SerialAdapterFactory._instance = new SerialAdapterFactory();
+        return SerialAdapterFactory._instance;
+    }
+    constructor() {
+        this.adapters = [];
+    }
+    registerAdapter(protocol, AdapterClass) {
+        const existing = this.adapters.findIndex(a => a.protocol === protocol);
+        if (existing !== -1)
+            this.adapters[existing].AdapterClass = AdapterClass;
+        else
+            this.adapters.push({ protocol, AdapterClass });
+    }
+    createInstance(props, settings) {
+        const { protocol } = props;
+        if (!protocol)
+            return null;
+        const adapter = this.adapters.find(a => a.protocol === protocol);
+        if (!adapter)
+            return null;
+        const { AdapterClass } = adapter;
+        return new AdapterClass(props, settings);
+    }
+}
+exports.default = SerialAdapterFactory;

package/lib/serial/index.d.ts

@@ -1,9 +1,12 @@
-import SerialPortProvider, { useSerialPortProvider } from './serialport';
-import SerialInterface, { SerialInterfaceProps } from './serial-interface';
-import SerialAdapterFactory from './adapter-factory';
-import { SerialIncyclistDevice, SerialDeviceSettings } from './adapter';
+import SerialPortProvider, { useSerialPortProvider } from './base/serialport';
+import SerialInterface from './base/serial-interface';
+import SerialAdapterFactory from './factories/adapter-factory';
 import DaumClassicAdapter from './daum/classic/adapter';
 import DaumPremiumAdapter from './daum/premium/adapter';
 import KettlerRacerAdapter from './kettler/ergo-racer/adapter';
+export { SerialIncyclistDevice } from './base/adapter';
+export { SerialInterfaceProps, SerialDeviceSettings, SerialScannerProps } from "./types";
 export { TCPBinding } from './bindings/tcp';
-export { SerialPortProvider, useSerialPortProvider, SerialInterface, SerialInterfaceProps, SerialDeviceSettings, SerialAdapterFactory, DaumClassicAdapter, DaumPremiumAdapter, KettlerRacerAdapter, SerialIncyclistDevice };
+export { DaumPremiumDeviceProperties, Route, Point } from './daum/premium/types';
+export { DaumClassicProperties } from './daum/classic/types';
+export { SerialAdapterFactory, DaumClassicAdapter, DaumPremiumAdapter, KettlerRacerAdapter, SerialPortProvider, useSerialPortProvider, SerialInterface };

package/lib/serial/index.js

@@ -26,24 +26,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SerialIncyclistDevice = exports.KettlerRacerAdapter = exports.DaumPremiumAdapter = exports.DaumClassicAdapter = exports.SerialAdapterFactory = exports.SerialInterface = exports.useSerialPortProvider = exports.SerialPortProvider = exports.TCPBinding = void 0;
-const serialport_1 = __importStar(require("./serialport"));
+exports.SerialInterface = exports.useSerialPortProvider = exports.SerialPortProvider = exports.KettlerRacerAdapter = exports.DaumPremiumAdapter = exports.DaumClassicAdapter = exports.SerialAdapterFactory = exports.TCPBinding = exports.SerialIncyclistDevice = void 0;
+const serialport_1 = __importStar(require("./base/serialport"));
 exports.SerialPortProvider = serialport_1.default;
 Object.defineProperty(exports, "useSerialPortProvider", { enumerable: true, get: function () { return serialport_1.useSerialPortProvider; } });
-const serial_interface_1 = __importDefault(require("./serial-interface"));
+const serial_interface_1 = __importDefault(require("./base/serial-interface"));
 exports.SerialInterface = serial_interface_1.default;
-const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+const adapter_factory_1 = __importDefault(require("./factories/adapter-factory"));
 exports.SerialAdapterFactory = adapter_factory_1.default;
-const adapter_1 = require("./adapter");
-Object.defineProperty(exports, "SerialIncyclistDevice", { enumerable: true, get: function () { return adapter_1.SerialIncyclistDevice; } });
-const adapter_2 = __importDefault(require("./daum/classic/adapter"));
-exports.DaumClassicAdapter = adapter_2.default;
-const adapter_3 = __importDefault(require("./daum/premium/adapter"));
-exports.DaumPremiumAdapter = adapter_3.default;
-const adapter_4 = __importDefault(require("./kettler/ergo-racer/adapter"));
-exports.KettlerRacerAdapter = adapter_4.default;
+const adapter_1 = __importDefault(require("./daum/classic/adapter"));
+exports.DaumClassicAdapter = adapter_1.default;
+const adapter_2 = __importDefault(require("./daum/premium/adapter"));
+exports.DaumPremiumAdapter = adapter_2.default;
+const adapter_3 = __importDefault(require("./kettler/ergo-racer/adapter"));
+exports.KettlerRacerAdapter = adapter_3.default;
+var adapter_4 = require("./base/adapter");
+Object.defineProperty(exports, "SerialIncyclistDevice", { enumerable: true, get: function () { return adapter_4.SerialIncyclistDevice; } });
 var tcp_1 = require("./bindings/tcp");
 Object.defineProperty(exports, "TCPBinding", { enumerable: true, get: function () { return tcp_1.TCPBinding; } });
-adapter_factory_1.default.getInstance().registerAdapter('Daum Classic', adapter_2.default);
-adapter_factory_1.default.getInstance().registerAdapter('Daum Premium', adapter_3.default);
-adapter_factory_1.default.getInstance().registerAdapter('Kettler Racer', adapter_4.default);
+adapter_factory_1.default.getInstance().registerAdapter('Daum Classic', adapter_1.default);
+adapter_factory_1.default.getInstance().registerAdapter('Daum Premium', adapter_2.default);
+adapter_factory_1.default.getInstance().registerAdapter('Kettler Racer', adapter_3.default);

package/lib/serial/kettler/comms.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { EventLogger } from "gd-eventlog";
-import { Command } from "../../types/command";
+import { Command } from "./types";
 import EventEmitter from "events";
 import { SerialInterface } from "..";
 export type SerialCommsProps = {

package/lib/serial/kettler/ergo-racer/adapter.d.ts

@@ -1,11 +1,11 @@
-import { DeviceProperties } from "../../../types/device";
 import { EventLogger } from "gd-eventlog";
 import SerialComms from "../comms";
-import { Command } from "../../../types/command";
-import CyclingMode, { IncyclistBikeData } from "../../../modes/cycling-mode";
-import { SerialDeviceSettings, SerialIncyclistDevice } from "../../adapter";
-import { DeviceData } from "../../../types/data";
-import SerialInterface from "../../serial-interface";
+import { IncyclistBikeData } from "../../../types";
+import { SerialDeviceSettings } from "../../types";
+import { Command } from "../types";
+import { SerialIncyclistDevice } from "../../base/adapter";
+import SerialInterface from "../../base/serial-interface";
+import { ControllerConfig, IAdapter, IncyclistAdapterData, DeviceProperties } from "../../../types";
 export interface KettlerRacerCommand extends Command {
 }
 export interface KettlerExtendedBikeData {
@@ -21,26 +21,23 @@ export interface KettlerBikeData {
     time: number;
     power: number;
 }
-export default class KettlerRacerAdapter extends SerialIncyclistDevice {
+export default class KettlerRacerAdapter extends SerialIncyclistDevice<DeviceProperties> {
     private id;
-    private ignoreHrm;
-    private ignoreBike;
-    private ignorePower;
     private iv;
     private requests;
-    private data;
     private internalData;
     private kettlerData;
     private updateBusy;
     private requestBusy;
     private comms;
     private prevDistance;
+    protected static ontrollers: ControllerConfig;
     constructor(settings: SerialDeviceSettings, props?: DeviceProperties);
     isBike(): boolean;
     isPower(): boolean;
     isHrm(): boolean;
     getProtocolName(): string;
-    isSame(device: SerialIncyclistDevice): boolean;
+    isSame(device: IAdapter): boolean;
     setID(id: any): void;
     getID(): string;
     getName(): string;
@@ -69,10 +66,10 @@ export default class KettlerRacerAdapter extends SerialIncyclistDevice {
     check(): Promise<boolean>;
     start(props?: any): Promise<boolean>;
     startUpdatePull(): void;
-    canSendUpdate(): boolean;
+    canEmitData(): boolean;
     stop(): Promise<boolean>;
     mapData(bikeData: KettlerBikeData): IncyclistBikeData;
-    transformData(internalData: IncyclistBikeData, bikeData: KettlerBikeData): DeviceData;
+    transformData(internalData: IncyclistBikeData, bikeData: KettlerBikeData): IncyclistAdapterData;
     update(): Promise<void>;
     sendRequest(request: any): Promise<any>;
     sendRequests(): Promise<void>;
@@ -84,6 +81,4 @@ export default class KettlerRacerAdapter extends SerialIncyclistDevice {
     close(): Promise<boolean>;
     waitForOpened(retries?: boolean): Promise<boolean>;
     waitForClosed(): Promise<boolean>;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
 }

package/lib/serial/kettler/ergo-racer/adapter.js

@@ -16,9 +16,9 @@ const gd_eventlog_1 = require("gd-eventlog");
 const comms_1 = __importDefault(require("../comms"));
 const utils_1 = require("../../../utils/utils");
 const power_meter_1 = __importDefault(require("../../../modes/power-meter"));
-const erg_1 = __importDefault(require("./modes/erg"));
-const adapter_1 = require("../../adapter");
-const capabilities_1 = require("../../../types/capabilities");
+const kettler_erg_1 = __importDefault(require("../../../modes/kettler-erg"));
+const adapter_1 = require("../../base/adapter");
+const types_1 = require("../../../types");
 const PROTOCOL_NAME = 'Kettler Racer';
 class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
     constructor(settings, props) {
@@ -29,8 +29,8 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
         this.iv = null;
         this.comms = new comms_1.default({ interface: settings.interface, port: settings.port, logger: this.logger });
         this.capabilities = [
-            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Gear, capabilities_1.IncyclistCapability.HeartRate,
-            capabilities_1.IncyclistCapability.Control
+            types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence, types_1.IncyclistCapability.Gear, types_1.IncyclistCapability.HeartRate,
+            types_1.IncyclistCapability.Control
         ];
     }
     isBike() { return true; }
@@ -333,7 +333,7 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
             update: ivUpdate
         };
     }
-    canSendUpdate() {
+    canEmitData() {
         return !this.isPaused();
     }
     stop() {
@@ -566,11 +566,9 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
             }
         });
     }
-    getSupportedCyclingModes() {
-        return [power_meter_1.default, erg_1.default];
-    }
-    getDefaultCyclingMode() {
-        return new erg_1.default(this);
-    }
 }
+KettlerRacerAdapter.ontrollers = {
+    modes: [power_meter_1.default, kettler_erg_1.default],
+    default: kettler_erg_1.default
+};
 exports.default = KettlerRacerAdapter;

package/lib/serial/kettler/types.d.ts

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

package/lib/serial/kettler/types.js

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

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

@@ -3,39 +3,9 @@
 import EventEmitter from "events";
 import { BindingInterface } from "@serialport/bindings-interface";
 import { SerialPortStream } from '@serialport/stream';
-import { SerialDeviceSettings } from './adapter';
+import { SerialDeviceSettings, SerialScannerProps, PortMapping, SerialInterfaceProps } from "./types";
+import { IncyclistInterface } from "../types";
 import { EventLogger } from "gd-eventlog";
-import { IncyclistScanProps } from "../types/device";
-import { IncyclistInterface, InterfaceProps } from "../types/interface";
-export declare const SerialInterfaceType: {
-    SERIAL: string;
-    TCPIP: string;
-};
-export interface SerialInterfaceProps extends InterfaceProps {
-    ifaceName: string;
-    binding?: BindingInterface;
-}
-export type PortMapping = {
-    path: string;
-    port: SerialPortStream;
-};
-export interface SerialScannerProps extends IncyclistScanProps {
-    port?: string;
-    protocol: string;
-}
-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>;
-}
 export default class SerialInterface extends EventEmitter implements IncyclistInterface {
     ifaceName: string;
     binding: BindingInterface;

package/lib/serial/serial-interface.js

@@ -12,87 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SinglePathScanner = exports.SerialInterfaceType = void 0;
 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 adapters_1 = __importDefault(require("../adapters"));
-const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+const adapter_factory_1 = __importDefault(require("./factories/adapter-factory"));
+const serial_scanner_1 = require("./serial-scanner");
 const DEFAULT_SCAN_TIMEOUT = 10000;
-exports.SerialInterfaceType = {
-    SERIAL: 'serial',
-    TCPIP: 'tcpip'
-};
-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() === exports.SerialInterfaceType.TCPIP) {
-                            [host, port] = this.path.split(':');
-                        }
-                        else {
-                            port = this.path;
-                        }
-                        const adapterSettings = { interface: this.serial.getName(), host, port, protocol };
-                        const adapter = adapters_1.default.create(adapterSettings);
-                        found = yield adapter.check();
-                        if (found) {
-                            this.isFound = true;
-                            const name = adapter.getName();
-                            yield adapter.close();
-                            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;
 class SerialInterface extends events_1.default {
     static getInstance(props) {
         const { ifaceName, binding, logger } = props;
@@ -313,7 +239,7 @@ class SerialInterface extends events_1.default {
                 return [];
             }
             this.logEvent({ message: 'scanning on ', interface: this.ifaceName, paths: paths.map(p => p.path).join(','), timeout });
-            const scanners = paths.map(p => new SinglePathScanner(p.path, this, Object.assign(Object.assign({}, props), { logger: this.logger })));
+            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* () {
@@ -321,7 +247,7 @@ class SerialInterface extends events_1.default {
                         const adapter = adapter_factory_1.default.getInstance().createInstance(device);
                         const path = adapter.getPort();
                         this.inUse.push(path);
-                        yield adapter.stop();
+                        yield adapter.pause();
                         detected.push(device);
                         this.emit('device', device);
                     }

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

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

@@ -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());
+    });
+};
+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 +1,5 @@
 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;
-};
+import { InterfaceBinding, InterfaceImplementation } from './types';
 export default class SerialPortProvider {
     static _instance: SerialPortProvider;
     interfaces: InterfaceBinding[];