incyclist-devices 2.1.12 → 2.1.14

package/package.json

@@ -1,51 +1,51 @@
-{
-  "name": "incyclist-devices",
-  "version": "2.1.12",
-  "dependencies": {
-    "@serialport/bindings-interface": "^1.2.2",
-    "@serialport/parser-byte-length": "^9.0.1",
-    "@serialport/parser-delimiter": "^9.0.1",
-    "@serialport/parser-readline": "^10.5.0",
-    "@serialport/stream": "^10.5.0",
-    "incyclist-ant-plus": "^0.2.0",
-    "win32filetime": "^1.0.2"
-  },
-  "peerDependencies": {
-    "gd-eventlog": "^0.1.24"
-  },
-  "devDependencies": {
-    "@serialport/binding-mock": "^10.2.2",
-    "@serialport/bindings-cpp": "^10.8.0",
-    "@types/jest": "^29.5.3",
-    "@types/node": "^20.5.0",
-    "eslint": "^8.47.0",
-    "eslint-config-react-app": "^7.0.1",
-    "jest": "^29.6.2",
-    "ts-jest": "^29.1.1",
-    "typescript": "^5.1.6"
-  },
-  "scripts": {
-    "lint": "eslint . --ext .ts",
-    "build": "tsc",
-    "test": "npx jest --coverage",
-    "test:ci": "npx jest --coverage --forceExit",
-    "dev": "tsc --watch",
-    "postversion": "git push && git push --tags"
-  },
-  "files": [
-    "lib/"
-  ],
-  "main": "lib/index.js",
-  "directories": {
-    "example": "./sample",
-    "lib": "./src"
-  },
-  "eslintConfig": {
-    "extends": "react-app",
-    "rules": {
-      "jsx-a11y/anchor-is-valid": [
-        "off"
-      ]
-    }
-  }
-}
+{
+  "name": "incyclist-devices",
+  "version": "2.1.14",
+  "dependencies": {
+    "@serialport/bindings-interface": "^1.2.2",
+    "@serialport/parser-byte-length": "^9.0.1",
+    "@serialport/parser-delimiter": "^9.0.1",
+    "@serialport/parser-readline": "^10.5.0",
+    "@serialport/stream": "^10.5.0",
+    "incyclist-ant-plus": "^0.2.0",
+    "win32filetime": "^1.0.2"
+  },
+  "peerDependencies": {
+    "gd-eventlog": "^0.1.24"
+  },
+  "devDependencies": {
+    "@serialport/binding-mock": "^10.2.2",
+    "@serialport/bindings-cpp": "^10.8.0",
+    "@types/jest": "^29.5.3",
+    "@types/node": "^20.5.0",
+    "eslint": "^8.47.0",
+    "eslint-config-react-app": "^7.0.1",
+    "jest": "^29.6.2",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.1.6"
+  },
+  "scripts": {
+    "lint": "eslint . --ext .ts",
+    "build": "tsc",
+    "test": "npx jest --coverage",
+    "test:ci": "npx jest --coverage --forceExit",
+    "dev": "tsc --watch",
+    "postversion": "git push && git push --tags"
+  },
+  "files": [
+    "lib/"
+  ],
+  "main": "lib/index.js",
+  "directories": {
+    "example": "./sample",
+    "lib": "./src"
+  },
+  "eslintConfig": {
+    "extends": "react-app",
+    "rules": {
+      "jsx-a11y/anchor-is-valid": [
+        "off"
+      ]
+    }
+  }
+}

package/lib/adapters.d.ts

@@ -1,7 +0,0 @@
-import { IncyclistDeviceAdapter } from "./base/adpater";
-import { DeviceProperties, DeviceSettings } from "./types/device";
-export default class AdapterFactory {
-    static adapters: IncyclistDeviceAdapter[];
-    static reset(): void;
-    static create(settings: DeviceSettings, props?: DeviceProperties): any;
-}

package/lib/adapters.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const antv2_1 = require("./antv2");
-const ble_1 = require("./ble");
-const serial_1 = require("./serial");
-const Simulator_1 = require("./simulator/Simulator");
-const device_1 = require("./types/device");
-class AdapterFactory {
-    static reset() {
-        AdapterFactory.adapters = [];
-        ble_1.BleAdapterFactory.getInstance().instances = [];
-    }
-    static create(settings, props) {
-        const adapters = AdapterFactory.adapters;
-        if (!settings.interface && settings.protocol === 'Simulator') {
-            const adapter = new Simulator_1.Simulator(settings);
-            if (adapter) {
-                adapters.push(adapter);
-            }
-            return adapter;
-        }
-        const existing = adapters.find(a => a.isEqual(settings));
-        if (existing)
-            return existing;
-        const ifaceName = typeof settings.interface === 'string' ? settings.interface : settings.interface.getName();
-        let adapter;
-        switch (ifaceName) {
-            case device_1.INTERFACE.SERIAL:
-            case device_1.INTERFACE.TCPIP:
-                adapter = serial_1.SerialAdapterFactory.getInstance().createInstance(settings, props);
-                break;
-            case device_1.INTERFACE.ANT:
-                adapter = antv2_1.AntAdapterFactory.getInstance().createInstance(settings, props);
-                break;
-            case device_1.INTERFACE.BLE:
-                adapter = ble_1.BleAdapterFactory.getInstance().createInstance(settings, props);
-                break;
-            case device_1.INTERFACE.SIMULATOR:
-                adapter = new Simulator_1.Simulator(settings, props);
-                break;
-        }
-        if (adapter) {
-            adapters.push(adapter);
-        }
-        return adapter;
-    }
-}
-AdapterFactory.adapters = [];
-exports.default = AdapterFactory;

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

@@ -1,14 +0,0 @@
-import { Profile } from "incyclist-ant-plus";
-import AntAdapter from "./base/adapter";
-import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData } from "./types";
-import { AntAdapterInfo, AdapterQuery } from "./types";
-export default class AntAdapterFactory {
-    static _instance: AntAdapterFactory;
-    adapters: AntAdapterInfo[];
-    static getInstance(): AntAdapterFactory;
-    constructor();
-    register<TDeviceData extends BaseDeviceData>(antProfile: Profile, incyclistProfile: LegacyProfile, Adapter: typeof AntAdapter<TDeviceData>): void;
-    getAdapter(query?: AdapterQuery): any;
-    createInstance(settings: AntDeviceSettings, props?: AntDeviceProperties): any;
-    createFromDetected(profile: Profile, deviceID: number, props?: AntDeviceProperties): any;
-}

package/lib/antv2/adapter-factory.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class AntAdapterFactory {
-    static getInstance() {
-        if (!AntAdapterFactory._instance)
-            AntAdapterFactory._instance = new AntAdapterFactory();
-        return AntAdapterFactory._instance;
-    }
-    constructor() {
-        this.adapters = [];
-    }
-    register(antProfile, incyclistProfile, Adapter) {
-        const info = Object.assign({}, { antProfile, incyclistProfile, Adapter });
-        const existing = this.adapters.findIndex(a => a.antProfile === antProfile);
-        if (existing !== -1)
-            this.adapters[existing] = info;
-        else
-            this.adapters.push(info);
-    }
-    getAdapter(query) {
-        const { antProfile, incyclistProfile } = query;
-        if (!antProfile && !incyclistProfile)
-            throw new Error('Illegal arguments: either "antProfile" or "incyclistProfile" must be set');
-        let found;
-        if (antProfile)
-            found = this.adapters.find(a => a.antProfile === antProfile);
-        if (incyclistProfile)
-            found = this.adapters.find(a => a.incyclistProfile === incyclistProfile);
-        return found;
-    }
-    createInstance(settings, props) {
-        let info;
-        const { profile, protocol } = settings;
-        let isLegacy = false;
-        if (protocol) {
-            try {
-                const incyclistProfile = profile;
-                info = this.getAdapter({ incyclistProfile });
-                isLegacy = true;
-            }
-            catch (_a) {
-                isLegacy = false;
-            }
-        }
-        if (!isLegacy) {
-            const antProfile = profile;
-            info = this.getAdapter({ antProfile });
-        }
-        if (info && info.Adapter)
-            return new info.Adapter(settings, props);
-    }
-    createFromDetected(profile, deviceID, props) {
-        const info = this.getAdapter({ antProfile: profile });
-        if (!info || !info.Adapter)
-            return;
-        const settings = Object.assign({}, {
-            profile: info.incyclistProfile,
-            deviceID: deviceID.toString(),
-            interface: 'ant',
-            protocol: 'Ant'
-        });
-        return new info.Adapter(settings, props);
-    }
-}
-exports.default = AntAdapterFactory;

package/lib/antv2/adapter.d.ts

@@ -1,54 +0,0 @@
-/// <reference types="node" />
-import { IChannel, ISensor, Profile } from 'incyclist-ant-plus';
-import AntInterface from './ant-interface';
-import IncyclistDevice from '../base/adpater';
-import { AntDeviceProperties, AntDeviceSettings, BaseDeviceData } from './types';
-import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../types';
-export default class AntAdapter<TDeviceData extends BaseDeviceData> extends IncyclistDevice<AntDeviceProperties> {
-    sensor: ISensor;
-    data: IncyclistAdapterData;
-    deviceData: TDeviceData;
-    updateFrequency: number;
-    channel: IChannel;
-    ant: AntInterface;
-    userSettings: {
-        weight?: number;
-    };
-    bikeSettings: {
-        weight?: number;
-    };
-    onDataFn: (data: IncyclistAdapterData) => void;
-    startupRetryPause: number;
-    protected ivDataTimeout: NodeJS.Timeout;
-    protected lastDataTS: number;
-    protected dataMsgCount: number;
-    protected ivWaitForData: NodeJS.Timeout;
-    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    createSensor(settings: AntDeviceSettings): ISensor;
-    isEqual(settings: AntDeviceSettings): boolean;
-    connect(): Promise<boolean>;
-    close(): Promise<boolean>;
-    resetData(): void;
-    isSame(device: IAdapter): boolean;
-    hasData(): boolean;
-    mapData(deviceData: TDeviceData): IncyclistBikeData;
-    transformData(data: IncyclistBikeData): void;
-    mapToAdapterData(deviceData: any): void;
-    onDeviceData(deviceData: TDeviceData): void;
-    isWaitingForData(): boolean;
-    waitForData(timeout: number): Promise<boolean>;
-    getID(): string;
-    getName(): string;
-    getInterface(): string;
-    getProfile(): Profile;
-    getLogData(data: any, excludeList: any): any;
-    triggerTimeoutCheck(): void;
-    startDataTimeoutCheck(): void;
-    stopDataTimeoutCheck(): void;
-    check(): Promise<boolean>;
-    checkCapabilities(): Promise<void>;
-    initControl(): Promise<void>;
-    sendUpdate(request: any): void;
-    start(props?: AntDeviceProperties): Promise<boolean>;
-    stop(): Promise<boolean>;
-}

package/lib/antv2/adapter.js

@@ -1,291 +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 });
-const ant_interface_1 = __importDefault(require("./ant-interface"));
-const adpater_1 = __importDefault(require("../base/adpater"));
-const types_1 = require("./types");
-const types_2 = require("../types");
-const utils_1 = require("../utils/utils");
-const utils_2 = require("./utils");
-const consts_1 = require("./consts");
-const INTERFACE_NAME = 'ant';
-class AntAdapter extends adpater_1.default {
-    constructor(settings, props) {
-        super(settings, props);
-        this.startupRetryPause = 1000;
-        const antSettings = this.settings;
-        if ((0, types_1.isLegacyProfile)(antSettings.profile))
-            antSettings.profile = (0, utils_2.mapLegacyProfile)(antSettings.profile);
-        if (this.settings.interface !== 'ant')
-            throw new Error('Incorrect interface');
-        this.sensor = this.createSensor(settings);
-        this.deviceData = {};
-        this.data = {};
-        this.dataMsgCount = 0;
-        this.updateFrequency = consts_1.DEFAULT_UPDATE_FREQUENCY;
-        this.channel = undefined;
-        this.ant = ant_interface_1.default.getInstance();
-    }
-    createSensor(settings) {
-        throw new Error('Method not implemented.');
-    }
-    isEqual(settings) {
-        const as = this.settings;
-        if (as.interface !== settings.interface)
-            return false;
-        if (Number(as.deviceID) !== Number(settings.deviceID) || as.profile !== settings.profile)
-            return false;
-        return true;
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connected = yield ant_interface_1.default.getInstance().connect();
-            return connected;
-        });
-    }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
-        });
-    }
-    resetData() {
-        this.dataMsgCount = 0;
-        const { DeviceID } = this.deviceData;
-        this.deviceData = { DeviceID };
-        this.lastDataTS = undefined;
-    }
-    isSame(device) {
-        if (!(device instanceof AntAdapter))
-            return false;
-        const adapter = device;
-        return (adapter.getID() === this.getID() && adapter.getProfile() === this.getProfile());
-    }
-    hasData() {
-        return this.dataMsgCount > 0;
-    }
-    mapData(deviceData) {
-        throw new Error('message not implemented');
-    }
-    transformData(data) {
-        throw new Error('message not implemented');
-    }
-    mapToAdapterData(deviceData) {
-        throw new Error('message not implemented');
-    }
-    onDeviceData(deviceData) {
-        this.dataMsgCount++;
-        this.lastDataTS = Date.now();
-        try {
-            const { ManId } = this.deviceData;
-            this.deviceData = Object.assign({}, deviceData);
-            if (!ManId && deviceData.ManId) {
-                this.emit('device-info', { device: this.getSettings(), manufacturer: (0, utils_2.getBrand)(deviceData.ManId) });
-            }
-            if (!this.started || this.isStopped())
-                return;
-            this.triggerTimeoutCheck();
-            if (!this.canEmitData())
-                return;
-            const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
-            this.logEvent({ message: 'onDeviceData', data: logData, paused: this.paused });
-            if (this.isControllable()) {
-                let incyclistData = this.mapData(deviceData);
-                incyclistData = this.getCyclingMode().updateData(incyclistData);
-                this.transformData(incyclistData);
-            }
-            else {
-                this.mapToAdapterData(deviceData);
-            }
-            this.emitData(this.data);
-        }
-        catch (err) {
-            console.log('~~~ERROR', err);
-            this.logEvent({ message: 'error', fn: 'onDeviceData()', error: err.message || err, stack: err.stack });
-        }
-    }
-    isWaitingForData() {
-        return this.ivWaitForData !== undefined && this.ivWaitForData !== null;
-    }
-    waitForData(timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const startTs = Date.now();
-            const timeoutTs = startTs + timeout;
-            if (this.hasData())
-                return true;
-            return new Promise((resolve, reject) => {
-                if (this.ivWaitForData)
-                    return reject(new Error('busy'));
-                this.ivWaitForData = setInterval(() => {
-                    const nowTs = Date.now();
-                    const hasData = this.hasData();
-                    if (nowTs > timeoutTs && !hasData) {
-                        clearInterval(this.ivWaitForData);
-                        this.ivWaitForData = undefined;
-                        reject(new Error('No Data Received'));
-                    }
-                    if (hasData) {
-                        clearInterval(this.ivWaitForData);
-                        this.ivWaitForData = undefined;
-                        resolve(true);
-                    }
-                }, 500);
-            });
-        });
-    }
-    getID() {
-        return this.sensor.getDeviceID().toString();
-    }
-    getName() {
-        const deviceID = this.sensor.getDeviceID();
-        const profile = this.sensor.getProfile();
-        return `Ant+${profile} ${deviceID}`;
-    }
-    getInterface() {
-        return INTERFACE_NAME;
-    }
-    getProfile() {
-        const settings = this.settings;
-        if (settings.protocol === undefined)
-            return settings.profile;
-        else {
-            return (0, utils_2.mapLegacyProfile)(settings.profile);
-        }
-    }
-    getLogData(data, excludeList) {
-        const logData = JSON.parse(JSON.stringify(data));
-        excludeList.forEach((key) => {
-            delete logData[key];
-        });
-        return logData;
-    }
-    triggerTimeoutCheck() {
-        if (!this.ivDataTimeout && this.dataMsgCount > 0) {
-            this.startDataTimeoutCheck();
-        }
-    }
-    startDataTimeoutCheck() {
-        if (this.ivDataTimeout)
-            return;
-        this.ivDataTimeout = setInterval(() => {
-            if (!this.lastDataTS)
-                return;
-            if (this.lastDataTS + consts_1.NO_DATA_TIMEOUT < Date.now()) {
-                this.emit('disconnected', Date.now() - this.lastDataTS);
-            }
-        }, 1000);
-    }
-    stopDataTimeoutCheck() {
-        if (!this.ivDataTimeout)
-            return;
-        clearInterval(this.ivDataTimeout);
-        this.ivDataTimeout = undefined;
-        this.lastDataTS = undefined;
-        this.dataMsgCount = 0;
-    }
-    check() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.start();
-            }
-            catch (error) {
-                return false;
-            }
-        });
-    }
-    checkCapabilities() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
-    }
-    initControl() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
-    }
-    sendUpdate(request) {
-        if (!this.isControllable())
-            return;
-        if (this.isPaused() || this.isStopped())
-            return;
-        if (!this.hasCapability(types_2.IncyclistCapability.Control))
-            this.getCyclingMode().sendBikeUpdate(request);
-        else
-            throw new Error('method not implemented');
-    }
-    start(props = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.started && !this.stopped) {
-                if (this.paused)
-                    this.resume();
-                return true;
-            }
-            this.stopped = false;
-            const connected = yield this.connect();
-            if (!connected)
-                throw new Error(`could not start device, reason:could not connect`);
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.resetData();
-                this.stopped = false;
-                this.resume();
-                const { startupTimeout = 20000 } = props;
-                let to = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        yield this.stop();
-                    }
-                    catch (_a) { }
-                    this.started = false;
-                    reject(new Error(`could not start device, reason:timeout`));
-                }), startupTimeout);
-                let started = false;
-                do {
-                    started = yield this.ant.startSensor(this.sensor, (data) => {
-                        this.onDeviceData(data);
-                    });
-                    if (!started)
-                        yield (0, utils_1.sleep)(this.startupRetryPause);
-                } while (!started);
-                try {
-                    yield this.waitForData(startupTimeout - 100);
-                    yield this.checkCapabilities();
-                    if (this.hasCapability(types_2.IncyclistCapability.Control))
-                        yield this.initControl();
-                    this.started = true;
-                    if (to)
-                        clearTimeout(to);
-                    resolve(true);
-                }
-                catch (err) {
-                }
-            }));
-        });
-    }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let stopped;
-            try {
-                this.stopDataTimeoutCheck();
-                stopped = yield this.ant.stopSensor(this.sensor);
-            }
-            catch (err) {
-                this.logEvent({ message: 'stop sensor failed', reason: err.message });
-            }
-            this.started = false;
-            this.stopped = true;
-            this.paused = false;
-            this.removeAllListeners();
-            return stopped;
-        });
-    }
-}
-exports.default = AntAdapter;

package/lib/antv2/ant-interface.d.ts

@@ -1,35 +0,0 @@
-/// <reference types="node" />
-import EventEmitter from "events";
-import { EventLogger } from "gd-eventlog";
-import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
-import { AntDeviceSettings, AntScanProps, AntInterfaceProps, ConnectState } from "./types";
-import { IncyclistInterface } from "../types";
-import AntDeviceBinding from "./base/binding";
-export default class AntInterface extends EventEmitter implements IncyclistInterface {
-    static _instance: AntInterface;
-    static INTERFACE_NAME: string;
-    static getInstance(props?: AntInterfaceProps): AntInterface;
-    static hasInstance(): boolean;
-    protected logger: EventLogger;
-    protected device: IAntDevice;
-    protected Binding: typeof AntDeviceBinding;
-    protected connectState: ConnectState;
-    protected props: AntInterfaceProps;
-    protected activeScan: IChannel;
-    constructor(props: AntInterfaceProps);
-    getName(): string;
-    getBinding(): typeof AntDeviceBinding;
-    setBinding(binding: typeof AntDeviceBinding): void;
-    setLogger(logger: EventLogger): void;
-    logEvent(event: any): void;
-    isConnected(): boolean;
-    connect(): Promise<boolean>;
-    disconnect(): Promise<boolean>;
-    onError(profile: any, error: any): void;
-    onData(profile: any, id: any, data: any, tag: any): void;
-    scan(props?: AntScanProps): Promise<AntDeviceSettings[]>;
-    stopScan(): Promise<boolean>;
-    startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
-    stopSensor(sensor: ISensor): Promise<boolean>;
-    isScanning(): boolean;
-}