incyclist-devices 1.5.11 → 1.5.12

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

@@ -1,37 +1,37 @@
-/// <reference types="node" />
-import EventEmitter from "events";
-import { EventLogger } from "gd-eventlog";
-import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
-import AntDeviceBinding from "./ant-binding";
-import { AntScannerProps } from "./incyclist-protocol";
-export declare type AntInterfaceProps = {
-    binding?: typeof AntDeviceBinding;
-    logger?: EventLogger;
-    startupTimeout?: number;
-};
-export default class AntInterface extends EventEmitter {
-    static _instance: AntInterface;
-    static getInstance(props?: AntInterfaceProps): AntInterface;
-    static hasInstance(): boolean;
-    protected logger: EventLogger;
-    protected device: IAntDevice;
-    protected Binding: typeof AntDeviceBinding;
-    protected isConnected: boolean;
-    protected isConnecting: boolean;
-    protected props: AntInterfaceProps;
-    protected activeScan: IChannel;
-    constructor(props: AntInterfaceProps);
-    getBinding(): typeof AntDeviceBinding;
-    setBinding(binding: typeof AntDeviceBinding): void;
-    setLogger(logger: EventLogger): void;
-    logEvent(event: any): void;
-    connect(): Promise<unknown>;
-    disconnect(): Promise<boolean>;
-    onError(profile: any, error: any): void;
-    onData(profile: any, id: any, data: any, tag: any): void;
-    scan(props?: AntScannerProps): Promise<unknown>;
-    stopScan(): Promise<boolean>;
-    startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
-    stopSensor(sensor: ISensor): Promise<boolean>;
-    isScanning(): boolean;
-}
+/// <reference types="node" />
+import EventEmitter from "events";
+import { EventLogger } from "gd-eventlog";
+import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
+import AntDeviceBinding from "./ant-binding";
+import { AntScannerProps } from "./incyclist-protocol";
+export declare type AntInterfaceProps = {
+    binding?: typeof AntDeviceBinding;
+    logger?: EventLogger;
+    startupTimeout?: number;
+};
+export default class AntInterface extends EventEmitter {
+    static _instance: AntInterface;
+    static getInstance(props?: AntInterfaceProps): AntInterface;
+    static hasInstance(): boolean;
+    protected logger: EventLogger;
+    protected device: IAntDevice;
+    protected Binding: typeof AntDeviceBinding;
+    protected isConnected: boolean;
+    protected isConnecting: boolean;
+    protected props: AntInterfaceProps;
+    protected activeScan: IChannel;
+    constructor(props: AntInterfaceProps);
+    getBinding(): typeof AntDeviceBinding;
+    setBinding(binding: typeof AntDeviceBinding): void;
+    setLogger(logger: EventLogger): void;
+    logEvent(event: any): void;
+    connect(): Promise<unknown>;
+    disconnect(): Promise<boolean>;
+    onError(profile: any, error: any): void;
+    onData(profile: any, id: any, data: any, tag: any): void;
+    scan(props?: AntScannerProps): Promise<unknown>;
+    stopScan(): Promise<boolean>;
+    startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
+    stopSensor(sensor: ISensor): Promise<boolean>;
+    isScanning(): boolean;
+}

package/lib/antv2/ant-interface.js

@@ -1,255 +1,255 @@
-"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("./sensor-factory"));
-class AntInterface extends events_1.default {
-    constructor(props) {
-        super();
-        this.props = props;
-        this.device = undefined;
-        this.isConnected = false;
-        this.isConnecting = false;
-        const { binding, logger } = props;
-        if (logger)
-            this.logger = logger;
-        else {
-            this.logger = new gd_eventlog_1.EventLogger('Ant+');
-        }
-        if (binding) {
-            this.Binding = binding;
-        }
-    }
-    static getInstance(props = {}) {
-        if (AntInterface._instance === undefined)
-            AntInterface._instance = new AntInterface(props);
-        return AntInterface._instance;
-    }
-    static hasInstance() {
-        return AntInterface._instance !== undefined;
-    }
-    getBinding() {
-        return this.Binding;
-    }
-    setBinding(binding) {
-        this.Binding = binding;
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    logEvent(event) {
-        if (this.logger)
-            this.logger.logEvent(event);
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isConnected)
-                return true;
-            if (!this.isConnecting) {
-                this.isConnecting = 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: 'could not connect' });
-                        this.isConnecting = false;
-                        return false;
-                    }
-                    this.device = device;
-                    this.isConnected = true;
-                    this.isConnecting = false;
-                    this.logEvent({ message: 'ANT+ connected' });
-                    return true;
-                }
-                catch (err) {
-                    this.isConnected = false;
-                    this.isConnecting = false;
-                    return false;
-                }
-            }
-            else {
-                return new Promise(resolve => {
-                    setInterval(() => {
-                        if (!this.isConnecting)
-                            resolve(this.isConnected);
-                    }, 500);
-                });
-            }
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device)
-                return true;
-            this.logEvent({ message: 'disconnecting ...' });
-            const closed = yield this.device.close();
-            this.isConnected = !closed;
-            this.logEvent({ message: '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 = [];
-            if (!this.isConnected) {
-                const connected = yield this.connect();
-                if (!connected)
-                    return [];
-            }
-            const onDetected = (profile, deviceID) => {
-                if (deviceID && detected.find(s => s.deviceID === deviceID && s.profile === profile) === undefined) {
-                    try {
-                        detected.push({ profile, deviceID });
-                        this.emit('detected', profile, deviceID);
-                    }
-                    catch (err) {
-                        this.logEvent({ message: 'error', fn: 'onDerected', error: err.message, stack: err.stack });
-                    }
-                }
-            };
-            let channel;
-            if (!this.activeScan) {
-                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) {
-                console.log('ERROR', err);
-                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();
-            channel.removeAllListeners('data');
-            if (channel) {
-                try {
-                    return yield channel.stopSensor(sensor);
-                }
-                catch (err) {
-                    this.logEvent({ message: 'could not stop sensor', error: err.message || err, stack: err.stack });
-                    return false;
-                }
-            }
-        });
-    }
-    isScanning() {
-        return (this.activeScan === undefined || this.activeScan === null);
-    }
-}
-exports.default = AntInterface;
-AntInterface._instance = undefined;
+"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("./sensor-factory"));
+class AntInterface extends events_1.default {
+    constructor(props) {
+        super();
+        this.props = props;
+        this.device = undefined;
+        this.isConnected = false;
+        this.isConnecting = false;
+        const { binding, logger } = props;
+        if (logger)
+            this.logger = logger;
+        else {
+            this.logger = new gd_eventlog_1.EventLogger('Ant+');
+        }
+        if (binding) {
+            this.Binding = binding;
+        }
+    }
+    static getInstance(props = {}) {
+        if (AntInterface._instance === undefined)
+            AntInterface._instance = new AntInterface(props);
+        return AntInterface._instance;
+    }
+    static hasInstance() {
+        return AntInterface._instance !== undefined;
+    }
+    getBinding() {
+        return this.Binding;
+    }
+    setBinding(binding) {
+        this.Binding = binding;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    logEvent(event) {
+        if (this.logger)
+            this.logger.logEvent(event);
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected)
+                return true;
+            if (!this.isConnecting) {
+                this.isConnecting = 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: 'could not connect' });
+                        this.isConnecting = false;
+                        return false;
+                    }
+                    this.device = device;
+                    this.isConnected = true;
+                    this.isConnecting = false;
+                    this.logEvent({ message: 'ANT+ connected' });
+                    return true;
+                }
+                catch (err) {
+                    this.isConnected = false;
+                    this.isConnecting = false;
+                    return false;
+                }
+            }
+            else {
+                return new Promise(resolve => {
+                    setInterval(() => {
+                        if (!this.isConnecting)
+                            resolve(this.isConnected);
+                    }, 500);
+                });
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.device)
+                return true;
+            this.logEvent({ message: 'disconnecting ...' });
+            const closed = yield this.device.close();
+            this.isConnected = !closed;
+            this.logEvent({ message: '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 = [];
+            if (!this.isConnected) {
+                const connected = yield this.connect();
+                if (!connected)
+                    return [];
+            }
+            const onDetected = (profile, deviceID) => {
+                if (deviceID && detected.find(s => s.deviceID === deviceID && s.profile === profile) === undefined) {
+                    try {
+                        detected.push({ profile, deviceID });
+                        this.emit('detected', profile, deviceID);
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'error', fn: 'onDerected', error: err.message, stack: err.stack });
+                    }
+                }
+            };
+            let channel;
+            if (!this.activeScan) {
+                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) {
+                console.log('ERROR', err);
+                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();
+            channel.removeAllListeners('data');
+            if (channel) {
+                try {
+                    return yield channel.stopSensor(sensor);
+                }
+                catch (err) {
+                    this.logEvent({ message: 'could not stop sensor', error: err.message || err, stack: err.stack });
+                    return false;
+                }
+            }
+        });
+    }
+    isScanning() {
+        return (this.activeScan === undefined || this.activeScan === null);
+    }
+}
+exports.default = AntInterface;
+AntInterface._instance = undefined;

package/lib/antv2/fe.d.ts

@@ -1,29 +1,29 @@
-import { ISensor } from "incyclist-ant-plus";
-import AntAdapter from "./ant-device";
-import AntProtocol from "./incyclist-protocol";
-import { EventLogger } from "gd-eventlog";
-import CyclingMode, { IncyclistBikeData } from '../cycling-mode';
-export default class AntFEAdapter extends AntAdapter {
-    protected started: boolean;
-    protected logger: EventLogger;
-    protected cyclingMode: CyclingMode;
-    protected distanceInternal?: number;
-    protected msgCount: number;
-    constructor(sensor: ISensor, protocol: AntProtocol);
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-    getName(): string;
-    getDisplayName(): string;
-    getSupportedCyclingModes(): Array<any>;
-    setCyclingMode(mode: string | CyclingMode, settings?: any): void;
-    getCyclingMode(): CyclingMode;
-    getDefaultCyclingMode(): CyclingMode;
-    getLogData(data: any, excludeList: any): any;
-    sendUpdate(request: any): Promise<void>;
-    onDeviceData(deviceData: any): void;
-    mapData(deviceData: any): IncyclistBikeData;
-    transformData(bikeData: any): any;
-    start(props?: any): Promise<any>;
-    stop(): Promise<boolean>;
-}
+import { ISensor } from "incyclist-ant-plus";
+import AntAdapter from "./ant-device";
+import AntProtocol from "./incyclist-protocol";
+import { EventLogger } from "gd-eventlog";
+import CyclingMode, { IncyclistBikeData } from '../cycling-mode';
+export default class AntFEAdapter extends AntAdapter {
+    protected started: boolean;
+    protected logger: EventLogger;
+    protected cyclingMode: CyclingMode;
+    protected distanceInternal?: number;
+    protected msgCount: number;
+    constructor(sensor: ISensor, protocol: AntProtocol);
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    getName(): string;
+    getDisplayName(): string;
+    getSupportedCyclingModes(): Array<any>;
+    setCyclingMode(mode: string | CyclingMode, settings?: any): void;
+    getCyclingMode(): CyclingMode;
+    getDefaultCyclingMode(): CyclingMode;
+    getLogData(data: any, excludeList: any): any;
+    sendUpdate(request: any): Promise<void>;
+    onDeviceData(deviceData: any): void;
+    mapData(deviceData: any): IncyclistBikeData;
+    transformData(bikeData: any): any;
+    start(props?: any): Promise<any>;
+    stop(): Promise<boolean>;
+}