incyclist-devices 2.1.31 → 2.1.33

package/lib/antv2/base/ant-interface.js

@@ -1,285 +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 events_1 = __importDefault(require("events"));
-const gd_eventlog_1 = require("gd-eventlog");
-const sensor_factory_1 = __importDefault(require("../factories/sensor-factory"));
-class AntInterface extends events_1.default {
-    static getInstance(props = {}) {
-        if (AntInterface._instance === undefined)
-            AntInterface._instance = new AntInterface(props);
-        return AntInterface._instance;
-    }
-    static hasInstance() {
-        return AntInterface._instance !== undefined;
-    }
-    constructor(props) {
-        super();
-        this.props = props;
-        this.device = undefined;
-        this.connectState = {
-            connected: false,
-            connecting: false
-        };
-        const { binding, logger } = props;
-        if (logger)
-            this.logger = logger;
-        else {
-            this.logger = new gd_eventlog_1.EventLogger('Ant+');
-        }
-        if (binding) {
-            this.Binding = binding;
-        }
-    }
-    getName() {
-        return AntInterface.INTERFACE_NAME;
-    }
-    getBinding() {
-        return this.Binding;
-    }
-    setBinding(binding) {
-        this.Binding = binding;
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    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.ANT_DEBUG) {
-            console.log('~~~ ANT', event);
-        }
-    }
-    isConnected() {
-        return this.connectState.connected;
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isConnected())
-                return true;
-            if (!this.connectState.connecting) {
-                this.connectState.connecting = true;
-                this.logEvent({ message: 'ANT+ connecting ...' });
-                try {
-                    const device = new this.Binding(Object.assign(Object.assign({}, this.props), { logger: this.logger }));
-                    const opened = yield device.open();
-                    if (!opened) {
-                        this.logEvent({ message: 'ANT+ not connected' });
-                        this.connectState.connecting = false;
-                        return false;
-                    }
-                    this.device = device;
-                    this.connectState.connected = true;
-                    this.connectState.connecting = false;
-                    this.logEvent({ message: 'ANT+ connected' });
-                    return true;
-                }
-                catch (err) {
-                    this.logEvent({ message: 'error', fn: 'connect', error: err.message, stack: err.stack });
-                    this.connectState.connected = false;
-                    this.connectState.connecting = false;
-                    return false;
-                }
-            }
-            else {
-                return new Promise(resolve => {
-                    setInterval(() => {
-                        if (!this.connectState.connecting)
-                            resolve(this.connectState.connected);
-                    }, 500);
-                });
-            }
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device)
-                return true;
-            this.logEvent({ message: 'ANT+ disconnecting ...' });
-            const closed = yield this.device.close();
-            this.connectState.connected = !closed;
-            this.logEvent({ message: 'ANT+ disconnected' });
-            return closed;
-        });
-    }
-    onError(profile, error) {
-        this.logEvent({ message: 'ANT+ERROR:', profile, error });
-    }
-    onData(profile, id, data, tag) {
-        this.emit('data', profile, id, data, tag);
-    }
-    scan(props = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'starting scan ..' });
-            const detected = [];
-            const onDetected = (profile, deviceID) => {
-                if (deviceID && detected.find(s => s.deviceID === deviceID && s.profile === profile) === undefined) {
-                    try {
-                        detected.push({ interface: this.getName(), profile, deviceID });
-                        this.emit('device', { interface: 'ant', profile, deviceID });
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'error', fn: 'onDerected', error: err.message, stack: err.stack });
-                    }
-                }
-            };
-            let channel;
-            if (!this.activeScan) {
-                while (!this.isConnected()) {
-                    const connected = yield this.connect();
-                    if (!connected)
-                        return [];
-                }
-                channel = this.device.getChannel();
-                channel.setProps({ logger: this.logger });
-                if (!channel)
-                    return [];
-                const sensors = sensor_factory_1.default.createAll();
-                sensors.forEach((sensor) => {
-                    channel.attach(sensor);
-                });
-                channel.on('detected', onDetected);
-                channel.on('data', this.onData.bind(this));
-                try {
-                    const success = yield channel.startScanner();
-                    this.logEvent({ message: 'scan started', success });
-                }
-                catch (err) {
-                    this.logEvent({ message: 'scan could not be started', error: err.message, stack: err.stack });
-                    channel.off('detected', onDetected);
-                    channel.off('data', this.onData.bind(this));
-                    return [];
-                }
-                let iv;
-                return new Promise(resolve => {
-                    this.activeScan = channel;
-                    const start = Date.now();
-                    const timeout = props.timeout ? start + props.timeout : undefined;
-                    iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                        if (this.activeScan && (!timeout || Date.now() < timeout))
-                            return;
-                        clearInterval(iv);
-                        if (this.activeScan)
-                            yield this.stopScan();
-                        this.emit('stop-scan');
-                        channel.off('detected', onDetected);
-                        channel.off('data', this.onData.bind(this));
-                        resolve(detected);
-                    }), 100);
-                });
-            }
-            else {
-                return new Promise(resolve => {
-                    channel = this.activeScan;
-                    channel.on('data', this.onData.bind(this));
-                    channel.on('detected', onDetected);
-                    this.once('stop-scan', () => {
-                        channel.off('detected', onDetected);
-                        channel.off('data', this.onData.bind(this));
-                        resolve(detected);
-                    });
-                });
-            }
-        });
-    }
-    stopScan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'stopping scan ..' });
-            if (!this.activeScan)
-                return false;
-            const channel = this.activeScan;
-            try {
-                const stopped = yield channel.stopScanner();
-                this.activeScan = undefined;
-                this.logEvent({ message: 'scan stopped' });
-                return stopped;
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'stopScan()', error: err.message, stack: err.stack });
-                return false;
-            }
-        });
-    }
-    startSensor(sensor, onDeviceData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isConnected()) {
-                const connected = yield this.connect();
-                if (!connected)
-                    return false;
-            }
-            let channel;
-            channel = this.device.getChannel();
-            channel.setProps({ logger: this.logger });
-            if (!channel)
-                return false;
-            channel.on('data', this.onData.bind(this));
-            sensor.setChannel(channel);
-            this.on('data', (profile, deviceID, data) => {
-                if (profile === sensor.getProfile() && deviceID === sensor.getDeviceID())
-                    onDeviceData(data);
-            });
-            try {
-                return yield channel.startSensor(sensor);
-            }
-            catch (err) {
-                this.logEvent({ message: 'could not start sensor', error: err.message || err, stack: err.stack });
-                try {
-                    yield channel.stopSensor(sensor);
-                }
-                catch (_a) { }
-                return false;
-            }
-        });
-    }
-    stopSensor(sensor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isConnected() || !this.device) {
-                return true;
-            }
-            const channel = sensor.getChannel();
-            if (channel) {
-                try {
-                    if (!channel.flush) {
-                        this.logEvent({ message: 'old version of ant-channel detected' });
-                        channel.flush = () => {
-                            const c = channel;
-                            c.messageQueue.forEach(msg => { msg.resolve(false); });
-                            c.messageQueue = [];
-                            c.isWriting = false;
-                        };
-                    }
-                    channel.flush();
-                    channel.removeAllListeners('data');
-                    const stopped = yield channel.stopSensor(sensor);
-                    return stopped;
-                }
-                catch (err) {
-                    this.logEvent({ message: 'could not stop sensor', error: err.message || err, deviceID: sensor.getDeviceID(), stack: err.stack });
-                    return false;
-                }
-            }
-            else {
-                this.logEvent({ message: 'could not stop sensor', deviceID: sensor.getDeviceID(), error: 'no channel attached' });
-                return false;
-            }
-        });
-    }
-    isScanning() {
-        return (this.activeScan === undefined || this.activeScan === null);
-    }
-}
-AntInterface._instance = undefined;
-AntInterface.INTERFACE_NAME = 'ant';
-exports.default = AntInterface;

package/lib/antv2/binding.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="node" />
-import { IAntDevice, IChannel } from 'incyclist-ant-plus';
-import { AntInterfaceProps } from './ant-interface';
-export default class AntDeviceBinding implements IAntDevice {
-    constructor(_props: AntInterfaceProps);
-    open(): Promise<boolean>;
-    close(): Promise<boolean>;
-    getMaxChannels(): number;
-    getChannel(): IChannel;
-    freeChannel(channel: IChannel): void;
-    getDeviceNumber(): number;
-    write(data: Buffer): void;
-}

package/lib/antv2/binding.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class AntDeviceBinding {
-    constructor(_props) { }
-    open() {
-        throw new Error('Method not implemented.');
-    }
-    close() {
-        throw new Error('Method not implemented.');
-    }
-    getMaxChannels() {
-        throw new Error('Method not implemented.');
-    }
-    getChannel() {
-        throw new Error('Method not implemented.');
-    }
-    freeChannel(channel) {
-        throw new Error('Method not implemented.');
-    }
-    getDeviceNumber() {
-        throw new Error('Method not implemented.');
-    }
-    write(data) {
-        throw new Error('Method not implemented.');
-    }
-}
-exports.default = AntDeviceBinding;

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

@@ -1,11 +0,0 @@
-import { HeartRateSensorState, Profile } from "incyclist-ant-plus";
-import AntAdapter from "../base/adapter";
-import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
-export default class AntHrAdapter extends AntAdapter<HeartRateSensorState> {
-    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
-    protected static ANT_PROFILE_NAME: Profile;
-    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    getDisplayName(): string;
-    mapToAdapterData(deviceData: HeartRateSensorState): void;
-    hasData(): boolean;
-}

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

@@ -1,30 +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("../base/adapter"));
-const types_1 = require("../../types");
-class AntHrAdapter extends adapter_1.default {
-    constructor(settings, props) {
-        super(settings, props);
-        this.capabilities = [types_1.IncyclistCapability.HeartRate];
-    }
-    getDisplayName() {
-        const { ComputedHeartRate } = this.deviceData;
-        const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
-        return `${this.getUniqueName()}${hrmStr}`;
-    }
-    mapToAdapterData(deviceData) {
-        if (deviceData.ComputedHeartRate) {
-            this.data.heartrate = deviceData.ComputedHeartRate;
-            this.data.timestamp = Date.now();
-        }
-    }
-    hasData() {
-        return this.deviceData.ComputedHeartRate !== undefined && this.deviceData.ComputedHeartRate !== null;
-    }
-}
-AntHrAdapter.INCYCLIST_PROFILE_NAME = 'Heartrate Monitor';
-AntHrAdapter.ANT_PROFILE_NAME = 'HR';
-exports.default = AntHrAdapter;

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;
-}