incyclist-devices 2.1.12 → 2.1.14

package/lib/antv2/hr copy/index.d.ts

@@ -1,2 +0,0 @@
-import AntHrAdapter from './adapter';
-export default AntHrAdapter;

package/lib/antv2/hr copy/index.js

@@ -1,7 +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 adapter_1 = __importDefault(require("./adapter"));
-exports.default = adapter_1.default;

package/lib/antv2/sensor-factory.d.ts

@@ -1,5 +0,0 @@
-import { ISensor, Profile } from "incyclist-ant-plus";
-export default class SensorFactory {
-    static create(profile: Profile, deviceID?: number): ISensor;
-    static createAll(): ISensor[];
-}

package/lib/antv2/sensor-factory.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const incyclist_ant_plus_1 = require("incyclist-ant-plus");
-const profiles = [
-    { profile: 'PWR', Class: incyclist_ant_plus_1.BicyclePowerSensor },
-    { profile: 'HR', Class: incyclist_ant_plus_1.HeartRateSensor },
-    { profile: 'FE', Class: incyclist_ant_plus_1.FitnessEquipmentSensor },
-];
-class SensorFactory {
-    static create(profile, deviceID) {
-        const info = profiles.find(i => i.profile === profile);
-        if (!info)
-            return;
-        return new info.Class(deviceID);
-    }
-    static createAll() {
-        return profiles.map(info => new info.Class());
-    }
-}
-exports.default = SensorFactory;

package/lib/interfaces.d.ts

@@ -1,7 +0,0 @@
-import { InterfaceProps } from "./types/interface";
-import { SerialInterface } from "./serial";
-import AntInterface from "./antv2/ant-interface";
-import { BleInterface } from "./ble";
-export default class InterfaceFactory {
-    static create(ifaceName: string, props?: InterfaceProps): AntInterface | BleInterface | SerialInterface;
-}

package/lib/interfaces.js

@@ -1,27 +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 serial_1 = require("./serial");
-const ant_interface_1 = __importDefault(require("./antv2/ant-interface"));
-const device_1 = require("./types/device");
-const ble_1 = require("./ble");
-class InterfaceFactory {
-    static create(ifaceName, props) {
-        switch (ifaceName) {
-            case device_1.INTERFACE.SERIAL:
-            case device_1.INTERFACE.TCPIP:
-                const serialProps = props;
-                serialProps.ifaceName = ifaceName;
-                return serial_1.SerialInterface.getInstance(serialProps);
-            case device_1.INTERFACE.ANT:
-                const antProps = props;
-                return ant_interface_1.default.getInstance(antProps);
-            case device_1.INTERFACE.BLE:
-                const bleProps = props;
-                return ble_1.BleInterface.getInstance(bleProps);
-        }
-    }
-}
-exports.default = InterfaceFactory;

package/lib/serial/SinglePathScanner.d.ts

@@ -1,17 +0,0 @@
-import { SerialDeviceSettings } from './adapter';
-import { EventLogger } from "gd-eventlog";
-import { SerialScannerProps } from "./types";
-import SerialInterface from "./serial-interface";
-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/SinglePathScanner.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 utils_1 = require("../utils/utils");
-const adapter_factory_1 = __importDefault(require("./adapter-factory"));
-const types_1 = require("./types");
-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/adapter-factory.d.ts

@@ -1,14 +0,0 @@
-import { DeviceProperties } from '../types';
-import { SerialIncyclistDevice } from './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/adapter-factory.js

@@ -1,30 +0,0 @@
-"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/adapter.d.ts

@@ -1,17 +0,0 @@
-import IncyclistDevice from "../base/adpater";
-import { DeviceProperties } from "../types";
-import SerialInterface from "./base/serial-interface";
-import { SerialDeviceSettings } from "./types";
-export declare class SerialIncyclistDevice<P extends DeviceProperties> extends IncyclistDevice<P> {
-    pullFrequency: number;
-    check(): Promise<boolean>;
-    constructor(settings: SerialDeviceSettings, props?: P);
-    isEqual(settings: SerialDeviceSettings): boolean;
-    getPort(): string;
-    getUniqueName(): string;
-    getSerialInterface(): SerialInterface;
-    getInterface(): string;
-    setMaxUpdateFrequency(ms: number): void;
-    setPullFrequency(ms: number): void;
-    getPullFrequency(): number;
-}

package/lib/serial/adapter.js

@@ -1,67 +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.SerialIncyclistDevice = void 0;
-const adpater_1 = __importDefault(require("../base/adpater"));
-const DEFAULT_PULL_FREQUENCY = 1000;
-class SerialIncyclistDevice extends adpater_1.default {
-    check() {
-        return __awaiter(this, void 0, void 0, function* () { throw new Error('not implemnted'); });
-    }
-    ;
-    constructor(settings, props) {
-        super(settings, props);
-        this.pullFrequency = DEFAULT_PULL_FREQUENCY;
-    }
-    isEqual(settings) {
-        if (settings.interface !== this.getInterface())
-            return false;
-        const s = this.settings;
-        if (settings.protocol !== s.protocol)
-            return false;
-        if (settings.port !== s.port)
-            return false;
-        if (settings.host && (!s.host || s.host !== settings.host))
-            return false;
-        return true;
-    }
-    getPort() {
-        const settings = this.settings;
-        return settings.port;
-    }
-    getUniqueName() {
-        return `${this.getName()} (${this.getPort()})`;
-    }
-    getSerialInterface() {
-        throw new Error('not implemented');
-    }
-    getInterface() {
-        return 'serial';
-    }
-    setMaxUpdateFrequency(ms) {
-        if (ms <= this.pullFrequency)
-            this.updateFrequency = -1;
-        else
-            this.updateFrequency = ms;
-    }
-    setPullFrequency(ms) {
-        this.pullFrequency = ms;
-        if (this.updateFrequency <= this.pullFrequency)
-            this.updateFrequency = -1;
-    }
-    getPullFrequency() {
-        return this.pullFrequency;
-    }
-}
-exports.SerialIncyclistDevice = SerialIncyclistDevice;

package/lib/serial/comm.d.ts

@@ -1,7 +0,0 @@
-import { EventLogger } from "gd-eventlog";
-import SerialInterface from "./serial-interface";
-export type SerialCommProps = {
-    serial: SerialInterface;
-    path: string;
-    logger?: EventLogger;
-};

package/lib/serial/comm.js

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

package/lib/serial/comms.d.ts

@@ -1,62 +0,0 @@
-/// <reference types="node" />
-import { EventLogger } from "gd-eventlog";
-import SerialInterface from "./base/serial-interface";
-import { SerialCommProps } from "./types";
-import { SerialPortStream } from "@serialport/stream";
-import { Queue } from "../utils/utils";
-export type ConnectionState = 'Connecting' | 'Connected' | 'Disconnected' | 'Disconnecting';
-export type Request = {
-    logString?: string;
-    isBinary?: boolean;
-};
-export type Response = {};
-export interface CommsState {
-    data?: Queue<Response>;
-}
-export default class SerialPortComms<T extends CommsState, C extends Request, R extends Response> {
-    logger: EventLogger;
-    serial: SerialInterface;
-    protected path: string;
-    protected props: SerialCommProps;
-    protected sp: SerialPortStream;
-    protected connectState: ConnectionState;
-    protected connectPromise: Promise<SerialPortStream>;
-    protected disconnectPromise: Promise<boolean>;
-    protected writePromise: Promise<void>;
-    protected sendCmdPromise: Promise<R>;
-    protected actualBikeType?: string;
-    protected recvState: T;
-    protected isLoggingPaused: boolean;
-    constructor(props: SerialCommProps);
-    getBusyTimeout(): number;
-    getDefaultLoggerName(): string;
-    getInitialCommsState(): T;
-    validatePath(path: string): string;
-    getInterface(): string;
-    getPort(): string;
-    isConnected(): boolean;
-    pauseLogging(): void;
-    resumeLogging(): void;
-    logEvent(e: any): void;
-    connect(): Promise<boolean>;
-    onConnected(): void;
-    portFlush(): void;
-    portPipe(destination: any, options?: any): any;
-    portUnpipe(destination?: any): void;
-    closePort(): Promise<boolean>;
-    resetState(isDisconnected?: boolean): void;
-    cleanupPort(isDisconnected?: boolean): void;
-    close(): Promise<boolean>;
-    flush(): Promise<void>;
-    onPortClose(): Promise<void>;
-    onPortError(error: Error): Promise<void>;
-    isSending(): boolean;
-    rejectCurrent(error: Error): void;
-    getTimeoutValue(): number;
-    onData(data: any, depth?: number): Promise<void>;
-    send(command: C): Promise<R>;
-    portWrite(buffer: Buffer): Promise<void>;
-    write(buffer: Buffer): Promise<void>;
-    ensurePrevCmdFinish(logPayload: any): Promise<void>;
-    ensureConnection(): Promise<void>;
-}

package/lib/serial/comms.js

@@ -1,280 +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 });
-const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("./daum/premium/utils");
-const utils_2 = require("../utils/utils");
-const DEFAULT_BUSY_TIMEOUT = 5000;
-class SerialPortComms {
-    constructor(props) {
-        this.props = props;
-        const { logger, serial, path } = props;
-        this.serial = serial;
-        this.path = this.validatePath(path);
-        const w = global.window;
-        this.logger = logger || ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.DEBUG ? utils_1.DEBUG_LOGGER : new gd_eventlog_1.EventLogger(this.getDefaultLoggerName()));
-        this.resetState();
-    }
-    getBusyTimeout() {
-        return DEFAULT_BUSY_TIMEOUT;
-    }
-    getDefaultLoggerName() {
-        return 'Serial';
-    }
-    getInitialCommsState() {
-        return { data: new utils_2.Queue() };
-    }
-    validatePath(path) {
-        return path;
-    }
-    getInterface() {
-        var _a;
-        return (_a = this.serial) === null || _a === void 0 ? void 0 : _a.ifaceName;
-    }
-    getPort() {
-        return this.path;
-    }
-    isConnected() {
-        return this.connectState === 'Connected' || this.connectState === 'Disconnecting';
-    }
-    pauseLogging() {
-        this.isLoggingPaused = true;
-    }
-    resumeLogging() {
-        this.isLoggingPaused = false;
-    }
-    logEvent(e) {
-        if (this.isLoggingPaused)
-            return;
-        this.logger.logEvent(e);
-        const w = global.window;
-        if (w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) {
-            console.log(`~~~ ${this.getDefaultLoggerName()}`, e);
-        }
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isConnected() && this.sp) {
-                return true;
-            }
-            if (this.connectState === 'Connecting') {
-                if (this.connectPromise) {
-                    try {
-                        yield this.connectPromise;
-                    }
-                    catch (_a) {
-                    }
-                }
-                return this.isConnected();
-            }
-            try {
-                this.connectState = 'Connecting';
-                this.connectPromise = this.serial.openPort(this.path);
-                const port = yield this.connectPromise;
-                this.connectPromise = null;
-                if (port !== null) {
-                    this.connectState = 'Connected';
-                    this.sp = port;
-                    this.sp.on('close', this.onPortClose.bind(this));
-                    this.sp.on('error', this.onPortError.bind(this));
-                    this.onConnected();
-                    return true;
-                }
-                else {
-                    this.connectState = 'Disconnected';
-                    return false;
-                }
-            }
-            catch (_b) {
-                this.connectState = 'Disconnected';
-                return false;
-            }
-        });
-    }
-    onConnected() {
-    }
-    portFlush() {
-        if (this.sp)
-            this.sp.flush();
-    }
-    portPipe(destination, options) {
-        if (this.sp)
-            return this.sp.pipe(destination, options);
-    }
-    portUnpipe(destination) {
-        if (this.sp)
-            this.sp.unpipe(destination);
-    }
-    closePort() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.sp)
-                return true;
-            try {
-                yield this.flush();
-                yield this.serial.closePort(this.path);
-                return true;
-            }
-            catch (err) {
-                this.logEvent({ message: 'could not close ', reason: err.message });
-                return false;
-            }
-        });
-    }
-    resetState(isDisconnected = true) {
-        this.isLoggingPaused = false;
-        this.recvState = this.getInitialCommsState();
-        this.connectPromise = null;
-        this.disconnectPromise = null;
-        this.writePromise = null;
-        this.sendCmdPromise = null;
-        if (isDisconnected)
-            this.connectState = 'Disconnected';
-    }
-    cleanupPort(isDisconnected = true) {
-        if (this.sp) {
-            this.sp.removeAllListeners();
-        }
-        this.sp = null;
-        this.resetState(isDisconnected);
-    }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let isDisconnected = false;
-            if (this.disconnectPromise) {
-                try {
-                    isDisconnected = yield this.disconnectPromise;
-                }
-                catch (_a) {
-                }
-                return isDisconnected;
-            }
-            if (this.connectState === 'Disconnected') {
-                this.cleanupPort();
-                return true;
-            }
-            else if (this.connectState === 'Disconnecting' || this.connectState === 'Connected' || this.connectState === 'Connecting') {
-                this.connectState = 'Disconnecting';
-                this.disconnectPromise = this.closePort();
-                isDisconnected = yield this.disconnectPromise;
-                if (isDisconnected) {
-                    this.connectState = 'Disconnected';
-                    this.logEvent({ message: "port closed:", port: this.path });
-                }
-                this.cleanupPort(isDisconnected);
-            }
-            return isDisconnected;
-        });
-    }
-    flush() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.writePromise) {
-                yield (0, utils_2.waitWithTimeout)(this.writePromise, 1000);
-                this.writePromise = null;
-            }
-        });
-    }
-    onPortClose() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.connectState !== 'Disconnected' && this.connectState !== 'Disconnecting')
-                this.logEvent({ message: "port closed:", port: this.path });
-            this.connectState = 'Disconnected';
-            this.cleanupPort();
-        });
-    }
-    onPortError(error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.connectState === 'Disconnecting' || this.connectState === 'Disconnected') {
-                return;
-            }
-            this.logEvent({ message: "port error:", port: this.path, error: error.message, connected: this.isConnected(), state: this.connectState });
-            if (this.isSending()) {
-                this.rejectCurrent(error);
-            }
-            if (this.connectState === 'Connected')
-                this.close();
-        });
-    }
-    isSending() {
-        return (this.writePromise !== undefined && this.writePromise !== null) || (this.sendCmdPromise !== null && this.sendCmdPromise !== undefined);
-    }
-    rejectCurrent(error) {
-        this.recvState.data.enqueue({ type: 'Error', error });
-    }
-    getTimeoutValue() {
-        throw new Error('method not implemented');
-    }
-    onData(data, depth = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-        });
-    }
-    send(command) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error('method not implemented');
-        });
-    }
-    portWrite(buffer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.sp) {
-                this.logEvent({ message: 'write failed', error: 'port is not opened' });
-                return;
-            }
-            try {
-                yield this.sp.write(buffer);
-            }
-            catch (err) {
-                this.logEvent({ message: 'write failed', error: err.message });
-            }
-        });
-    }
-    write(buffer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.writePromise) {
-                try {
-                    yield this.writePromise;
-                }
-                catch (_a) {
-                }
-                this.writePromise = null;
-            }
-            this.writePromise = this.portWrite(buffer);
-            yield this.writePromise;
-            this.writePromise = null;
-        });
-    }
-    ensurePrevCmdFinish(logPayload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.sendCmdPromise) {
-                const tsRequest = Date.now();
-                this.logEvent(Object.assign({ message: 'sendCommand:waiting:' }, logPayload));
-                let busyTimedOut = false;
-                const onTimeout = () => {
-                    this.logEvent(Object.assign(Object.assign({ message: 'sendCommand:error:' }, logPayload), { error: 'BUSY timeout', duration: Date.now() - tsRequest }));
-                    busyTimedOut = true;
-                };
-                yield (0, utils_2.waitWithTimeout)(this.sendCmdPromise, this.getBusyTimeout(), onTimeout);
-                this.sendCmdPromise = null;
-                if (busyTimedOut)
-                    throw new Error('BUSY timeout');
-            }
-        });
-    }
-    ensureConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isConnected()) {
-                const connected = yield this.connect();
-                if (!connected) {
-                    throw new Error('not connected');
-                }
-            }
-        });
-    }
-}
-exports.default = SerialPortComms;

package/lib/serial/daum/classic/PROTOCOL_NAME.d.ts

@@ -1,2 +0,0 @@
-export declare const PROTOCOL_NAME = "Daum Classic";
-export declare const DEFAULT_GEAR = 10;