incyclist-devices 2.2.10-beta.0 → 2.3.0-beta.10

package/lib/utils/task.js

@@ -0,0 +1,139 @@
+"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.onStopNotifiers = [];
+        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;
+        });
+    }
+    notifyOnStop(cb) {
+        this.onStopNotifiers.push(cb);
+    }
+    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();
+                this.sendStopNotification();
+                if (this.getState().result === 'completed' || this.getState().result === 'error')
+                    return;
+                this.getState().result = 'stopped';
+                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);
+    }
+    sendStopNotification() {
+        this.onStopNotifiers.forEach((cb) => {
+            if (typeof cb === 'function')
+                cb();
+        });
+    }
+    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-beta.10",
   "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",