incyclist-services 1.3.14 → 1.3.15

package/lib/devices/ride/service.d.ts

@@ -50,6 +50,7 @@ export declare class DeviceRideService extends EventEmitter {
     cancelStart(): Promise<boolean>;
     startRide(_props: any): void;
     stop(udid?: string): Promise<boolean>;
+    resetLimits(): Promise<void>;
     pause(): void;
     resume(): void;
     protected verifySelected(selectedDevices: any, capability: IncyclistCapability): void;
@@ -60,6 +61,7 @@ export declare class DeviceRideService extends EventEmitter {
     sendUpdate(request: UpdateRequest): Promise<void>;
     getCyclingMode(udid?: string): CyclingMode;
     resetCyclingMode(sendInit?: boolean): Promise<void>;
+    enforceERG(): Promise<void>;
     onCyclingModeChanged(udid: string, mode: string, settings: any): Promise<void>;
     onDeviceDeleted(settings: IncyclistDeviceSettings): void;
     enforceSimulator(enforced?: boolean): void;

package/lib/devices/ride/service.js

@@ -727,6 +727,17 @@ class DeviceRideService extends events_1.default {
             return true;
         });
     }
+    resetLimits() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const mode = this.getCyclingMode();
+                const resetRequest = (_a = mode === null || mode === void 0 ? void 0 : mode.getBikeInitRequest()) !== null && _a !== void 0 ? _a : {};
+                yield this.sendUpdate(Object.assign(Object.assign({}, resetRequest), { slope: 0, forced: true }));
+            }
+            catch (_b) { }
+        });
+    }
     pause() {
         const adapters = this.getAdapterList();
         adapters === null || adapters === void 0 ? void 0 : adapters.forEach(ai => {
@@ -897,6 +908,30 @@ class DeviceRideService extends events_1.default {
             }
         });
     }
+    enforceERG() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const adapters = this.getAdapterList();
+                const adapterInfo = adapters === null || adapters === void 0 ? void 0 : adapters.find(ai => ai.adapter.hasCapability(incyclist_devices_1.IncyclistCapability.Control));
+                if (!(adapterInfo === null || adapterInfo === void 0 ? void 0 : adapterInfo.adapter))
+                    return;
+                const { udid, adapter } = adapterInfo;
+                if (adapter.getCyclingMode().getModeProperty('eppSupport'))
+                    return;
+                const modes = adapter.getSupportedCyclingModes().filter(C => C.supportsERGMode());
+                if (modes.length > 0) {
+                    const mode = new modes[0](adapter);
+                    const modeInfo = this.configurationService.getModeSettings(udid, mode.getName());
+                    const settings = modeInfo.settings;
+                    const device = adapter;
+                    device.setCyclingMode(mode, settings);
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', error: err.message, fn: 'enforceERG' });
+            }
+        });
+    }
     onCyclingModeChanged(udid, mode, settings) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;

package/lib/workouts/ride/service.d.ts

@@ -21,6 +21,7 @@ export declare class WorkoutRide extends IncyclistService {
     protected currentLimits: ActiveWorkoutLimit;
     protected updateInterval: NodeJS.Timeout;
     protected currentStep: StepDefinition;
+    protected isFreeRide: boolean;
     constructor();
     init(): Observer;
     start(paused?: boolean): Workout;
@@ -34,10 +35,13 @@ export declare class WorkoutRide extends IncyclistService {
     getDashboardDisplayProperties(): WorkoutDisplayProperties;
     getCurrentLimits(): ActiveWorkoutLimit;
     inUse(): boolean;
+    appliesLimits(): boolean;
     isActive(): boolean;
     getWorkout(): Workout;
     getObserver(): Observer;
     protected update(startIfInitialized?: boolean): void;
+    protected startFreeRide(): Promise<void>;
+    protected stopFreeRide(): Promise<void>;
     protected resetLimits(): Promise<void>;
     protected resetTimes(): void;
     protected setCurrentLimits(trainingTime?: number): void;

package/lib/workouts/ride/service.js

@@ -68,6 +68,7 @@ let WorkoutRide = (() => {
         constructor() {
             super('WorkoutRide');
             this.state = 'idle';
+            this.isFreeRide = true;
         }
         init() {
             var _a, _b;
@@ -282,6 +283,9 @@ let WorkoutRide = (() => {
         inUse() {
             return this.state !== 'idle' && this.state !== 'completed';
         }
+        appliesLimits() {
+            return this.inUse() && !this.isFreeRide;
+        }
         isActive() {
             return this.state === 'active';
         }
@@ -315,6 +319,12 @@ let WorkoutRide = (() => {
                 const prevStep = this.currentStep;
                 this.setCurrentLimits(time);
                 if (this.currentStep !== prevStep) {
+                    if (!this.currentStep.power && prevStep.power) {
+                        this.startFreeRide();
+                    }
+                    else if (this.currentStep.power && !prevStep.power) {
+                        this.stopFreeRide();
+                    }
                     this.emit('step-changed', this.getDashboardDisplayProperties());
                 }
                 else if (Math.round(time) !== prevTime) {
@@ -325,16 +335,31 @@ let WorkoutRide = (() => {
                 this.logError(err, 'update');
             }
         }
+        startFreeRide() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.settings.useErgMode) {
+                    (0, devices_1.useDeviceRide)().resetCyclingMode(false);
+                }
+                this.resetLimits();
+            });
+        }
+        stopFreeRide() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.settings.useErgMode) {
+                    (0, devices_1.useDeviceRide)().enforceERG();
+                }
+                this.resetLimits();
+            });
+        }
         resetLimits() {
             return __awaiter(this, void 0, void 0, function* () {
                 const rideService = (0, devices_1.useDeviceRide)();
-                rideService.resetCyclingMode();
                 const mode = rideService.getCyclingMode();
-                const data = rideService.getData();
                 const isERG = mode ? mode.constructor.supportsERGMode() : false;
                 if (!this.currentLimits || !mode)
                     return;
                 yield rideService.waitForUpdateFinish();
+                const data = rideService.getData();
                 if (isERG) {
                     rideService.sendUpdate({ targetPower: data.power });
                 }
@@ -374,6 +399,7 @@ let WorkoutRide = (() => {
                 request.maxHrm = ((_d = limits.hrm) === null || _d === void 0 ? void 0 : _d.max) ? Math.round(limits.hrm.max) : undefined;
                 this.currentLimits = Object.assign(Object.assign({}, request), { duration: limits.duration, remaining: limits.remaining });
             }
+            this.isFreeRide = limits.power === undefined || limits.power === null;
             this.logger.logEvent(Object.assign(Object.assign({ message: 'workout requests' }, this.currentLimits), { ftp }));
             this.emit('request-update', this.currentLimits);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.3.14",
+  "version": "1.3.15",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },
@@ -43,7 +43,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.2.2",
+    "incyclist-devices": "^2.2.3",
     "promise.any": "^2.0.6",
     "tcx-builder": "^1.1.1",
     "uuid": "^9.0.0",