incyclist-services 1.1.95 → 1.1.97

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

@@ -55,6 +55,7 @@ export declare class DeviceRideService extends EventEmitter {
     private getEnabledCapabilities;
     sendUpdate(request: UpdateRequest): void;
     getCyclingMode(udid?: string): CyclingMode;
+    resetCyclingMode(sendInit?: boolean): 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

@@ -852,6 +852,29 @@ class DeviceRideService extends events_1.default {
         if (adapter)
             return adapter.getCyclingMode();
     }
+    resetCyclingMode(sendInit = false) {
+        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;
+                const modeInfo = this.configurationService.getModeSettings(udid);
+                const mode = modeInfo === null || modeInfo === void 0 ? void 0 : modeInfo.mode;
+                const settings = modeInfo.settings;
+                if (adapter.getCyclingMode().getModeProperty('eppSupport'))
+                    return;
+                const device = adapter;
+                device.setCyclingMode(mode, settings);
+                if (sendInit)
+                    yield device.sendInitCommands();
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', error: err.message, fn: 'resetCyclingMode' });
+            }
+        });
+    }
     onCyclingModeChanged(udid, mode, settings) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {

package/lib/workouts/base/model/Segment.d.ts

@@ -7,12 +7,12 @@ export declare class Segment extends Step implements SegmentDefinition {
     protected init(opts: SegmentDefinition, ignoreValidate: boolean): void;
     validate(): void;
     validateTiming(): boolean;
-    prepareNext(json: StepDefinition | SegmentDefinition): void;
-    push(s: any): void;
     getDuration(): number;
-    getSingleDuration(): number;
     getStart(): number;
     getEnd(): number;
-    getStep(ts: number): Step;
     getLimits(ts: any, includeStepInfo?: boolean): CurrentStep;
+    protected prepareNext(json: StepDefinition | SegmentDefinition): void;
+    push(s: any): void;
+    protected getSingleDuration(): number;
+    protected getStep(ts: number): Step;
 }

package/lib/workouts/base/model/Segment.js

@@ -63,6 +63,36 @@ class Segment extends Step_1.Step {
         });
         return true;
     }
+    getDuration() {
+        return this.getSingleDuration() * this.repeat;
+    }
+    getStart() {
+        if (this.start !== undefined)
+            return this.start;
+        else {
+            if (this.steps.length > 0)
+                return this.steps[0].start;
+            else
+                return undefined;
+        }
+    }
+    getEnd() {
+        return this.getStart() + this.getDuration();
+    }
+    getLimits(ts, includeStepInfo = false) {
+        const step = this.getStep(ts);
+        if (step === undefined)
+            return undefined;
+        const segTime = ts - this.getStart();
+        const stepDuration = this.getSingleDuration();
+        let part = (segTime % stepDuration);
+        if (part === stepDuration)
+            part = 0;
+        part += this.getStart();
+        if (part === this.getStart() && segTime > 0 && segTime < stepDuration)
+            part += stepDuration;
+        return step.getLimits(part, includeStepInfo);
+    }
     prepareNext(json) {
         if (json === undefined)
             return;
@@ -88,50 +118,25 @@ class Segment extends Step_1.Step {
         this.end = this.start + this.duration;
         this.validate();
     }
-    getDuration() {
-        return this.getSingleDuration() * this.repeat;
-    }
     getSingleDuration() {
         if (this.steps.length === 0)
             return 0;
         return this.steps.map(s => s.duration).reduce((a, b) => a + b);
     }
-    getStart() {
-        if (this.start !== undefined)
-            return this.start;
-        else {
-            if (this.steps.length > 0)
-                return this.steps[0].start;
-            else
-                return undefined;
-        }
-    }
-    getEnd() {
-        return this.getStart() + this.getDuration();
-    }
     getStep(ts) {
-        if (ts >= this.getStart() && ts <= this.getEnd()) {
+        if (ts >= this.getStart() && ts < this.getEnd()) {
             const segTime = ts - this.getStart();
             let part = (segTime % this.getSingleDuration());
+            if (part === this.getSingleDuration())
+                part = 0;
             part += this.getStart();
-            if (part === this.getStart() && segTime > 0)
+            if (part === this.getStart() && segTime > 0 && segTime < this.getSingleDuration())
                 part += this.getSingleDuration();
             const found = this.steps.find(s => {
-                return (part >= s.start && part <= s.end);
+                return (part >= s.start && part < s.end);
             });
             return found;
         }
     }
-    getLimits(ts, includeStepInfo = false) {
-        const step = this.getStep(ts);
-        if (step === undefined)
-            return undefined;
-        const segTime = ts - this.getStart();
-        let part = (segTime % this.getSingleDuration());
-        part += this.getStart();
-        if (part === this.getStart() && segTime > 0)
-            part += this.getSingleDuration();
-        return step.getLimits(part, includeStepInfo);
-    }
 }
 exports.Segment = Segment;

package/lib/workouts/base/model/Step.d.ts

@@ -15,7 +15,7 @@ export declare class Step implements StepDefinition {
     power?: PowerLimit;
     cadence?: Limit;
     hrm?: Limit;
-    text: string;
+    text?: string;
     work: boolean;
     steady: boolean;
     cooldown: boolean;
@@ -24,12 +24,12 @@ export declare class Step implements StepDefinition {
     getDuration(): number;
     getStart(): number;
     getEnd(): number;
-    validateTiming(): boolean;
-    validateLimit(p: Limit, name: string): boolean;
-    validatePower(): boolean;
-    validateCadence(): boolean;
-    validateHrm(): boolean;
     getLimits(ts: number, includeStepInfo?: boolean): CurrentStep;
-    getRemainder(limits: CurrentStep, includeStepInfo?: boolean): CurrentStep;
-    calc(ts: any, limit: any, includeStepInfo: boolean, isPower?: boolean): {};
+    validateTiming(): boolean;
+    protected validateLimit(p: Limit, name: string): boolean;
+    protected validatePower(): boolean;
+    protected validateCadence(): boolean;
+    protected validateHrm(): boolean;
+    protected getRemainder(limits: CurrentStep, includeStepInfo?: boolean): CurrentStep;
+    protected calc(ts: any, limit: any, includeStepInfo: boolean, isPower?: boolean): {};
 }

package/lib/workouts/base/model/Step.js

@@ -41,6 +41,27 @@ class Step {
     getDuration() { return this.duration; }
     getStart() { return this.start; }
     getEnd() { return this.end; }
+    getLimits(ts, includeStepInfo = false) {
+        const rv = (limits) => this.getRemainder(limits, includeStepInfo);
+        if (ts >= this.start && ts <= this.end) {
+            const duration = this.duration;
+            const remaining = this.end - ts;
+            if (this.steady) {
+                const { power, cadence, hrm, text, work } = this;
+                return rv({ power, cadence, hrm, text, work, duration, remaining });
+            }
+            else {
+                const { text, work } = this;
+                const power = this.calc(ts, this.power, includeStepInfo, true);
+                const cadence = this.calc(ts, this.cadence, includeStepInfo);
+                const hrm = this.calc(ts, this.hrm, includeStepInfo);
+                return rv({ power, cadence, hrm, text, work, duration, remaining });
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
     validateTiming() {
         if (this.start === undefined && this.end === undefined) {
             throw new Error(`Invalid Step description, start or end needs to be provided `);
@@ -94,27 +115,6 @@ class Step {
     validateHrm() {
         return this.validateLimit(this.hrm, 'hrm');
     }
-    getLimits(ts, includeStepInfo = false) {
-        const rv = (limits) => this.getRemainder(limits, includeStepInfo);
-        if (ts >= this.start && ts <= this.end) {
-            const duration = this.duration;
-            const remaining = this.end - ts;
-            if (this.steady) {
-                const { power, cadence, hrm, text, work } = this;
-                return rv({ power, cadence, hrm, text, work, duration, remaining });
-            }
-            else {
-                const { text, work } = this;
-                const power = this.calc(ts, this.power, includeStepInfo, true);
-                const cadence = this.calc(ts, this.cadence, includeStepInfo);
-                const hrm = this.calc(ts, this.hrm, includeStepInfo);
-                return rv({ power, cadence, hrm, text, work, duration, remaining });
-            }
-        }
-        else {
-            return undefined;
-        }
-    }
     getRemainder(limits, includeStepInfo = false) {
         if (limits === undefined)
             return;

package/lib/workouts/base/model/Workout.d.ts

@@ -8,6 +8,7 @@ export declare class Workout extends Segment implements WorkoutDefinition {
     category?: Category;
     constructor(opts: WorkoutDefinition);
     get hash(): string;
+    getSegment(time: number): Segment;
     addStep(step: StepDefinition): void;
     addSegment(segment: SegmentDefinition): void;
 }

package/lib/workouts/base/model/Workout.js

@@ -39,6 +39,11 @@ class Workout extends Segment_1.Segment {
         this._hash = (0, md5_1.default)(JSON.stringify({ name, description, steps, repeat }));
         return this._hash;
     }
+    getSegment(time) {
+        const s = this.steps.find(s => s.getStart() <= time && s.getEnd() > time);
+        if (s.type === 'segment')
+            return s;
+    }
     addStep(step) {
         if ((0, valid_1.valid)(step)) {
             if (step.duration === undefined && step.start === undefined && step.end === undefined)

package/lib/workouts/list/cards/WorkoutCard.js

@@ -187,7 +187,7 @@ class WorkoutCard extends base_1.BaseCard {
             return `${duration / 60}min`;
         const secVal = duration % 60;
         const minVal = (duration - secVal) / 60 % 60;
-        const h = (duration - secVal - minVal * 60) / 60 % 60;
+        const h = Math.floor((duration - secVal - minVal * 60) / 3600);
         const sec = secVal < 10 ? `0${secVal}` : secVal;
         const min = minVal < 10 ? `0${minVal}` : minVal;
         if (h > 0)

package/lib/workouts/list/loaders/db.d.ts

@@ -16,12 +16,12 @@ export declare class WorkoutsDbLoader extends Loader {
     constructor();
     load(): Observer;
     stopLoad(): void;
-    protected getRepo(): JsonRepository;
-    protected _load(): Promise<void>;
     save(workout: Workout | Plan): Promise<void>;
     delete(workout: Workout | Plan): Promise<void>;
+    protected getRepo(): JsonRepository;
+    protected _load(): Promise<void>;
     protected writeRepo(): Promise<void>;
-    protected write(): void;
+    protected write(enforced?: boolean): void;
     protected emitUpdated(workout: Workout | Plan): void;
     protected emitAdded(workout: Workout | Plan): void;
     protected emitDone(): void;

package/lib/workouts/list/loaders/db.js

@@ -55,6 +55,7 @@ const loader_1 = require("./loader");
 const Workout_1 = require("../../base/model/Workout");
 const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("../../../utils");
+const valid_1 = require("../../../utils/valid");
 let WorkoutsDbLoader = (() => {
     let _classDecorators = [types_1.Singleton];
     let _classDescriptor;
@@ -77,41 +78,36 @@ let WorkoutsDbLoader = (() => {
             return this.loadObserver;
         }
         stopLoad() {
-            delete this.loadObserver;
-        }
-        getRepo() {
-            if (!this.repo)
-                this.repo = api_1.JsonRepository.create('workouts');
-            return this.repo;
-        }
-        _load() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const workouts = yield this.getRepo().read('db');
-                if (workouts) {
-                    const items = workouts;
-                    items.forEach(item => {
-                        const workout = new Workout_1.Workout(item);
-                        this.workouts.push(workout);
-                        this.emitAdded(workout);
-                    });
-                }
-                this.emitDone();
-            });
+            if (this.loadObserver) {
+                this.loadObserver.emit('done');
+                (0, utils_1.waitNextTick)().then(() => {
+                    delete this.loadObserver;
+                });
+            }
         }
         save(workout) {
             return __awaiter(this, void 0, void 0, function* () {
-                const stringify = (json) => { try {
-                    JSON.stringify(json);
-                }
-                catch (_a) { } };
+                if (!(0, valid_1.valid)(workout))
+                    return;
+                const stringify = (json) => {
+                    try {
+                        return JSON.stringify(json);
+                    }
+                    catch (_a) {
+                    }
+                };
                 let prev;
                 const idx = this.workouts.findIndex(d => d.id === workout.id);
-                if (idx === -1)
+                let changed = false;
+                if (idx === -1) {
+                    changed = true;
                     this.workouts.push(workout);
+                }
                 else {
+                    prev = stringify(Object.assign({}, this.workouts[idx]));
                     this.workouts[idx] = workout;
+                    changed = stringify(Object.assign({}, this.workouts[idx])) !== prev;
                 }
-                const changed = !prev || stringify(this.workouts) !== prev;
                 if (changed) {
                     this.isDirty = true;
                     this.write();
@@ -129,13 +125,32 @@ let WorkoutsDbLoader = (() => {
                 yield this.write();
             });
         }
+        getRepo() {
+            if (!this.repo)
+                this.repo = api_1.JsonRepository.create('workouts');
+            return this.repo;
+        }
+        _load() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const workouts = yield this.getRepo().read('db');
+                if (workouts) {
+                    const items = workouts;
+                    items.forEach(item => {
+                        const workout = new Workout_1.Workout(item);
+                        this.workouts.push(workout);
+                        this.emitAdded(workout);
+                    });
+                }
+                this.emitDone();
+            });
+        }
         writeRepo() {
             return __awaiter(this, void 0, void 0, function* () {
                 if (this.saveObserver)
                     yield this.saveObserver.wait();
                 const save = () => __awaiter(this, void 0, void 0, function* () {
                     try {
-                        yield this.repo.write('db', this.workouts);
+                        yield this.getRepo().write('db', this.workouts);
                     }
                     catch (err) {
                         this.logger.logEvent({ message: 'could not safe repo', error: err.message });
@@ -146,14 +161,17 @@ let WorkoutsDbLoader = (() => {
                 process.nextTick(() => { delete this.saveObserver; });
             });
         }
-        write() {
-            if (this.isDirty && (this.tsLastWrite === undefined || Date.now() - this.tsLastWrite >= 1000)) {
+        write(enforced = false) {
+            if (enforced || (this.isDirty && (this.tsLastWrite === undefined || Date.now() - this.tsLastWrite >= 1000))) {
                 this.isDirty = false;
                 this.tsLastWrite = Date.now();
                 this.writeRepo();
             }
             if (this.isDirty && Date.now() - this.tsLastWrite < 1000) {
-                setTimeout(() => { this.write(); }, this.tsLastWrite + 1000 - Date.now());
+                const delayUntilNextWrite = this.tsLastWrite + 1000 - Date.now();
+                setTimeout(() => {
+                    this.write(true);
+                }, delayUntilNextWrite);
             }
         }
         emitUpdated(workout) {

package/lib/workouts/list/service.js

@@ -286,7 +286,6 @@ let WorkoutListService = (() => {
                 if (forUi && (!this.initialized))
                     return null;
                 const lists = this.lists.filter(l => l.getCards().length > 0);
-                console.log('~~~ LISTS:', lists);
                 return lists;
             }
             catch (err) {

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

@@ -4,6 +4,7 @@ import { Observer } from "../../base/types/observer";
 import { PowerLimit, Workout } from "../base/model";
 import { WorkoutListService } from "../list";
 import { WorkoutSettings } from "../list/cards/types";
+import { ActiveWorkoutLimit, WorkoutDisplayProperties } from "./types";
 export declare class WorkoutRide extends IncyclistService {
     protected manualTimeOffset: number;
     protected manualPowerOffset: number;
@@ -17,9 +18,8 @@ export declare class WorkoutRide extends IncyclistService {
     protected tsPauseStart: number;
     protected tsCurrent: number;
     protected trainingTime: number;
-    protected currentLimits: any;
+    protected currentLimits: ActiveWorkoutLimit;
     protected updateInterval: NodeJS.Timeout;
-    protected id: any;
     constructor();
     init(): Observer;
     start(paused?: boolean): Workout;
@@ -30,37 +30,25 @@ export declare class WorkoutRide extends IncyclistService {
     backward(): void;
     powerUp(delta: number): void;
     powerDown(delta: number): void;
-    update(startIfInitialized?: boolean): void;
-    getDashboardDisplayProperties(): {
-        workout?: undefined;
-        title?: undefined;
-        ftp?: undefined;
-        current?: undefined;
-        start?: undefined;
-        stop?: undefined;
-    } | {
-        workout: Workout;
-        title: string;
-        ftp: number;
-        current: any;
-        start: any;
-        stop: any;
-    };
+    getDashboardDisplayProperties(): WorkoutDisplayProperties;
+    getCurrentLimits(): ActiveWorkoutLimit;
     inUse(): boolean;
     isActive(): boolean;
     getWorkout(): Workout;
     getObserver(): Observer;
+    protected update(startIfInitialized?: boolean): void;
     protected resetTimes(): void;
     protected setCurrentLimits(trainingTime?: number): void;
     protected getZoomParameters(time: number): {
         start: any;
         stop: any;
     };
+    protected getStepTitle(time: number): string;
     protected getPowerVal(power: PowerLimit, key: 'min' | 'max'): number;
-    protected getTime(): number;
     protected getFtpFromUserSettings(): any;
     protected resetWorkout(): void;
     emit(eventName: string, ...args: any[]): boolean;
+    protected stopWorker(): void;
 }
 export declare const useWorkoutRide: () => WorkoutRide;
 export declare const getWorkoutRide: () => WorkoutRide;

package/lib/workouts/ride/service.js

@@ -48,7 +48,6 @@ const valid_1 = require("../../utils/valid");
 const list_1 = require("../list");
 const DEFAULT_FTP = 200;
 const WORKOUT_ZOOM = 1200;
-let _instance = 0;
 let WorkoutRide = (() => {
     let _classDecorators = [types_1.Singleton];
     let _classDescriptor;
@@ -59,17 +58,16 @@ let WorkoutRide = (() => {
         constructor() {
             super('WorkoutRide');
             this.state = 'idle';
-            this.id = _instance++;
         }
         init() {
             var _a, _b;
             try {
                 this.workoutList = (0, list_1.getWorkoutList)();
-                this.resetTimes();
-                this.manualPowerOffset = 0;
                 this.workout = this.workoutList.getSelected();
                 if (!this.workout)
                     return;
+                this.resetTimes();
+                this.manualPowerOffset = 0;
                 this.settings = (_a = this.workoutList.getStartSettings()) !== null && _a !== void 0 ? _a : {};
                 if (!(0, valid_1.valid)(this.settings.ftp)) {
                     this.settings.ftp = (_b = this.getFtpFromUserSettings()) !== null && _b !== void 0 ? _b : 200;
@@ -90,7 +88,7 @@ let WorkoutRide = (() => {
         }
         start(paused = false) {
             try {
-                if (this.state !== 'initialized') {
+                if (this.state !== 'initialized' || !this.workout) {
                     return;
                 }
                 this.state = 'active';
@@ -102,6 +100,7 @@ let WorkoutRide = (() => {
                 this.emit('started');
                 this.logEvent({ message: 'workout started', settings: this.settings });
                 if (!this.updateInterval) {
+                    this.update();
                     this.updateInterval = setInterval(() => { this.update(); }, 500);
                 }
                 if (paused)
@@ -131,6 +130,7 @@ let WorkoutRide = (() => {
         resume() {
             try {
                 if (this.state === 'initialized' || this.state === 'completed') {
+                    this.state = 'initialized';
                     this.start();
                     return;
                 }
@@ -152,13 +152,12 @@ let WorkoutRide = (() => {
         }
         stop() {
             try {
+                if (!this.workout || this.state === 'idle')
+                    return;
                 this.state = 'completed';
                 this.logger.logEvent({ message: 'workout completed' });
                 this.emit('completed');
-                if (this.updateInterval) {
-                    clearInterval(this.updateInterval);
-                    this.updateInterval = undefined;
-                }
+                this.stopWorker();
                 (0, utils_1.waitNextTick)()
                     .then(() => { this.resetWorkout(); });
             }
@@ -168,10 +167,11 @@ let WorkoutRide = (() => {
         }
         forward() {
             try {
-                const ts = this.getTime();
+                const ts = this.trainingTime;
                 const wo = this.workout;
                 const limits = wo.getLimits(ts);
                 this.manualTimeOffset += limits.remaining;
+                this.update();
             }
             catch (err) {
                 this.logError(err, 'forward');
@@ -179,26 +179,40 @@ let WorkoutRide = (() => {
         }
         backward() {
             try {
-                const ts = this.getTime();
+                const ts = this.trainingTime;
                 const wo = this.workout;
                 const limits = wo.getLimits(ts);
                 const completed = limits.duration - limits.remaining;
-                const timePrev = ts - completed - 1;
-                const prevLimits = wo.getLimits(timePrev);
-                if (prevLimits) {
-                    this.manualTimeOffset -= (completed + prevLimits.duration);
+                const stepBusyLmit = Math.min(15, limits.duration / 2);
+                if (completed >= stepBusyLmit) {
+                    this.manualTimeOffset -= completed;
                 }
+                else {
+                    const timePrev = ts - completed - 0.1;
+                    if (timePrev < 0) {
+                        this.manualTimeOffset -= completed;
+                    }
+                    else {
+                        const prevLimits = wo.getLimits(timePrev);
+                        if (prevLimits) {
+                            this.manualTimeOffset -= (completed + prevLimits.duration);
+                        }
+                    }
+                }
+                this.update();
             }
             catch (err) {
                 this.logError(err, 'backward');
             }
         }
         powerUp(delta) {
+            var _a;
             try {
-                if (this.settings.ftp)
+                if ((_a = this.settings) === null || _a === void 0 ? void 0 : _a.ftp) {
                     this.settings.ftp = this.settings.ftp * (1 + delta / 100);
+                    this.workoutList.setStartSettings(this.settings);
+                }
                 this.manualPowerOffset += delta;
-                this.workoutList.setStartSettings(this.settings);
                 this.setCurrentLimits();
                 this.emit('update', this.getDashboardDisplayProperties());
             }
@@ -207,11 +221,13 @@ let WorkoutRide = (() => {
             }
         }
         powerDown(delta) {
+            var _a;
             try {
-                if (this.settings.ftp)
+                if ((_a = this.settings) === null || _a === void 0 ? void 0 : _a.ftp) {
                     this.settings.ftp = this.settings.ftp / (1 + delta / 100);
+                    this.workoutList.setStartSettings(this.settings);
+                }
                 this.manualPowerOffset -= delta;
-                this.workoutList.setStartSettings(this.settings);
                 this.setCurrentLimits();
                 this.emit('update', this.getDashboardDisplayProperties());
             }
@@ -219,47 +235,32 @@ let WorkoutRide = (() => {
                 this.logError(err, 'powerDown');
             }
         }
-        update(startIfInitialized = false) {
-            var _a, _b;
-            try {
-                const prevTime = Math.round(this.currentLimits.time);
-                if (startIfInitialized && this.state === 'initialized') {
-                    this.start();
-                }
-                else if (this.state !== 'active')
-                    return;
-                const time = (_b = ((_a = Date.now() - this.tsStart - this.offset) !== null && _a !== void 0 ? _a : 0) / 1000 + this.manualTimeOffset) !== null && _b !== void 0 ? _b : 0;
-                const end = this.workout.getEnd();
-                if (time > end) {
-                    this.stop();
-                    return;
-                }
-                this.setCurrentLimits(time);
-                if (Math.round(time) !== prevTime)
-                    this.emit('update', this.getDashboardDisplayProperties());
-            }
-            catch (err) {
-                this.logError(err, 'update');
-            }
-        }
         getDashboardDisplayProperties() {
             try {
                 if (this.state === 'idle' || this.state === 'completed') {
                     return {};
                 }
                 const { start, stop } = this.getZoomParameters(this.trainingTime);
-                return {
-                    workout: this.workout, title: this.workout.name,
+                const title = this.getStepTitle(this.trainingTime);
+                const props = {
+                    workout: this.workout, title,
                     ftp: this.settings.ftp,
                     current: this.currentLimits,
                     start, stop
                 };
+                return props;
             }
             catch (err) {
                 this.logError(err, 'getDashboardDisplayProperties');
                 return {};
             }
         }
+        getCurrentLimits() {
+            if (this.state === 'idle' || this.state === 'completed') {
+                return undefined;
+            }
+            return this.currentLimits;
+        }
         inUse() {
             return this.state !== 'idle' && this.state !== 'completed';
         }
@@ -276,12 +277,37 @@ let WorkoutRide = (() => {
                 return undefined;
             return this.observer;
         }
+        update(startIfInitialized = false) {
+            var _a, _b, _c, _d;
+            if (!this.workout)
+                return;
+            try {
+                const prevTime = Math.round((_b = (_a = this.currentLimits) === null || _a === void 0 ? void 0 : _a.time) !== null && _b !== void 0 ? _b : 0);
+                if (startIfInitialized && this.state === 'initialized') {
+                    this.start();
+                }
+                else if (this.state !== 'active')
+                    return;
+                const time = (_d = ((_c = Date.now() - this.tsStart - this.offset) !== null && _c !== void 0 ? _c : 0) / 1000 + this.manualTimeOffset) !== null && _d !== void 0 ? _d : 0;
+                const end = this.workout.getEnd();
+                if (time >= end) {
+                    this.stop();
+                    return;
+                }
+                this.setCurrentLimits(time);
+                if (Math.round(time) !== prevTime)
+                    this.emit('update', this.getDashboardDisplayProperties());
+            }
+            catch (err) {
+                this.logError(err, 'update');
+            }
+        }
         resetTimes() {
             this.manualTimeOffset = 0;
             this.tsStart = undefined;
             this.tsCurrent = undefined;
             this.tsPauseStart = undefined;
-            this.offset = undefined;
+            this.offset = 0;
         }
         setCurrentLimits(trainingTime) {
             var _a, _b, _c, _d;
@@ -293,7 +319,7 @@ let WorkoutRide = (() => {
             const limits = wo.getLimits(time);
             const request = { time: 0, duration: 0, remaining: 0 };
             if (limits !== undefined) {
-                request.time = time;
+                request.time = Math.round(time);
                 request.minPower = this.getPowerVal(limits.power, 'min');
                 request.maxPower = this.getPowerVal(limits.power, 'max');
                 request.minCadence = ((_a = limits === null || limits === void 0 ? void 0 : limits.cadence) === null || _a === void 0 ? void 0 : _a.min) ? Math.round(limits.cadence.min) : undefined;
@@ -318,6 +344,31 @@ let WorkoutRide = (() => {
             }
             return { start, stop };
         }
+        getStepTitle(time) {
+            if (!this.workout)
+                return;
+            let title = this.workout.name;
+            const limit = this.workout.getLimits(time, true);
+            const segment = this.workout.getSegment(time);
+            let ch = ': ';
+            if (segment && segment.text) {
+                title += `${ch}${segment.text}`;
+                ch = ' - ';
+            }
+            if (segment && segment.text && segment.repeat > 0) {
+                const repeatTime = segment.duration / segment.repeat;
+                const repeatCount = Math.floor((time - segment.getStart()) / repeatTime) + 1;
+                title += `(${repeatCount}/${segment.repeat})`;
+            }
+            if (limit.text)
+                title += `${ch}${limit.text}`;
+            if (limit.text && segment && !segment.text && segment.repeat > 0) {
+                const repeatTime = segment.duration / segment.repeat;
+                const repeatCount = Math.floor((time - segment.getStart()) / repeatTime) + 1;
+                title += `(${repeatCount}/${segment.repeat})`;
+            }
+            return title;
+        }
         getPowerVal(power, key) {
             var _a, _b;
             if (power === undefined)
@@ -333,16 +384,6 @@ let WorkoutRide = (() => {
             }
             return Math.round(val + this.manualPowerOffset);
         }
-        getTime() {
-            if (this.state === 'initialized' || this.state === 'idle')
-                return 0;
-            let ts = (this.tsCurrent - this.tsStart - (this.offset || 0)) / 1000 + this.manualTimeOffset;
-            if (ts < 0) {
-                this.manualTimeOffset -= ts;
-                ts = 0;
-            }
-            return ts;
-        }
         getFtpFromUserSettings() {
             try {
                 const userSettings = (0, settings_1.useUserSettings)();
@@ -366,6 +407,12 @@ let WorkoutRide = (() => {
             this.observer.emit(eventName, ...args);
             return true;
         }
+        stopWorker() {
+            if (this.updateInterval) {
+                clearInterval(this.updateInterval);
+                this.updateInterval = undefined;
+            }
+        }
     };
     __setFunctionName(_classThis, "WorkoutRide");
     (() => {

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

@@ -1,3 +1,4 @@
+import { Workout } from "../base/model";
 export interface WorkoutRequest {
     time: number;
     minPower?: number;
@@ -11,3 +12,11 @@ export interface ActiveWorkoutLimit extends WorkoutRequest {
     duration: number;
     remaining: number;
 }
+export interface WorkoutDisplayProperties {
+    workout?: Workout;
+    title?: string;
+    ftp?: number;
+    current?: ActiveWorkoutLimit;
+    start?: number;
+    stop?: number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.1.95",
+  "version": "1.1.97",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.1.40",
+    "incyclist-devices": "^2.1.41",
     "md5": "^2.3.0",
     "promise.any": "^2.0.6",
     "uuid": "^9.0.0",