incyclist-devices 2.3.10 → 2.3.12

package/lib/ble/peripheral-cache.js

@@ -1,109 +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 ble_peripheral_1 = __importDefault(require("./ble-peripheral"));
-class BlePeripheralCache {
-    constructor() {
-        this.peripherals = [];
-    }
-    findAdapter(adapter) {
-        return this.find(adapter.getSettings());
-    }
-    getConnector(peripheral) {
-        if (!peripheral)
-            return;
-        const info = this.find({ address: peripheral.address });
-        if (!info) {
-            const item = this.add({ address: peripheral.address, ts: Date.now(), peripheral });
-            return item.connector;
-        }
-        return info.connector;
-    }
-    getPeripheral(query) {
-        const info = this.find(query);
-        return info ? info.peripheral : undefined;
-    }
-    handleStopScan() {
-        const ongoing = this.peripherals.filter(i => i.state && i.state.isLoading);
-        if (ongoing)
-            ongoing.forEach(i => { i.state.isInterrupted = true; });
-    }
-    find(query) {
-        const { peripheral } = query;
-        const { name, address, id } = peripheral ? peripheral : query;
-        if (!name && !address && !id)
-            throw new Error('illegal query, one of <id>,<name>,<address> needs to be provided');
-        if (address)
-            return this.peripherals.find(i => i.address === address);
-        else if (name)
-            return this.peripherals.find(i => i.name === name);
-        else if (id)
-            return this.peripherals.find(i => i.id === id);
-    }
-    filter(services) {
-        if (services.length === 0) {
-            return this.peripherals;
-        }
-        return this.peripherals.filter(i => {
-            const announced = i.peripheral.services.map(s => s.uuid);
-            const requested = services;
-            return (announced.find(s => requested.includes(s)));
-        });
-    }
-    _findIndex(query) {
-        const { name, address, id } = query;
-        if (!name && !address && !id)
-            throw new Error('illegal query, one of <id>,<name>,<address> needs to be provided');
-        if (address)
-            return this.peripherals.findIndex(i => i.address === address);
-        else if (name)
-            return this.peripherals.findIndex(i => i.name === name);
-        else if (id)
-            return this.peripherals.findIndex(i => i.id === id);
-    }
-    add(item) {
-        const { address, name, id } = item;
-        const { ts, peripheral, state, characteristics } = item;
-        const cachedItem = this.find({ address, name, id });
-        if (cachedItem) {
-            cachedItem.ts = ts;
-            cachedItem.peripheral = peripheral;
-            if (state)
-                cachedItem.state = state;
-            if (characteristics) {
-                cachedItem.characteristics = characteristics;
-            }
-            if (!cachedItem.connector) {
-                cachedItem.connector = item.connector || new ble_peripheral_1.default(cachedItem.peripheral);
-            }
-            return cachedItem;
-        }
-        else {
-            const newItem = Object.assign({}, item);
-            if (newItem.peripheral && !newItem.connector)
-                newItem.connector = new ble_peripheral_1.default(item.peripheral);
-            this.peripherals.push(newItem);
-            return newItem;
-        }
-    }
-    remove(query) {
-        const item = query;
-        const isCacheItem = item.peripheral !== undefined;
-        let cachedItemIdx;
-        if (isCacheItem) {
-            const { address, name, id } = item;
-            cachedItemIdx = this._findIndex({ address, name, id });
-        }
-        else {
-            const peripheral = query;
-            const { address } = peripheral;
-            cachedItemIdx = this._findIndex({ address });
-        }
-        if (cachedItemIdx === -1)
-            return;
-        this.peripherals.splice(cachedItemIdx);
-    }
-}
-exports.default = BlePeripheralCache;

package/lib/ble/tacx/comms.d.ts

@@ -1,59 +0,0 @@
-import { LegacyProfile } from "../../antv2/types";
-import { CrankData } from "../cp";
-import { IndoorBikeData } from "../fm";
-import BleFitnessMachineDevice from "../fm/comms";
-import { BleProtocol, IBlePeripheralConnector } from "../types";
-import { BleFeBikeData } from "./types";
-export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {
-    static protocol: BleProtocol;
-    static services: string[];
-    static characteristics: string[];
-    static PROFILE: string;
-    static detectionPriority: number;
-    prevCrankData: CrankData;
-    currentCrankData: CrankData;
-    timeOffset: number;
-    tsPrevWrite: any;
-    data: BleFeBikeData;
-    hasFECData: boolean;
-    messageCnt: number;
-    tacxRx: string;
-    tacxTx: string;
-    constructor(props?: any);
-    static isMatching(characteristics: string[]): boolean;
-    setCharacteristicUUIDs(uuids: string[]): void;
-    subscribeAll(conn?: IBlePeripheralConnector): Promise<void>;
-    init(): Promise<boolean>;
-    getProfile(): LegacyProfile;
-    getProtocol(): BleProtocol;
-    getServiceUUids(): string[];
-    requestControl(): Promise<boolean>;
-    parseCrankData(crankData: any): {
-        rpm?: undefined;
-        time?: undefined;
-    } | {
-        rpm: number;
-        time: any;
-    };
-    parseCSC(_data: Buffer, logOnly?: boolean): IndoorBikeData;
-    parsePower(_data: Buffer, logOnly?: boolean): IndoorBikeData;
-    parseIndoorBikeData(_data: Buffer, logOnly?: boolean): IndoorBikeData;
-    resetState(): void;
-    parseFEState(capStateBF: number): void;
-    parseGeneralFE(data: Buffer): BleFeBikeData;
-    parseTrainerData(data: Buffer): BleFeBikeData;
-    parseProductInformation(data: Buffer): BleFeBikeData;
-    parseFECMessage(_data: Buffer): BleFeBikeData;
-    onData(characteristic: string, data: Buffer): boolean;
-    getChecksum(message: any[]): number;
-    buildMessage(payload?: number[], msgID?: number): Buffer;
-    sendMessage(message: Buffer): Promise<boolean>;
-    sendUserConfiguration(userWeight: any, bikeWeight: any, wheelDiameter: any, gearRatio: any): Promise<boolean>;
-    sendBasicResistance(resistance: any): Promise<boolean>;
-    sendTargetPower(power: any): Promise<boolean>;
-    sendWindResistance(windCoeff: any, windSpeed: any, draftFactor: any): Promise<boolean>;
-    sendTrackResistance(slope: any, rrCoeff?: any): Promise<boolean>;
-    setTargetPower(power: number): Promise<boolean>;
-    setSlope(slope: any): Promise<boolean>;
-    reset(): void;
-}