incyclist-devices 2.2.10-beta.0 → 2.3.0-beta.10

package/lib/direct-connect/utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyFromVal = exports.propertyVal = exports.beautifyUUID = exports.parseUUID = void 0;
+const parseUUID = (str) => {
+    const uuid = str.toUpperCase();
+    if (str.startsWith('0x')) {
+        const hex = uuid.slice(2);
+        if (hex.length === 4) {
+            return `0000${hex}00001000800000805F9B34FB`;
+        }
+        if (hex.length === 8) {
+            return `${hex}00001000800000805F9B34FB`;
+        }
+    }
+    else if (uuid.length === 4) {
+        return `0000${uuid}00001000800000805F9B34FB`;
+    }
+    else if (uuid.length === 8) {
+        return `${uuid}00001000800000805F9B34FB`;
+    }
+    else if (uuid.length === 32) {
+        return uuid;
+    }
+    else if (uuid.length === 36) {
+        return uuid.replace(/-/g, '');
+    }
+    throw new Error(`Invalid UUID: ${uuid}`);
+};
+exports.parseUUID = parseUUID;
+const beautifyUUID = (str, withX = false) => {
+    const uuid = (0, exports.parseUUID)(str);
+    const parts = [
+        uuid.substring(0, 8),
+        uuid.substring(8, 12),
+        uuid.substring(12, 16),
+        uuid.substring(16, 20),
+        uuid.substring(20),
+    ];
+    if (uuid.substring(8) === '00001000800000805F9B34FB') {
+        let short;
+        if (parts[0].startsWith('0000')) {
+            short = parts[0].substring(4);
+        }
+        else {
+            short = parts[0];
+        }
+        return withX ? `0x${short}` : short;
+    }
+    return parts.join('-');
+};
+exports.beautifyUUID = beautifyUUID;
+const propertyVal = (properties) => {
+    let res = 0;
+    if (properties.includes('read'))
+        res |= 0x01;
+    if (properties.includes('write'))
+        res |= 0x02;
+    if (properties.includes('notify'))
+        res |= 0x04;
+    return res;
+};
+exports.propertyVal = propertyVal;
+const propertyFromVal = (val) => {
+    const res = [];
+    if (val & 0x01)
+        res.push('read');
+    if (val & 0x02)
+        res.push('write');
+    if (val & 0x04)
+        res.push('notify');
+    return res;
+};
+exports.propertyFromVal = propertyFromVal;

package/lib/factories/adapters.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const antv2_1 = require("../antv2");
+const adapter_factory_1 = __importDefault(require("../antv2/factories/adapter-factory"));
 const ble_1 = require("../ble");
 const serial_1 = require("../serial");
 const Simulator_1 = require("../simulator/Simulator");
@@ -8,7 +11,8 @@ const device_1 = require("../types/device");
 class AdapterFactory {
     static reset() {
         AdapterFactory.adapters = [];
-        ble_1.BleAdapterFactory.getInstance().instances = [];
+        ble_1.BleAdapterFactory.getInstance('ble').instances = [];
+        ble_1.BleAdapterFactory.getInstance('wifi').instances = [];
     }
     static create(settings, props) {
         const adapters = AdapterFactory.adapters;
@@ -30,10 +34,16 @@ class AdapterFactory {
                 adapter = serial_1.SerialAdapterFactory.getInstance().createInstance(settings, props);
                 break;
             case device_1.INTERFACE.ANT:
-                adapter = antv2_1.AntAdapterFactory.getInstance().createInstance(settings, props);
+                adapter = adapter_factory_1.default.getInstance().createInstance(settings, props);
                 break;
             case device_1.INTERFACE.BLE:
-                adapter = ble_1.BleAdapterFactory.getInstance().createInstance(settings, props);
+                adapter = ble_1.BleAdapterFactory.getInstance('ble').createInstance(settings, props);
+                break;
+            case device_1.INTERFACE.DC:
+                {
+                    const factory = ble_1.BleAdapterFactory.getInstance('wifi');
+                    adapter = ble_1.BleAdapterFactory.getInstance('wifi').createInstance(settings, props);
+                }
                 break;
             case device_1.INTERFACE.SIMULATOR:
                 adapter = new Simulator_1.Simulator(settings, props);

package/lib/factories/interfaces.d.ts

@@ -2,6 +2,7 @@ import { InterfaceProps } from "../types/interface";
 import { SerialInterface } from "../serial";
 import AntInterface from "../antv2/base/interface";
 import { BleInterface } from "../ble";
+import DirectConnectInterface from "../direct-connect/base/interface";
 export default class InterfaceFactory {
-    static create(ifaceName: string, props?: InterfaceProps): AntInterface | BleInterface | SerialInterface;
+    static create(ifaceName: string, props?: InterfaceProps): AntInterface | BleInterface | SerialInterface | DirectConnectInterface;
 }

package/lib/factories/interfaces.js

@@ -7,20 +7,23 @@ const serial_1 = require("../serial");
 const interface_1 = __importDefault(require("../antv2/base/interface"));
 const device_1 = require("../types/device");
 const ble_1 = require("../ble");
+const interface_2 = __importDefault(require("../direct-connect/base/interface"));
 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);
+                {
+                    const serialProps = (props || {});
+                    serialProps.ifaceName = ifaceName;
+                    return serial_1.SerialInterface.getInstance(serialProps);
+                }
             case device_1.INTERFACE.ANT:
-                const antProps = props;
-                return interface_1.default.getInstance(antProps);
+                return interface_1.default.getInstance(props);
             case device_1.INTERFACE.BLE:
-                const bleProps = props;
-                return ble_1.BleInterface.getInstance(bleProps);
+                return ble_1.BleInterface.getInstance(props);
+            case device_1.INTERFACE.DC:
+                return interface_2.default.getInstance(props);
         }
     }
 }

package/lib/index.d.ts

@@ -1,15 +1,16 @@
-import { INTERFACE } from './types/device';
+import { INTERFACE, DeviceSettings, DeviceProperties } from './types/device';
 import { IncyclistInterface, InterfaceProps } from './types/interface';
 import { IncyclistCapability } from './types/capabilities';
 import { IncyclistAdapterData } from './types/data';
-import { DeviceSettings, DeviceProperties } from './types/device';
 import ICyclingMode from './modes/types';
 import calc from './utils/calculations';
 import IncyclistDevice, { IncyclistDeviceAdapter } from './base/adpater';
 import { IAdapter } from './types/adapter';
-export * from './factories';
+import AdapterFactory from './factories/adapters';
+import InterfaceFactory from './factories/interfaces';
 export * from './modes/types';
 export * from './serial';
 export * from './ble';
 export * from './antv2';
-export { IAdapter, IncyclistDevice, IncyclistDeviceAdapter, DeviceSettings, DeviceProperties, IncyclistInterface, INTERFACE, InterfaceProps, ICyclingMode, IncyclistAdapterData as DeviceData, IncyclistCapability, calc, };
+export * from './direct-connect';
+export { IAdapter, IncyclistDevice, IncyclistDeviceAdapter, DeviceSettings, DeviceProperties, AdapterFactory, InterfaceFactory, IncyclistInterface, INTERFACE, InterfaceProps, ICyclingMode, IncyclistAdapterData as DeviceData, IncyclistCapability, calc, };

package/lib/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calc = exports.IncyclistCapability = exports.INTERFACE = exports.IncyclistDevice = void 0;
+exports.calc = exports.IncyclistCapability = exports.INTERFACE = exports.InterfaceFactory = exports.AdapterFactory = exports.IncyclistDevice = void 0;
 const device_1 = require("./types/device");
 Object.defineProperty(exports, "INTERFACE", { enumerable: true, get: function () { return device_1.INTERFACE; } });
 const capabilities_1 = require("./types/capabilities");
@@ -26,8 +26,12 @@ const calculations_1 = __importDefault(require("./utils/calculations"));
 exports.calc = calculations_1.default;
 const adpater_1 = __importDefault(require("./base/adpater"));
 exports.IncyclistDevice = adpater_1.default;
-__exportStar(require("./factories"), exports);
+const adapters_1 = __importDefault(require("./factories/adapters"));
+exports.AdapterFactory = adapters_1.default;
+const interfaces_1 = __importDefault(require("./factories/interfaces"));
+exports.InterfaceFactory = interfaces_1.default;
 __exportStar(require("./modes/types"), exports);
 __exportStar(require("./serial"), exports);
 __exportStar(require("./ble"), exports);
 __exportStar(require("./antv2"), exports);
+__exportStar(require("./direct-connect"), exports);

package/lib/modes/antble-smarttrainer.d.ts

@@ -1,13 +1,7 @@
-import ICyclingMode, { CyclingModeProperyType, IVirtualShifting, UpdateRequest } from "./types";
+import ICyclingMode, { CyclingModeProperyType, UpdateRequest } from "./types";
 import PowerBasedCyclingModeBase from "./power-base";
 import { IAdapter } from "../types";
-export type GearConfigEntry = {
-    chainConfig: number[];
-    cassetteConfig: number[];
-    wheelCirc: number;
-    numGears: number;
-};
-export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode, IVirtualShifting {
+export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
     protected static config: {
         name: string;
         isSIM: boolean;
@@ -32,18 +26,10 @@ export default class SmartTrainerCyclingMode extends PowerBasedCyclingModeBase i
             options?: undefined;
         })[];
     };
-    protected gear: any;
     constructor(adapter: IAdapter, props?: any);
     getBikeInitRequest(): UpdateRequest;
     checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
     protected checkSlope(request: UpdateRequest, newRequest?: UpdateRequest): void;
     protected checkEmptyRequest(newRequest: UpdateRequest): void;
     sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
-    initGears(): Promise<number>;
-    gearUp(numGears: number): Promise<number>;
-    protected switchGear: (gear: any, prevGear: any) => number;
-    protected findBestGear(): any;
-    getCurrentGearConfig(): GearConfigEntry;
-    protected getDefaultCadence(): number;
-    protected getDefaultPower(): number;
 }

package/lib/modes/antble-smarttrainer.js

@@ -1,45 +1,13 @@
 "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 types_1 = require("./types");
 const power_base_1 = __importDefault(require("./power-base"));
-const calculations_1 = __importDefault(require("../utils/calculations"));
-const NUM_GEARS = 30;
-const GearConfig = {
-    race: { chainConfig: [34, 50], cassetteConfig: [11, 36], wheelCirc: 2125, numGears: NUM_GEARS },
-    mountain: { chainConfig: [26, 36], cassetteConfig: [10, 44], wheelCirc: 2344, numGears: NUM_GEARS },
-    triathlon: { chainConfig: [36, 52], cassetteConfig: [11, 30], wheelCirc: 2125, numGears: NUM_GEARS },
-};
 class SmartTrainerCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
-        this.switchGear = (gear, prevGear) => {
-            var _a;
-            const { chainConfig, cassetteConfig, wheelCirc, numGears } = this.getCurrentGearConfig();
-            const { pedalRpm, speed, power, slope } = (_a = this.getData()) !== null && _a !== void 0 ? _a : {};
-            const m = this.getWeight();
-            let cadence = pedalRpm !== null && pedalRpm !== void 0 ? pedalRpm : this.getDefaultCadence();
-            let currentPower = power !== null && power !== void 0 ? power : this.getDefaultPower();
-            const prevGearSpeed = calculations_1.default.calculateSpeedBike(prevGear, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
-            const targetGearSpeed = calculations_1.default.calculateSpeedBike(gear, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
-            const targetGearPower = calculations_1.default.calculatePower(m, targetGearSpeed / 3.6, 0);
-            const prevGearPower = calculations_1.default.calculatePower(m, prevGearSpeed / 3.6, 0);
-            const targetPower = currentPower + (targetGearPower - prevGearPower);
-            const slopeTarget = calculations_1.default.calculateSlope(m, targetPower, speed / 3.6);
-            console.log('Gear', gear, 'power', targetPower, 'speed', speed.toFixed(1), 'slope', slope.toFixed(1), 'virtual slope', slopeTarget.toFixed(1));
-            return slopeTarget;
-        };
         this.initLogger('SmartTrainerMode');
     }
     getBikeInitRequest() {
@@ -60,16 +28,11 @@ class SmartTrainerCyclingMode extends power_base_1.default {
             newRequest.slope = parseFloat(request.slope.toFixed(1));
             this.data.slope = newRequest.slope;
             try {
-                if (this.gear !== undefined) {
-                    const slopeTarget = this.switchGear(this.gear, this.gear);
-                    newRequest.slope = slopeTarget;
-                }
                 const slopeAdj = this.getSetting('slopeAdj');
                 if (slopeAdj !== undefined)
                     newRequest.slope = newRequest.slope * slopeAdj / 100;
             }
-            catch (err) {
-                this.logger.logEvent({ message: "error", fn: '', error: err.message, request, prev: this.prevRequest, data: this.getData() });
+            catch (_a) {
             }
         }
     }
@@ -98,66 +61,6 @@ class SmartTrainerCyclingMode extends power_base_1.default {
         }
         return newRequest;
     }
-    initGears() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.gear = this.findBestGear();
-            return this.gear;
-        });
-    }
-    gearUp(numGears) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let target = this.gear + numGears;
-            if (target > NUM_GEARS)
-                target = NUM_GEARS;
-            if (target < 1)
-                target = 1;
-            this.gear = target;
-            return this.gear;
-        });
-    }
-    findBestGear() {
-        var _a;
-        const { chainConfig, cassetteConfig, wheelCirc, numGears } = this.getCurrentGearConfig();
-        const { pedalRpm, speed, power, slope } = (_a = this.getData()) !== null && _a !== void 0 ? _a : {};
-        const m = this.getWeight();
-        let cadence = pedalRpm !== null && pedalRpm !== void 0 ? pedalRpm : this.getDefaultCadence();
-        let currentPower = power !== null && power !== void 0 ? power : this.getDefaultPower();
-        let minDiff, gearInitial;
-        if (speed === 0) {
-            const speedInitial = calculations_1.default.calculateSpeed(m, currentPower, slope);
-            for (let i = 1; i <= numGears; i++) {
-                const speed = calculations_1.default.calculateSpeedBike(i, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
-                const diff = Math.abs(speed - speedInitial);
-                if (!minDiff || diff < minDiff) {
-                    minDiff = diff;
-                    gearInitial = i;
-                }
-            }
-        }
-        else {
-            for (let i = 1; i <= numGears; i++) {
-                const speed = calculations_1.default.calculateSpeedBike(i, cadence, chainConfig, cassetteConfig, { numGears, wheelCirc });
-                const targetPower = calculations_1.default.calculatePower(m, speed / 3.6, slope);
-                const diff = Math.abs(currentPower - targetPower);
-                if (!minDiff || diff < minDiff) {
-                    minDiff = diff;
-                    gearInitial = i;
-                }
-            }
-        }
-        return gearInitial;
-    }
-    getCurrentGearConfig() {
-        var _a;
-        const type = (_a = this.getSetting('bikeType')) !== null && _a !== void 0 ? _a : 'Race';
-        return GearConfig[type.toLowerCase()];
-    }
-    getDefaultCadence() {
-        return 90;
-    }
-    getDefaultPower() {
-        return 120;
-    }
 }
 SmartTrainerCyclingMode.config = {
     name: "Smart Trainer",

package/lib/modes/types.d.ts

@@ -47,10 +47,6 @@ export default interface ICyclingMode {
     setModeProperty(name: string, value: any): void;
     getModeProperty(name: string): any;
 }
-export interface IVirtualShifting {
-    initGears(): Promise<number>;
-    gearUp(numGears: number): Promise<number>;
-}
 export type CyclingModeConfig = {
     isERG?: boolean;
     isSIM?: boolean;
@@ -73,7 +69,7 @@ export declare class CyclingMode implements ICyclingMode {
     getSetting(_name: string): void;
     getSettings(): Settings;
     setModeProperty(_name: string, _value: any): void;
-    getModeProperty(_name: string): any;
+    getModeProperty(_name: string): void;
     getConfig(): CyclingModeConfig;
     isERG(): boolean;
     isSIM(): boolean;

package/lib/serial/bindings/tcp.d.ts

@@ -6,6 +6,7 @@ export interface TCPOpenOptions extends OpenOptions {
 }
 export declare interface TCPBindingInterface<T extends BindingPortInterface = BindingPortInterface, R extends OpenOptions = OpenOptions, P extends PortInfo = PortInfo> extends BindingInterface<TCPPortBinding, TCPOpenOptions> {
     list(port?: number, excludeList?: string[]): Promise<P[]>;
+    open(options: TCPOpenOptions): Promise<TCPPortBinding>;
 }
 export declare class CanceledError extends Error {
     canceled: true;
@@ -22,10 +23,10 @@ export declare class TCPPortBinding implements BindingPortInterface {
     writeOperation: null | Promise<any>;
     data: Buffer;
     private pendingRead;
-    private onDataHandler;
-    private onErrorHandler;
-    private onTimeoutHandler;
-    private onCloseHandler;
+    private readonly onDataHandler;
+    private readonly onErrorHandler;
+    private readonly onTimeoutHandler;
+    private readonly onCloseHandler;
     constructor(socket: net.Socket, options: Required<OpenOptions>);
     get isOpen(): boolean;
     onData(data: Buffer): void;

package/lib/serial/bindings/tcp.js

@@ -55,23 +55,13 @@ function scanPort(host, port) {
 function scanSubNet(sn, port, excludeHosts) {
     const range = [];
     for (let i = 1; i < 255; i++)
-        if (!excludeHosts || !excludeHosts.includes(`${sn}.${i}`))
+        if (!(excludeHosts === null || excludeHosts === void 0 ? void 0 : excludeHosts.includes(`${sn}.${i}`)))
             range.push(i);
     return Promise.all(range.map(j => scanPort(`${sn}.${j}`, port).then(success => success ? `${sn}.${j}` : null).catch()))
         .then(hosts => hosts.filter(h => h !== null))
         .catch();
 }
 function getSubnets() {
-    const nets = (0, os_1.networkInterfaces)();
-    const results = [];
-    const names = Object.keys(nets);
-    names.forEach(name => {
-        for (const net of nets[name]) {
-            if (net.family === 'IPv4' && !net.internal) {
-                results.push(net.address);
-            }
-        }
-    });
     const address = Object.keys((0, os_1.networkInterfaces)())
         .reduce((a, key) => [
         ...a,
@@ -93,7 +83,7 @@ exports.TCPBinding = {
                 return [];
             const subnets = getSubnets();
             let hosts = [];
-            const excludeHosts = excludeList.map(e => e && e.includes(':') ? e.split(':')[0] : e);
+            const excludeHosts = excludeList.map(e => (e === null || e === void 0 ? void 0 : e.includes(':')) ? e.split(':')[0] : e);
             yield Promise.all(subnets.map(sn => scanSubNet(sn, port, excludeHosts).then(found => { hosts.push(...found); })));
             return hosts.map(host => ({
                 path: `${host}:${port}`,
@@ -253,17 +243,20 @@ class TCPPortBinding {
         if (!this.isOpen) {
             throw new Error('Port is not open');
         }
-        this.writeOperation = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-            yield resolveNextTick();
-            try {
-                this.socket.write(buffer, () => {
-                    resolve();
-                });
-            }
-            catch (err) {
-                this.onError(err);
-            }
-        }));
+        this.writeOperation = new Promise((resolve) => {
+            const run = () => __awaiter(this, void 0, void 0, function* () {
+                yield resolveNextTick();
+                try {
+                    this.socket.write(buffer, () => {
+                        resolve();
+                    });
+                }
+                catch (err) {
+                    this.onError(err);
+                }
+            });
+            run();
+        });
         return this.writeOperation;
     }
     update(options) {

package/lib/types/adapter.d.ts

@@ -46,5 +46,8 @@ export interface IAdapter extends EventEmitter, IBike, ISensor {
     resume(): Promise<boolean>;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
+    resetData(): void;
+    onScanStart(): void;
+    onScanStop(): void;
     onData(callback: OnDeviceDataCallback): any;
 }

package/lib/types/device.d.ts

@@ -7,7 +7,8 @@ export declare enum INTERFACE {
     ANT = "ant",
     BLE = "ble",
     USB = "usb",
-    SIMULATOR = "simulator"
+    SIMULATOR = "simulator",
+    DC = "wifi"
 }
 export type DeviceType = 'race' | 'mountain' | 'triathlon';
 export type DeviceProperties = {

package/lib/types/device.js

@@ -9,4 +9,5 @@ var INTERFACE;
     INTERFACE["BLE"] = "ble";
     INTERFACE["USB"] = "usb";
     INTERFACE["SIMULATOR"] = "simulator";
+    INTERFACE["DC"] = "wifi";
 })(INTERFACE || (exports.INTERFACE = INTERFACE = {}));

package/lib/utils/calculations.d.ts

@@ -3,7 +3,6 @@ export declare class IllegalArgumentException extends Error {
 }
 export default class C {
     static calculateSpeed(m: number, power: number, slope: number, props?: any): number;
-    static calculateSlope(m: number, P: number, v: number, props?: any): number;
     static calculatePower(m: number, v: number, slope: number, props?: any): number;
     static calculateSpeedDaum(gear: number, rpm: number, bikeType?: string | number): number;
     static calculateSpeedBike(gear: number, rpm: number, chain: number[], cassette: number[], props?: {

package/lib/utils/calculations.js

@@ -19,14 +19,13 @@ class IllegalArgumentException extends Error {
 exports.IllegalArgumentException = IllegalArgumentException;
 class C {
     static calculateSpeed(m, power, slope, props = {}) {
-        var _a, _b, _c, _d;
         if (m === undefined || m === null || m < 0)
             throw new IllegalArgumentException("m must be a positive number");
         if (power === undefined || power === null || power < 0)
             throw new IllegalArgumentException("power must be a positive number");
-        const _rho = (_a = props.rho) !== null && _a !== void 0 ? _a : rho;
-        const _cRR = (_b = props.cRR) !== null && _b !== void 0 ? _b : cRR;
-        const _cwA = (_c = props.cwA) !== null && _c !== void 0 ? _c : ((_d = cwABike[props.bikeType || 'race']) !== null && _d !== void 0 ? _d : cwABike.race);
+        const _rho = props.rho || rho;
+        const _cRR = props.cRR || cRR;
+        const _cwA = props.cwA || cwABike[props.bikeType || 'race'] || cwABike.race;
         let sl = Math.atan(slope / 100);
         let c1 = 0.5 * _rho * _cwA;
         let c2 = (sl + _cRR) * m * g;
@@ -59,29 +58,14 @@ class C {
         }
         return 0;
     }
-    static calculateSlope(m, P, v, props = {}) {
-        var _a, _b, _c;
-        if (m === undefined || m === null || m < 0)
-            throw new IllegalArgumentException("m must be a positive number");
-        if (P === undefined || P === null || P < 0)
-            throw new IllegalArgumentException("power must be a positive number");
-        if (v === undefined || v === null || v === 0)
-            throw new IllegalArgumentException("v must be a positive number");
-        const _rho = (_a = props.rho) !== null && _a !== void 0 ? _a : rho;
-        const _cRR = (_b = props.cRR) !== null && _b !== void 0 ? _b : cRR;
-        const _cwA = (_c = props.cwA) !== null && _c !== void 0 ? _c : (cwABike[props.bikeType || 'race'] || cwABike.race);
-        const sl = (P - (0.5 * _rho * _cwA) * Math.pow(v, 3.0)) / (m * g * v) - _cRR;
-        return Math.tan(Math.asin(sl)) * 100;
-    }
     static calculatePower(m, v, slope, props = {}) {
-        var _a, _b, _c;
         if (m === undefined || m === null || m < 0)
             throw new IllegalArgumentException("m must be a positive number");
         if (v === undefined || v === null || v < 0)
             throw new IllegalArgumentException("v must be a positive number");
-        let _rho = (_a = props.rho) !== null && _a !== void 0 ? _a : rho;
-        let _cRR = (_b = props.cRR) !== null && _b !== void 0 ? _b : cRR;
-        let _cwA = (_c = props.cwA) !== null && _c !== void 0 ? _c : cwABike[props.bikeType || 'race'];
+        let _rho = props.rho || rho;
+        let _cRR = props.cRR || cRR;
+        let _cwA = props.cwA || cwABike[props.bikeType || 'race'];
         let sl = Math.sin(Math.atan(slope / 100));
         let P = (0.5 * _rho * _cwA) * Math.pow(v, 3.0) + (sl + _cRR) * m * g * v;
         return P;

package/lib/utils/operation.d.ts

@@ -0,0 +1,17 @@
+export interface TaskState {
+    isRunning: boolean;
+    timeout?: NodeJS.Timeout;
+    onTimeout: () => void;
+    promise: Promise<any>;
+}
+export interface TaskProps {
+    timeout?: number;
+}
+export declare class Task<T extends TaskState> {
+    protected _state: T;
+    constructor(_state: T, props: TaskProps);
+    get state(): T;
+    get promise(): Promise<any>;
+    start(promise: Promise<any>): void;
+    isRunning(): boolean;
+}

package/lib/utils/operation.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = void 0;
+class Task {
+    constructor(_state, props) {
+        this._state = _state;
+    }
+    get state() {
+        return this._state;
+    }
+    get promise() {
+        return this._state.promise;
+    }
+    start(promise) {
+    }
+    isRunning() {
+        return this._state.isRunning;
+    }
+}
+exports.Task = Task;

package/lib/utils/task.d.ts

@@ -0,0 +1,47 @@
+import EventEmitter from "events";
+export interface TaskState {
+    result?: 'completed' | 'timeout' | 'stopped' | 'error' | 'paused';
+    error?: Error;
+    tsStart?: number;
+    tsTimeout?: number;
+    promise?: Promise<any>;
+}
+export interface TaskProps<T, P> {
+    timeout?: number;
+    state?: any;
+    name?: string;
+    errorOnTimeout?: boolean;
+    log?: (event: any) => void;
+    onDone?: (state: T) => P;
+}
+interface InternalTaskState<P> {
+    tsStart?: number;
+    tsTimeout?: number;
+    isRunning: boolean;
+    timeout?: NodeJS.Timeout;
+    promise?: Promise<P>;
+    onDone?: (result: P) => void;
+    onError?: (error: Error) => void;
+    onTimeout?: () => void;
+}
+export declare class InteruptableTask<T extends TaskState, P> {
+    protected state: T;
+    protected internalState: InternalTaskState<P>;
+    protected props?: TaskProps<T, P>;
+    protected internalEvents: EventEmitter<[never]>;
+    protected promise?: Promise<P>;
+    protected onStopNotifiers: Array<() => void>;
+    constructor(promise: Promise<any>, props?: TaskProps<T, P>);
+    getPromise(): Promise<P>;
+    getState(): T;
+    run(): Promise<P>;
+    notifyOnStop(cb: () => void): void;
+    start(): void;
+    stop(): Promise<boolean>;
+    isRunning(): boolean;
+    protected clearTimeout(): void;
+    protected onTimeout(): void;
+    protected sendStopNotification(): void;
+    protected logEvent(event: any): void;
+}
+export {};