incyclist-devices 2.2.9 → 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/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/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.9",
+  "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",