incyclist-devices 1.5.10 → 1.5.12

package/lib/antv2/AntAdapter.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_UPDATE_FREQUENCY = void 0;
+const device_1 = __importDefault(require("../device"));
+const device_2 = require("../device");
+const ant_interface_1 = __importDefault(require("./ant-interface"));
+const incyclist_protocol_1 = require("./incyclist-protocol");
+exports.DEFAULT_UPDATE_FREQUENCY = 1000;
+class AntAdapter extends device_1.default {
+    constructor(sensor, protocol) {
+        super(protocol);
+        this.paused = false;
+        this.stopped = false;
+        this.ignoreHrm = false;
+        this.ignoreBike = false;
+        this.ignorePower = false;
+        this.deviceData = {};
+        this.data = {};
+        this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
+        this.ant = ant_interface_1.default.getInstance();
+        this.sensor = sensor;
+        this.onData = this.onDeviceData.bind(this);
+    }
+    isSame(device) {
+        if (!(device instanceof AntAdapter))
+            return false;
+        const adapter = device;
+        return (adapter.getID() === this.getID() && adapter.getProfile() === this.getProfile());
+    }
+    setSensor(sensor) {
+        this.sensor = sensor;
+    }
+    getID() {
+        return this.sensor.getDeviceID().toString();
+    }
+    setIgnoreHrm(ignore) {
+        this.ignoreHrm = ignore;
+    }
+    setIgnoreBike(ignore) {
+        this.ignoreBike = ignore;
+    }
+    setIgnorePower(ignore) {
+        this.ignorePower = ignore;
+    }
+    getProfile() {
+        return (0, incyclist_protocol_1.mapAntProfile)(this.sensor.getProfile());
+    }
+    getPort() {
+        return 'ant';
+    }
+    getWeight() {
+        let userWeight = device_2.DEFAULT_USER_WEIGHT;
+        let bikeWeight = device_2.DEFAULT_BIKE_WEIGHT;
+        if (this.userSettings && this.userSettings.weight) {
+            userWeight = Number(this.userSettings.weight);
+        }
+        if (this.bikeSettings && this.bikeSettings.weight) {
+            bikeWeight = Number(this.bikeSettings.weight);
+        }
+        return bikeWeight + userWeight;
+    }
+    isStopped() {
+        return this.stopped;
+    }
+    onDeviceData(data) { }
+    onDeviceEvent(data) { }
+    onAttached() { }
+    update() { }
+    check() { }
+    connect() { }
+    close() { }
+    pause() {
+        return new Promise(resolve => {
+            this.paused = true;
+            resolve(true);
+        });
+    }
+    resume() {
+        return new Promise(resolve => {
+            this.paused = false;
+            resolve(true);
+        });
+    }
+    start(props) {
+        if (props && props.user)
+            this.userSettings = props.user;
+        if (props && props.bikeSettings)
+            this.bikeSettings = props.bikeSettings;
+        return new Promise(resolve => {
+            this.stopped = false;
+            resolve(true);
+        });
+    }
+    stop() {
+        return new Promise(resolve => {
+            this.stopped = true;
+            resolve(true);
+        });
+    }
+}
+exports.default = AntAdapter;

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

@@ -1,11 +1,11 @@
-import AntProtocol, { AntDeviceSettings } from "./incyclist-protocol";
-import AntAdapter from "./ant-device";
-export default class AdapterFactory {
-    static create(settings: {
-        configuration?: AntDeviceSettings;
-        detected?: {
-            profile: string;
-            deviceID: number;
-        };
-    }, protocol: AntProtocol): AntAdapter;
-}
+import AntProtocol, { AntDeviceSettings } from "./incyclist-protocol";
+import AntAdapter from "./ant-device";
+export default class AdapterFactory {
+    static create(settings: {
+        configuration?: AntDeviceSettings;
+        detected?: {
+            profile: string;
+            deviceID: number;
+        };
+    }, protocol: AntProtocol): AntAdapter;
+}

package/lib/antv2/adapter-factory.js

@@ -1,40 +1,40 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const incyclist_protocol_1 = require("./incyclist-protocol");
-const fe_1 = __importDefault(require("./fe"));
-const hr_1 = __importDefault(require("./hr"));
-const pwr_1 = __importDefault(require("./pwr"));
-const sensor_factory_1 = __importDefault(require("./sensor-factory"));
-const profiles = [
-    { profile: 'PWR', Class: pwr_1.default },
-    { profile: 'HR', Class: hr_1.default },
-    { profile: 'FE', Class: fe_1.default },
-];
-class AdapterFactory {
-    static create(settings, protocol) {
-        let profile;
-        let deviceID;
-        if (settings && settings.configuration) {
-            profile = (0, incyclist_protocol_1.mapIncyclistProfile)(settings.configuration.profile);
-            deviceID = settings.configuration.deviceID;
-        }
-        else if (settings && settings.detected) {
-            profile = settings.detected.profile;
-            deviceID = settings.detected.deviceID;
-        }
-        else {
-            return;
-        }
-        const sensor = sensor_factory_1.default.create(profile, Number(deviceID));
-        if (sensor) {
-            const info = profiles.find(i => i.profile === profile);
-            if (!info)
-                return;
-            return new info.Class(sensor, protocol);
-        }
-    }
-}
-exports.default = AdapterFactory;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const incyclist_protocol_1 = require("./incyclist-protocol");
+const fe_1 = __importDefault(require("./fe"));
+const hr_1 = __importDefault(require("./hr"));
+const pwr_1 = __importDefault(require("./pwr"));
+const sensor_factory_1 = __importDefault(require("./sensor-factory"));
+const profiles = [
+    { profile: 'PWR', Class: pwr_1.default },
+    { profile: 'HR', Class: hr_1.default },
+    { profile: 'FE', Class: fe_1.default },
+];
+class AdapterFactory {
+    static create(settings, protocol) {
+        let profile;
+        let deviceID;
+        if (settings && settings.configuration) {
+            profile = (0, incyclist_protocol_1.mapIncyclistProfile)(settings.configuration.profile);
+            deviceID = settings.configuration.deviceID;
+        }
+        else if (settings && settings.detected) {
+            profile = settings.detected.profile;
+            deviceID = settings.detected.deviceID;
+        }
+        else {
+            return;
+        }
+        const sensor = sensor_factory_1.default.create(profile, Number(deviceID));
+        if (sensor) {
+            const info = profiles.find(i => i.profile === profile);
+            if (!info)
+                return;
+            return new info.Class(sensor, protocol);
+        }
+    }
+}
+exports.default = AdapterFactory;

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

@@ -1,13 +1,13 @@
-/// <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;
-}
+/// <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/ant-binding.js

@@ -1,27 +1,27 @@
-"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;
+"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/ant-device.d.ts

@@ -1,51 +1,51 @@
-import { Device } from '../protocol';
-import { IChannel, ISensor } from 'incyclist-ant-plus';
-import AntProtocol from './incyclist-protocol';
-import AntInterface from './ant-interface';
-import IncyclistDevice, { DeviceAdapter, OnDeviceDataCallback } from '../device';
-export declare const DEFAULT_UPDATE_FREQUENCY = 1000;
-export default class AntAdapter extends IncyclistDevice implements Device {
-    sensor: ISensor;
-    protocol: AntProtocol;
-    ignoreHrm: boolean;
-    ignoreBike: boolean;
-    ignorePower: boolean;
-    lastUpdate?: number;
-    data: any;
-    deviceData: any;
-    updateFrequency: number;
-    channel: IChannel;
-    ant: AntInterface;
-    stopped: boolean;
-    paused: boolean;
-    userSettings: {
-        weight?: number;
-    };
-    bikeSettings: {
-        weight?: number;
-    };
-    detected: boolean;
-    selected: boolean;
-    settings: any;
-    onDataFn: OnDeviceDataCallback;
-    constructor(sensor: ISensor, protocol: AntProtocol, settings?: any);
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
-    getDisplayName(): string;
-    isSame(device: DeviceAdapter): boolean;
-    getID(): string;
-    getName(): string;
-    getProfile(): string;
-    getPort(): string;
-    getProtocol(): AntProtocol;
-    getProtocolName(): string;
-    setIgnoreHrm(ignore: any): void;
-    setIgnoreBike(ignore: any): void;
-    setIgnorePower(ignore: any): void;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-    start(props?: any): Promise<any>;
-    stop(): Promise<boolean>;
-    isStopped(): boolean;
-}
+import { Device } from '../protocol';
+import { IChannel, ISensor } from 'incyclist-ant-plus';
+import AntProtocol from './incyclist-protocol';
+import AntInterface from './ant-interface';
+import IncyclistDevice, { DeviceAdapter, OnDeviceDataCallback } from '../device';
+export declare const DEFAULT_UPDATE_FREQUENCY = 1000;
+export default class AntAdapter extends IncyclistDevice implements Device {
+    sensor: ISensor;
+    protocol: AntProtocol;
+    ignoreHrm: boolean;
+    ignoreBike: boolean;
+    ignorePower: boolean;
+    lastUpdate?: number;
+    data: any;
+    deviceData: any;
+    updateFrequency: number;
+    channel: IChannel;
+    ant: AntInterface;
+    stopped: boolean;
+    paused: boolean;
+    userSettings: {
+        weight?: number;
+    };
+    bikeSettings: {
+        weight?: number;
+    };
+    detected: boolean;
+    selected: boolean;
+    settings: any;
+    onDataFn: OnDeviceDataCallback;
+    constructor(sensor: ISensor, protocol: AntProtocol, settings?: any);
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    getDisplayName(): string;
+    isSame(device: DeviceAdapter): boolean;
+    getID(): string;
+    getName(): string;
+    getProfile(): string;
+    getPort(): string;
+    getProtocol(): AntProtocol;
+    getProtocolName(): string;
+    setIgnoreHrm(ignore: any): void;
+    setIgnoreBike(ignore: any): void;
+    setIgnorePower(ignore: any): void;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    start(props?: any): Promise<any>;
+    stop(): Promise<boolean>;
+    isStopped(): boolean;
+}

package/lib/antv2/ant-device.js

@@ -1,115 +1,115 @@
-"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.DEFAULT_UPDATE_FREQUENCY = void 0;
-const incyclist_protocol_1 = require("./incyclist-protocol");
-const ant_interface_1 = __importDefault(require("./ant-interface"));
-const device_1 = __importDefault(require("../device"));
-exports.DEFAULT_UPDATE_FREQUENCY = 1000;
-class AntAdapter extends device_1.default {
-    constructor(sensor, protocol, settings) {
-        super(protocol, settings);
-        this.sensor = sensor;
-        this.protocol = protocol;
-        this.ignoreHrm = false;
-        this.ignoreBike = false;
-        this.ignorePower = false;
-        this.deviceData = {};
-        this.data = {};
-        this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
-        this.channel = undefined;
-        this.paused = false;
-        this.stopped = false;
-        this.ant = ant_interface_1.default.getInstance();
-    }
-    isBike() {
-        throw new Error('Method not implemented.');
-    }
-    isPower() {
-        throw new Error('Method not implemented.');
-    }
-    isHrm() {
-        throw new Error('Method not implemented.');
-    }
-    getDisplayName() {
-        throw new Error('Method not implemented.');
-    }
-    isSame(device) {
-        if (!(device instanceof AntAdapter))
-            return false;
-        const adapter = device;
-        return (adapter.getID() === this.getID() && adapter.getProfile() === this.getProfile());
-    }
-    getID() {
-        return this.sensor.getDeviceID().toString();
-    }
-    getName() {
-        const deviceID = this.sensor.getDeviceID();
-        const profile = this.sensor.getProfile();
-        return `Ant+${profile} ${deviceID}`;
-    }
-    getProfile() {
-        return (0, incyclist_protocol_1.mapAntProfile)(this.sensor.getProfile());
-    }
-    getPort() {
-        return undefined;
-    }
-    getProtocol() {
-        return this.protocol;
-    }
-    getProtocolName() {
-        return this.protocol.getName();
-    }
-    setIgnoreHrm(ignore) {
-        this.ignoreHrm = ignore;
-    }
-    setIgnoreBike(ignore) {
-        this.ignoreBike = ignore;
-    }
-    setIgnorePower(ignore) {
-        this.ignorePower = ignore;
-    }
-    pause() {
-        return new Promise(resolve => {
-            this.paused = true;
-            resolve(true);
-        });
-    }
-    resume() {
-        return new Promise(resolve => {
-            this.paused = false;
-            resolve(true);
-        });
-    }
-    start(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (props && props.user)
-                this.userSettings = props.user;
-            if (props && props.bikeSettings)
-                this.bikeSettings = props.bikeSettings;
-            this.stopped = false;
-            return true;
-        });
-    }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.stopped = true;
-            return true;
-        });
-    }
-    isStopped() {
-        return this.stopped;
-    }
-}
-exports.default = AntAdapter;
+"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.DEFAULT_UPDATE_FREQUENCY = void 0;
+const incyclist_protocol_1 = require("./incyclist-protocol");
+const ant_interface_1 = __importDefault(require("./ant-interface"));
+const device_1 = __importDefault(require("../device"));
+exports.DEFAULT_UPDATE_FREQUENCY = 1000;
+class AntAdapter extends device_1.default {
+    constructor(sensor, protocol, settings) {
+        super(protocol, settings);
+        this.sensor = sensor;
+        this.protocol = protocol;
+        this.ignoreHrm = false;
+        this.ignoreBike = false;
+        this.ignorePower = false;
+        this.deviceData = {};
+        this.data = {};
+        this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
+        this.channel = undefined;
+        this.paused = false;
+        this.stopped = false;
+        this.ant = ant_interface_1.default.getInstance();
+    }
+    isBike() {
+        throw new Error('Method not implemented.');
+    }
+    isPower() {
+        throw new Error('Method not implemented.');
+    }
+    isHrm() {
+        throw new Error('Method not implemented.');
+    }
+    getDisplayName() {
+        throw new Error('Method not implemented.');
+    }
+    isSame(device) {
+        if (!(device instanceof AntAdapter))
+            return false;
+        const adapter = device;
+        return (adapter.getID() === this.getID() && adapter.getProfile() === this.getProfile());
+    }
+    getID() {
+        return this.sensor.getDeviceID().toString();
+    }
+    getName() {
+        const deviceID = this.sensor.getDeviceID();
+        const profile = this.sensor.getProfile();
+        return `Ant+${profile} ${deviceID}`;
+    }
+    getProfile() {
+        return (0, incyclist_protocol_1.mapAntProfile)(this.sensor.getProfile());
+    }
+    getPort() {
+        return undefined;
+    }
+    getProtocol() {
+        return this.protocol;
+    }
+    getProtocolName() {
+        return this.protocol.getName();
+    }
+    setIgnoreHrm(ignore) {
+        this.ignoreHrm = ignore;
+    }
+    setIgnoreBike(ignore) {
+        this.ignoreBike = ignore;
+    }
+    setIgnorePower(ignore) {
+        this.ignorePower = ignore;
+    }
+    pause() {
+        return new Promise(resolve => {
+            this.paused = true;
+            resolve(true);
+        });
+    }
+    resume() {
+        return new Promise(resolve => {
+            this.paused = false;
+            resolve(true);
+        });
+    }
+    start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (props && props.user)
+                this.userSettings = props.user;
+            if (props && props.bikeSettings)
+                this.bikeSettings = props.bikeSettings;
+            this.stopped = false;
+            return true;
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stopped = true;
+            return true;
+        });
+    }
+    isStopped() {
+        return this.stopped;
+    }
+}
+exports.default = AntAdapter;