incyclist-devices 2.2.10-beta.0 → 2.3.0

package/lib/index.d.ts

@@ -1,15 +1,16 @@
-import { INTERFACE } from './types/device';
+import { INTERFACE, DeviceSettings, DeviceProperties } from './types/device';
 import { IncyclistInterface, InterfaceProps } from './types/interface';
 import { IncyclistCapability } from './types/capabilities';
 import { IncyclistAdapterData } from './types/data';
-import { DeviceSettings, DeviceProperties } from './types/device';
 import ICyclingMode from './modes/types';
 import calc from './utils/calculations';
 import IncyclistDevice, { IncyclistDeviceAdapter } from './base/adpater';
 import { IAdapter } from './types/adapter';
-export * from './factories';
+import AdapterFactory from './factories/adapters';
+import InterfaceFactory from './factories/interfaces';
 export * from './modes/types';
 export * from './serial';
 export * from './ble';
 export * from './antv2';
-export { IAdapter, IncyclistDevice, IncyclistDeviceAdapter, DeviceSettings, DeviceProperties, IncyclistInterface, INTERFACE, InterfaceProps, ICyclingMode, IncyclistAdapterData as DeviceData, IncyclistCapability, calc, };
+export * from './direct-connect';
+export { IAdapter, IncyclistDevice, IncyclistDeviceAdapter, DeviceSettings, DeviceProperties, AdapterFactory, InterfaceFactory, IncyclistInterface, INTERFACE, InterfaceProps, ICyclingMode, IncyclistAdapterData as DeviceData, IncyclistCapability, calc, };

package/lib/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calc = exports.IncyclistCapability = exports.INTERFACE = exports.IncyclistDevice = void 0;
+exports.calc = exports.IncyclistCapability = exports.INTERFACE = exports.InterfaceFactory = exports.AdapterFactory = exports.IncyclistDevice = void 0;
 const device_1 = require("./types/device");
 Object.defineProperty(exports, "INTERFACE", { enumerable: true, get: function () { return device_1.INTERFACE; } });
 const capabilities_1 = require("./types/capabilities");
@@ -26,8 +26,12 @@ const calculations_1 = __importDefault(require("./utils/calculations"));
 exports.calc = calculations_1.default;
 const adpater_1 = __importDefault(require("./base/adpater"));
 exports.IncyclistDevice = adpater_1.default;
-__exportStar(require("./factories"), exports);
+const adapters_1 = __importDefault(require("./factories/adapters"));
+exports.AdapterFactory = adapters_1.default;
+const interfaces_1 = __importDefault(require("./factories/interfaces"));
+exports.InterfaceFactory = interfaces_1.default;
 __exportStar(require("./modes/types"), exports);
 __exportStar(require("./serial"), exports);
 __exportStar(require("./ble"), exports);
 __exportStar(require("./antv2"), exports);
+__exportStar(require("./direct-connect"), exports);

package/lib/modes/antble-smarttrainer.d.ts

@@ -1,13 +1,7 @@
-import ICyclingMode, { CyclingModeProperyType, IVirtualShifting, UpdateRequest } from "./types";
+import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
 import PowerBasedCyclingModeBase from "./power-base";
 import { IAdapter } from "../types";
-export type GearConfigEntry = {
-    chainConfig: number[];
-    cassetteConfig: number[];
-    wheelCirc: number;
-    numGears: number;
-};
-export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode, IVirtualShifting {
+export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
     protected static config: {
         name: string;
         isSIM: boolean;
@@ -32,18 +26,10 @@ export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase i
             options?: undefined;
         })[];
     };
-    protected gear: any;
     constructor(adapter: IAdapter, props?: any);
     getBikeInitRequest(): UpdateRequest;
     checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
     protected checkSlope(request: UpdateRequest, newRequest?: UpdateRequest): void;
     protected checkEmptyRequest(newRequest: UpdateRequest): void;
     sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
-    initGears(): Promise<number>;
-    gearUp(numGears: number): Promise<number>;
-    protected switchGear: (gear: any, prevGear: any) => number;
-    protected findBestGear(): any;
-    getCurrentGearConfig(): GearConfigEntry;
-    protected getDefaultCadence(): number;
-    protected getDefaultPower(): number;
 }

package/lib/modes/antble-smarttrainer.js

@@ -1,45 +1,13 @@
 "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 types_1 = require("./types");
 const power_base_1 = __importDefault(require("./power-base"));
-const calculations_1 = __importDefault(require("../utils/calculations"));
-const NUM_GEARS = 30;
-const GearConfig = {
-    race: { chainConfig: [34, 50], cassetteConfig: [11, 36], wheelCirc: 2125, numGears: NUM_GEARS },
-    mountain: { chainConfig: [26, 36], cassetteConfig: [10, 44], wheelCirc: 2344, numGears: NUM_GEARS },
-    triathlon: { chainConfig: [36, 52], cassetteConfig: [11, 30], wheelCirc: 2125, numGears: NUM_GEARS },
-};
 class SmartTrainerCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
-        this.switchGear = (gear, prevGear) => {
-            var _a;
-            const { chainConfig, cassetteConfig, wheelCirc, numGears } = this.getCurrentGearConfig();
-            const { pedalRpm, speed, power, slope } = (_a = this.getData()) !== null && _a !== void 0 ? _a : {};
-            const m = this.getWeight();
-            let cadence = pedalRpm !== null && pedalRpm !== void 0 ? pedalRpm : this.getDefaultCadence();
-            let currentPower = power !== null && power !== void 0 ? power : this.getDefaultPower();
-            const prevGearSpeed = calculations_1.default.calculateSpeedBike(prevGear, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
-            const targetGearSpeed = calculations_1.default.calculateSpeedBike(gear, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
-            const targetGearPower = calculations_1.default.calculatePower(m, targetGearSpeed / 3.6, 0);
-            const prevGearPower = calculations_1.default.calculatePower(m, prevGearSpeed / 3.6, 0);
-            const targetPower = currentPower + (targetGearPower - prevGearPower);
-            const slopeTarget = calculations_1.default.calculateSlope(m, targetPower, speed / 3.6);
-            console.log('Gear', gear, 'power', targetPower, 'speed', speed.toFixed(1), 'slope', slope.toFixed(1), 'virtual slope', slopeTarget.toFixed(1));
-            return slopeTarget;
-        };
         this.initLogger('SmartTrainerMode');
     }
     getBikeInitRequest() {
@@ -60,16 +28,11 @@ class SmartTrainerCyclingMode extends power_base_1.default {
             newRequest.slope = parseFloat(request.slope.toFixed(1));
             this.data.slope = newRequest.slope;
             try {
-                if (this.gear !== undefined) {
-                    const slopeTarget = this.switchGear(this.gear, this.gear);
-                    newRequest.slope = slopeTarget;
-                }
                 const slopeAdj = this.getSetting('slopeAdj');
                 if (slopeAdj !== undefined)
                     newRequest.slope = newRequest.slope * slopeAdj / 100;
             }
-            catch (err) {
-                this.logger.logEvent({ message: "error", fn: '', error: err.message, request, prev: this.prevRequest, data: this.getData() });
+            catch (_a) {
             }
         }
     }
@@ -98,66 +61,6 @@ class SmartTrainerCyclingMode extends power_base_1.default {
         }
         return newRequest;
     }
-    initGears() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.gear = this.findBestGear();
-            return this.gear;
-        });
-    }
-    gearUp(numGears) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let target = this.gear + numGears;
-            if (target > NUM_GEARS)
-                target = NUM_GEARS;
-            if (target < 1)
-                target = 1;
-            this.gear = target;
-            return this.gear;
-        });
-    }
-    findBestGear() {
-        var _a;
-        const { chainConfig, cassetteConfig, wheelCirc, numGears } = this.getCurrentGearConfig();
-        const { pedalRpm, speed, power, slope } = (_a = this.getData()) !== null && _a !== void 0 ? _a : {};
-        const m = this.getWeight();
-        let cadence = pedalRpm !== null && pedalRpm !== void 0 ? pedalRpm : this.getDefaultCadence();
-        let currentPower = power !== null && power !== void 0 ? power : this.getDefaultPower();
-        let minDiff, gearInitial;
-        if (speed === 0) {
-            const speedInitial = calculations_1.default.calculateSpeed(m, currentPower, slope);
-            for (let i = 1; i <= numGears; i++) {
-                const speed = calculations_1.default.calculateSpeedBike(i, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
-                const diff = Math.abs(speed - speedInitial);
-                if (!minDiff || diff < minDiff) {
-                    minDiff = diff;
-                    gearInitial = i;
-                }
-            }
-        }
-        else {
-            for (let i = 1; i <= numGears; i++) {
-                const speed = calculations_1.default.calculateSpeedBike(i, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
-                const targetPower = calculations_1.default.calculatePower(m, speed / 3.6, slope);
-                const diff = Math.abs(currentPower - targetPower);
-                if (!minDiff || diff < minDiff) {
-                    minDiff = diff;
-                    gearInitial = i;
-                }
-            }
-        }
-        return gearInitial;
-    }
-    getCurrentGearConfig() {
-        var _a;
-        const type = (_a = this.getSetting('bikeType')) !== null && _a !== void 0 ? _a : 'Race';
-        return GearConfig[type.toLowerCase()];
-    }
-    getDefaultCadence() {
-        return 90;
-    }
-    getDefaultPower() {
-        return 120;
-    }
 }
 SmartTrainerCyclingMode.config = {
     name: "Smart Trainer",

package/lib/modes/types.d.ts

@@ -47,10 +47,6 @@ export default interface ICyclingMode {
     setModeProperty(name: string, value: any): void;
     getModeProperty(name: string): any;
 }
-export interface IVirtualShifting {
-    initGears(): Promise<number>;
-    gearUp(numGears: number): Promise<number>;
-}
 export type CyclingModeConfig = {
     isERG?: boolean;
     isSIM?: boolean;
@@ -73,7 +69,7 @@ export declare class CyclingMode implements ICyclingMode {
     getSetting(_name: string): void;
     getSettings(): Settings;
     setModeProperty(_name: string, _value: any): void;
-    getModeProperty(_name: string): any;
+    getModeProperty(_name: string): void;
     getConfig(): CyclingModeConfig;
     isERG(): boolean;
     isSIM(): boolean;

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

@@ -6,6 +6,7 @@ export interface TCPOpenOptions extends OpenOptions {
 }
 export declare interface TCPBindingInterface<T extends BindingPortInterface = BindingPortInterface, R extends OpenOptions = OpenOptions, P extends PortInfo = PortInfo> extends BindingInterface<TCPPortBinding, TCPOpenOptions> {
     list(port?: number, excludeList?: string[]): Promise<P[]>;
+    open(options: TCPOpenOptions): Promise<TCPPortBinding>;
 }
 export declare class CanceledError extends Error {
     canceled: true;
@@ -22,10 +23,10 @@ export declare class TCPPortBinding implements BindingPortInterface {
     writeOperation: null | Promise<any>;
     data: Buffer;
     private pendingRead;
-    private onDataHandler;
-    private onErrorHandler;
-    private onTimeoutHandler;
-    private onCloseHandler;
+    private readonly onDataHandler;
+    private readonly onErrorHandler;
+    private readonly onTimeoutHandler;
+    private readonly onCloseHandler;
     constructor(socket: net.Socket, options: Required<OpenOptions>);
     get isOpen(): boolean;
     onData(data: Buffer): void;

package/lib/serial/bindings/tcp.js

@@ -55,23 +55,13 @@ function scanPort(host, port) {
 function scanSubNet(sn, port, excludeHosts) {
     const range = [];
     for (let i = 1; i < 255; i++)
-        if (!excludeHosts || !excludeHosts.includes(`${sn}.${i}`))
+        if (!(excludeHosts === null || excludeHosts === void 0 ? void 0 : excludeHosts.includes(`${sn}.${i}`)))
             range.push(i);
     return Promise.all(range.map(j => scanPort(`${sn}.${j}`, port).then(success => success ? `${sn}.${j}` : null).catch()))
         .then(hosts => hosts.filter(h => h !== null))
         .catch();
 }
 function getSubnets() {
-    const nets = (0, os_1.networkInterfaces)();
-    const results = [];
-    const names = Object.keys(nets);
-    names.forEach(name => {
-        for (const net of nets[name]) {
-            if (net.family === 'IPv4' && !net.internal) {
-                results.push(net.address);
-            }
-        }
-    });
     const address = Object.keys((0, os_1.networkInterfaces)())
         .reduce((a, key) => [
         ...a,
@@ -93,7 +83,7 @@ exports.TCPBinding = {
                 return [];
             const subnets = getSubnets();
             let hosts = [];
-            const excludeHosts = excludeList.map(e => e && e.includes(':') ? e.split(':')[0] : e);
+            const excludeHosts = excludeList.map(e => (e === null || e === void 0 ? void 0 : e.includes(':')) ? e.split(':')[0] : e);
             yield Promise.all(subnets.map(sn => scanSubNet(sn, port, excludeHosts).then(found => { hosts.push(...found); })));
             return hosts.map(host => ({
                 path: `${host}:${port}`,
@@ -253,17 +243,20 @@ class TCPPortBinding {
         if (!this.isOpen) {
             throw new Error('Port is not open');
         }
-        this.writeOperation = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            yield resolveNextTick();
-            try {
-                this.socket.write(buffer, () => {
-                    resolve();
-                });
-            }
-            catch (err) {
-                this.onError(err);
-            }
-        }));
+        this.writeOperation = new Promise((resolve) => {
+            const run = () => __awaiter(this, void 0, void 0, function* () {
+                yield resolveNextTick();
+                try {
+                    this.socket.write(buffer, () => {
+                        resolve();
+                    });
+                }
+                catch (err) {
+                    this.onError(err);
+                }
+            });
+            run();
+        });
         return this.writeOperation;
     }
     update(options) {

package/lib/types/device.d.ts

@@ -7,7 +7,8 @@ export declare enum INTERFACE {
     ANT = "ant",
     BLE = "ble",
     USB = "usb",
-    SIMULATOR = "simulator"
+    SIMULATOR = "simulator",
+    DC = "wifi"
 }
 export type DeviceType = 'race' | 'mountain' | 'triathlon';
 export type DeviceProperties = {

package/lib/types/device.js

@@ -9,4 +9,5 @@ var INTERFACE;
     INTERFACE["BLE"] = "ble";
     INTERFACE["USB"] = "usb";
     INTERFACE["SIMULATOR"] = "simulator";
+    INTERFACE["DC"] = "wifi";
 })(INTERFACE || (exports.INTERFACE = INTERFACE = {}));

package/lib/utils/calculations.d.ts

@@ -3,7 +3,6 @@ export declare class IllegalArgumentException extends Error {
 }
 export default class C {
     static calculateSpeed(m: number, power: number, slope: number, props?: any): number;
-    static calculateSlope(m: number, P: number, v: number, props?: any): number;
     static calculatePower(m: number, v: number, slope: number, props?: any): number;
     static calculateSpeedDaum(gear: number, rpm: number, bikeType?: string | number): number;
     static calculateSpeedBike(gear: number, rpm: number, chain: number[], cassette: number[], props?: {

package/lib/utils/calculations.js

@@ -19,14 +19,13 @@ class IllegalArgumentException extends Error {
 exports.IllegalArgumentException = IllegalArgumentException;
 class C {
     static calculateSpeed(m, power, slope, props = {}) {
-        var _a, _b, _c, _d;
         if (m === undefined || m === null || m < 0)
             throw new IllegalArgumentException("m must be a positive number");
         if (power === undefined || power === null || power < 0)
             throw new IllegalArgumentException("power must be a positive number");
-        const _rho = (_a = props.rho) !== null && _a !== void 0 ? _a : rho;
-        const _cRR = (_b = props.cRR) !== null && _b !== void 0 ? _b : cRR;
-        const _cwA = (_c = props.cwA) !== null && _c !== void 0 ? _c : ((_d = cwABike[props.bikeType || 'race']) !== null && _d !== void 0 ? _d : cwABike.race);
+        const _rho = props.rho || rho;
+        const _cRR = props.cRR || cRR;
+        const _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
         let sl = Math.atan(slope / 100);
         let c1 = 0.5 * _rho * _cwA;
         let c2 = (sl + _cRR) * m * g;
@@ -59,29 +58,14 @@ class C {
         }
         return 0;
     }
-    static calculateSlope(m, P, v, props = {}) {
-        var _a, _b, _c;
-        if (m === undefined || m === null || m < 0)
-            throw new IllegalArgumentException("m must be a positive number");
-        if (P === undefined || P === null || P < 0)
-            throw new IllegalArgumentException("power must be a positive number");
-        if (v === undefined || v === null || v === 0)
-            throw new IllegalArgumentException("v must be a positive number");
-        const _rho = (_a = props.rho) !== null && _a !== void 0 ? _a : rho;
-        const _cRR = (_b = props.cRR) !== null && _b !== void 0 ? _b : cRR;
-        const _cwA = (_c = props.cwA) !== null && _c !== void 0 ? _c : (cwABike[props.bikeType || 'race'] || cwABike.race);
-        const sl = (P - (0.5 * _rho * _cwA) * Math.pow(v, 3.0)) / (m * g * v) - _cRR;
-        return Math.tan(Math.asin(sl)) * 100;
-    }
     static calculatePower(m, v, slope, props = {}) {
-        var _a, _b, _c;
         if (m === undefined || m === null || m < 0)
             throw new IllegalArgumentException("m must be a positive number");
         if (v === undefined || v === null || v < 0)
             throw new IllegalArgumentException("v must be a positive number");
-        let _rho = (_a = props.rho) !== null && _a !== void 0 ? _a : rho;
-        let _cRR = (_b = props.cRR) !== null && _b !== void 0 ? _b : cRR;
-        let _cwA = (_c = props.cwA) !== null && _c !== void 0 ? _c : cwABike[props.bikeType || 'race'];
+        let _rho = props.rho || rho;
+        let _cRR = props.cRR || cRR;
+        let _cwA = props.cwA || cwABike[props.bikeType || 'race'];
         let sl = Math.sin(Math.atan(slope / 100));
         let P = (0.5 * _rho * _cwA) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
         return P;

package/lib/utils/operation.d.ts

@@ -0,0 +1,17 @@
+export interface TaskState {
+    isRunning: boolean;
+    timeout?: NodeJS.Timeout;
+    onTimeout: () => void;
+    promise: Promise<any>;
+}
+export interface TaskProps {
+    timeout?: number;
+}
+export declare class Task<T extends TaskState> {
+    protected _state: T;
+    constructor(_state: T, props: TaskProps);
+    get state(): T;
+    get promise(): Promise<any>;
+    start(promise: Promise<any>): void;
+    isRunning(): boolean;
+}

package/lib/utils/operation.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = void 0;
+class Task {
+    constructor(_state, props) {
+        this._state = _state;
+    }
+    get state() {
+        return this._state;
+    }
+    get promise() {
+        return this._state.promise;
+    }
+    start(promise) {
+    }
+    isRunning() {
+        return this._state.isRunning;
+    }
+}
+exports.Task = Task;

package/lib/utils/task.d.ts

@@ -0,0 +1,44 @@
+import EventEmitter from "events";
+export interface TaskState {
+    result?: 'completed' | 'timeout' | 'stopped' | 'error' | 'paused';
+    error?: Error;
+    tsStart?: number;
+    tsTimeout?: number;
+    promise?: Promise<any>;
+}
+export interface TaskProps<T, P> {
+    timeout?: number;
+    state?: any;
+    name?: string;
+    errorOnTimeout?: boolean;
+    log?: (event: any) => void;
+    onDone?: (state: T) => P;
+}
+interface InternalTaskState<P> {
+    tsStart?: number;
+    tsTimeout?: number;
+    isRunning: boolean;
+    timeout?: NodeJS.Timeout;
+    promise?: Promise<P>;
+    onDone?: (result: P) => void;
+    onError?: (error: Error) => void;
+    onTimeout?: () => void;
+}
+export declare class InteruptableTask<T extends TaskState, P> {
+    protected state: T;
+    protected internalState: InternalTaskState<P>;
+    protected props?: TaskProps<T, P>;
+    protected internalEvents: EventEmitter<[never]>;
+    protected promise?: Promise<P>;
+    constructor(promise: Promise<any>, props?: TaskProps<T, P>);
+    getPromise(): Promise<P>;
+    getState(): T;
+    run(): Promise<P>;
+    start(): void;
+    stop(): Promise<boolean>;
+    isRunning(): boolean;
+    protected clearTimeout(): void;
+    protected onTimeout(): void;
+    protected logEvent(event: any): void;
+}
+export {};

package/lib/utils/task.js

@@ -0,0 +1,127 @@
+"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.InteruptableTask = void 0;
+const events_1 = __importDefault(require("events"));
+const utils_1 = require("./utils");
+class InteruptableTask {
+    constructor(promise, props) {
+        var _a;
+        this.internalState = { isRunning: false };
+        this.internalEvents = new events_1.default();
+        this.state = ((_a = props === null || props === void 0 ? void 0 : props.state) !== null && _a !== void 0 ? _a : {});
+        this.props = props;
+        delete this.props.state;
+        this.promise = promise;
+        this.start();
+    }
+    getPromise() {
+        return this.internalState.promise;
+    }
+    getState() {
+        return this.state;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.internalState.isRunning)
+                yield (0, utils_1.resolveNextTick)();
+            return this.internalState.promise;
+        });
+    }
+    start() {
+        this.internalState.promise = new Promise((resolve, reject) => {
+            var _a;
+            this.internalState.isRunning = true;
+            this.internalState.onDone = resolve;
+            this.internalState.onError = reject;
+            this.internalState.tsStart = Date.now();
+            const { timeout } = this.props;
+            if (timeout) {
+                this.internalState.tsTimeout = this.internalState.tsStart + timeout;
+                this.internalState.onTimeout = this.onTimeout.bind(this);
+                this.internalState.timeout = setTimeout(() => { this.internalEvents.emit('timeout'); }, timeout);
+                this.internalEvents.on('timeout', this.internalState.onTimeout);
+            }
+            this.internalEvents.once('stopped', () => {
+                this.clearTimeout();
+                this.internalState = {
+                    isRunning: false,
+                };
+                this.internalEvents.removeAllListeners();
+                if (this.getState().result === 'completed' || this.getState().result === 'error')
+                    return;
+                if (this.props.onDone)
+                    resolve(this.props.onDone(this.getState()));
+                else
+                    resolve(null);
+            });
+            (_a = this.promise) === null || _a === void 0 ? void 0 : _a.then((res) => {
+                this.clearTimeout();
+                this.internalState = {
+                    isRunning: false,
+                };
+                this.getState().result = 'completed';
+                this.internalEvents.emit('stopped');
+                resolve(res);
+            }).catch((err) => {
+                this.getState().result = 'error';
+                this.getState().error = err;
+                this.internalEvents.emit('stopped');
+                reject(err);
+            });
+        });
+    }
+    stop() {
+        return new Promise((resolve) => {
+            this.internalEvents.emit('stopped');
+            (0, utils_1.resolveNextTick)().then(() => {
+                resolve(true);
+            });
+        });
+    }
+    isRunning() {
+        return this.internalState.isRunning === true;
+    }
+    clearTimeout() {
+        if (this.internalState.timeout) {
+            clearTimeout(this.internalState.timeout);
+            this.internalEvents.off('timeout', this.internalState.onTimeout);
+        }
+        delete this.internalState.timeout;
+    }
+    onTimeout() {
+        var _a;
+        if (!this.internalState.timeout)
+            return;
+        const message = this.props.name ? `${this.props.name} timeout` : 'timeout';
+        this.logEvent({ message, active: this.isRunning() });
+        this.clearTimeout();
+        this.getState().result = 'timeout';
+        const resolve = this.internalState.onDone;
+        const reject = this.internalState.onError;
+        this.internalState = { isRunning: false };
+        if ((_a = this.props.errorOnTimeout) !== null && _a !== void 0 ? _a : true) {
+            reject(new Error('timeout'));
+        }
+        if (this.props.onDone)
+            resolve(this.props.onDone(this.getState()));
+        else
+            resolve(null);
+    }
+    logEvent(event) {
+        if (this.props.log)
+            this.props.log(event);
+    }
+}
+exports.InteruptableTask = InteruptableTask;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.2.10-beta.0",
+  "version": "2.3.0",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",
@@ -16,8 +16,10 @@
   "devDependencies": {
     "@serialport/binding-mock": "^10.2.2",
     "@serialport/bindings-cpp": "^10.8.0",
+    "@stoprocent/noble": "^1.15.2",
     "@types/jest": "^29.5.12",
     "@types/node": "^22.5.0",
+    "bonjour-service": "^1.3.0",
     "eslint": "^8.47.0",
     "eslint-config-react-app": "^7.0.1",
     "jest": "^29.7.0",