incyclist-services 1.7.76 → 1.7.77

package/lib/cjs/activities/list/service.js

@@ -404,7 +404,7 @@ let ActivityListService = (() => {
                 startPos,
                 segment: activity?.segment,
                 started: activity ? new Date(activity.startTime) : undefined,
-                showMap: true,
+                showMap: activity?.routeType !== 'None',
                 points,
                 activity,
                 exports: this.exports,

package/lib/cjs/activities/ride/service.js

@@ -425,10 +425,11 @@ let ActivityRideService = (() => {
                 const route = this.getRouteList().getSelected();
                 const startSettings = this.getRouteList().getStartSettings();
                 const isFreeRide = startSettings?.type === 'Free-Ride';
+                const isWorkout = this.activity?.routeType === 'None';
                 const showSave = this.activity !== undefined && !this.isSaveDone;
                 const showContinue = this.state !== 'completed';
                 const hasGPX = this.activity?.logs?.some((log) => !!log.lat && !!log.lng);
-                const showMap = hasGPX || isFreeRide || (route?.description?.hasGpx);
+                const showMap = hasGPX || isFreeRide || isWorkout || (route?.description?.hasGpx);
                 const preview = showMap ? undefined : route?.description?.previewUrl;
                 if (!this.isSummaryShown) {
                     this.logEvent({ message: 'activity summary shown', showSave, showContinue, showMap, fileLink: this.activity?.fitFileName });

package/lib/cjs/workouts/base/graph/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./series"), exports);
+__exportStar(require("./types"), exports);

package/lib/cjs/workouts/base/graph/series.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKOUT_ZONE_COLORS = void 0;
+exports.getStepDuration = getStepDuration;
+exports.getStepPower = getStepPower;
+exports.getWorkoutGraphSeries = getWorkoutGraphSeries;
+const model_1 = require("../model");
+exports.WORKOUT_ZONE_COLORS = [
+    'white',
+    '#7f7f7f',
+    '#338cff',
+    '#59bf59',
+    '#ffcc3f',
+    '#ff6639',
+    '#ff330c',
+    '#ea39ff'
+];
+function getMinPower(step, ftp) {
+    if (step?.power === undefined)
+        return undefined;
+    const p = step.power;
+    if (p.max !== undefined && p.min !== undefined && p.max === p.min)
+        return 0;
+    if (p.min === undefined)
+        return undefined;
+    let res = Math.round(p.min);
+    if (p.type === 'watt' && ftp !== undefined)
+        res = Math.round(p.min / ftp * 100);
+    return res;
+}
+function getMaxPower(step, ftp) {
+    if (step?.power === undefined)
+        return 0;
+    const p = step.power;
+    if (p.max === undefined)
+        return undefined;
+    let res = Math.round(p.max);
+    if (p.type === 'watt' && ftp !== undefined)
+        res = Math.round(p.max / ftp * 100);
+    return res;
+}
+function getZone(power, ftp) {
+    if (power === undefined)
+        return undefined;
+    if (ftp === undefined)
+        return 0;
+    if (power <= 55)
+        return 1;
+    if (power <= 75)
+        return 2;
+    if (power <= 90)
+        return 3;
+    if (power <= 105)
+        return 4;
+    if (power <= 120)
+        return 5;
+    if (power <= 150)
+        return 6;
+    return 7;
+}
+function getStepDuration(step) {
+    if (step.duration <= 60)
+        return `${step.duration}s`;
+    if (step.duration <= 3600)
+        return `${step.duration / 60}min`;
+    return `${step.duration / 3600}h`;
+}
+function formatPowerText(low, high, unit, rangePrefix) {
+    if (low !== undefined && high !== undefined && low !== high)
+        return `${rangePrefix}${Math.round(low)}-${Math.round(high)}${unit}`;
+    if (high !== undefined)
+        return `${Math.round(high)}${unit}`;
+    return '';
+}
+function appendConvertedSuffix(text, low, high, unit, ftp) {
+    if (text === '' || ftp === undefined)
+        return text;
+    const isPct = unit === '%';
+    const convert = (v) => isPct ? Math.round(v / 100 * ftp) : Math.round(v * 100 / ftp);
+    const suffixUnit = isPct ? 'W' : '%';
+    const range = (low !== undefined && high !== undefined && low !== high)
+        ? `${convert(low)}-${convert(high)}`
+        : `${convert(high)}`;
+    return `${text} (${range}${suffixUnit})`;
+}
+function getStepPower(step, ftp) {
+    if (step.power === undefined)
+        return '';
+    const { min, max, type } = step.power;
+    const unit = type === 'watt' ? 'W' : '%';
+    const ascending = step.steady || step.cooldown === false;
+    const low = ascending ? min : max;
+    const high = ascending ? max : min;
+    const rangePrefix = step.steady ? '' : 'Ramp ';
+    const stepText = formatPowerText(low, high, unit, rangePrefix);
+    return appendConvertedSuffix(stepText, low, high, unit, ftp);
+}
+function coerceToWorkout(workout) {
+    if (workout instanceof model_1.Workout)
+        return workout;
+    try {
+        return new model_1.Workout(workout);
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildSteadyBar(step, stepStart, ftp, absValues) {
+    const x0 = stepStart;
+    const x = stepStart + step.getDuration();
+    let y = getMaxPower(step, ftp);
+    let y0 = getMinPower(step, ftp);
+    const zone = getZone(y, ftp);
+    if (absValues && ftp) {
+        y = ftp * y / 100;
+        y0 = ftp * y0 / 100;
+    }
+    if (y === undefined || Number.isNaN(y))
+        return undefined;
+    if (y0 !== undefined && !Number.isNaN(y0))
+        return { x, x0, y, y0, zone };
+    if (y0 === undefined)
+        return { x, x0, y, y0: 0, zone };
+    return undefined;
+}
+function buildRampBars(wo, step, stepStart, ftp, absValues) {
+    const bars = [];
+    const stepSize = step.getDuration() / 10;
+    for (let i = 0; i < 10; i++) {
+        const x0 = stepStart + i * stepSize;
+        const x = x0 + stepSize;
+        const limit = wo.getLimits(x0 + 0.01);
+        let y = getMaxPower(limit, ftp);
+        const zone = getZone(y, ftp);
+        if (absValues && ftp)
+            y = ftp * y / 100;
+        if (y !== undefined && !Number.isNaN(y))
+            bars.push({ x, x0, y, y0: 0, zone });
+    }
+    return bars;
+}
+function getWorkoutGraphSeries(workout, opts) {
+    const { ftp, absValues = false } = opts ?? {};
+    const wo = coerceToWorkout(workout);
+    if (!wo)
+        return [];
+    const bars = [];
+    let stepStart = 0;
+    for (let limits = wo.getLimits(0, true); limits !== undefined; limits = wo.getLimits(stepStart + 0.01, true)) {
+        const step = limits.step;
+        if (step.steady) {
+            const bar = buildSteadyBar(step, stepStart, ftp, absValues);
+            if (bar)
+                bars.push(bar);
+        }
+        else {
+            bars.push(...buildRampBars(wo, step, stepStart, ftp, absValues));
+        }
+        stepStart += step.getDuration();
+    }
+    return bars;
+}

package/lib/cjs/workouts/base/graph/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/workouts/base/model/index.js

@@ -17,4 +17,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Workout"), exports);
 __exportStar(require("./Segment"), exports);
 __exportStar(require("./Step"), exports);
-__exportStar(require("./types"), exports);

package/lib/cjs/workouts/calendar/service.js

@@ -136,6 +136,20 @@ let WorkoutCalendarService = (() => {
             }
             return [];
         }
+        getScheduledToday() {
+            try {
+                if (!this.workouts)
+                    return undefined;
+                const now = new Date();
+                const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+                const entry = this.workouts.find(w => w.day?.toLocaleDateString() === today.toLocaleDateString());
+                return entry ? this.getScheduledWorkout(entry) : undefined;
+            }
+            catch (err) {
+                this.logError(err, 'getScheduledToday');
+                return undefined;
+            }
+        }
         setActive(active) {
             try {
                 this.listActive = active;

package/lib/cjs/workouts/index.js

@@ -17,3 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./list"), exports);
 __exportStar(require("./ride"), exports);
 __exportStar(require("./base/model"), exports);
+__exportStar(require("./base/graph"), exports);
+__exportStar(require("./page"), exports);

package/lib/cjs/workouts/list/cards/index.js

@@ -17,4 +17,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./WorkoutCreateCard"), exports);
 __exportStar(require("./WorkoutImportCard"), exports);
 __exportStar(require("./WorkoutCard"), exports);
-__exportStar(require("./types"), exports);

package/lib/cjs/workouts/list/index.js

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./service"), exports);
 __exportStar(require("./cards"), exports);
-__exportStar(require("./pageService"), exports);

package/lib/cjs/workouts/list/pageService.js

@@ -39,6 +39,12 @@ const types_1 = require("../../base/types");
 const pages_1 = require("../../base/pages");
 const decorators_1 = require("../../base/decorators");
 const appstate_1 = require("../../appstate");
+const observer_1 = require("../../base/types/observer");
+const settings_1 = require("../../settings");
+const calendar_1 = require("../calendar");
+const service_1 = require("./service");
+const DEFAULT_IMPORT_GROUP = 'My Workouts';
+const UPCOMING_COLLAPSED_COUNT = 3;
 let WorkoutListPageService = (() => {
     let _classDecorators = [types_1.Singleton];
     let _classDescriptor;
@@ -46,34 +52,66 @@ let WorkoutListPageService = (() => {
     let _classThis;
     let _classSuper = pages_1.IncyclistPageService;
     let _instanceExtraInitializers = [];
+    let _getWorkoutList_decorators;
+    let _getWorkoutCalendar_decorators;
+    let _getUserSettings_decorators;
     let _getAppState_decorators;
     var WorkoutListPageService = class extends _classSuper {
         static { _classThis = this; }
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _getWorkoutList_decorators = [decorators_1.Injectable];
+            _getWorkoutCalendar_decorators = [decorators_1.Injectable];
+            _getUserSettings_decorators = [decorators_1.Injectable];
             _getAppState_decorators = [decorators_1.Injectable];
+            __esDecorate(this, null, _getWorkoutList_decorators, { kind: "method", name: "getWorkoutList", static: false, private: false, access: { has: obj => "getWorkoutList" in obj, get: obj => obj.getWorkoutList }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getWorkoutCalendar_decorators, { kind: "method", name: "getWorkoutCalendar", static: false, private: false, access: { has: obj => "getWorkoutCalendar" in obj, get: obj => obj.getWorkoutCalendar }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getUserSettings_decorators, { kind: "method", name: "getUserSettings", static: false, private: false, access: { has: obj => "getUserSettings" in obj, get: obj => obj.getUserSettings }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getAppState_decorators, { kind: "method", name: "getAppState", static: false, private: false, access: { has: obj => "getAppState" in obj, get: obj => obj.getAppState }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             WorkoutListPageService = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
+        groupFilter = (__runInitializers(this, _instanceExtraInitializers), null);
+        importPhase;
+        importGroup;
+        importingFileName;
+        importResult;
+        importError;
+        listObserver;
+        listUpdateHandler = this.emitPageUpdate.bind(this);
+        calendarUpdateHandler = this.emitPageUpdate.bind(this);
         constructor() {
             super('WorkoutListPage');
-            __runInitializers(this, _instanceExtraInitializers);
         }
         openPage() {
             try {
                 super.openPage();
                 this.logEvent({ message: 'page shown', page: 'Workouts' });
-                return this.getPageObserver();
+                const { observer } = this.getWorkoutList().open();
+                this.listObserver = observer;
+                this.listObserver?.on('started', this.listUpdateHandler);
+                this.listObserver?.on('loading', this.listUpdateHandler);
+                this.listObserver?.on('loaded', this.listUpdateHandler);
+                this.listObserver?.on('updated', this.listUpdateHandler);
+                this.getWorkoutCalendar().on('updated', this.calendarUpdateHandler);
+                this.emitPageUpdate();
             }
             catch (err) {
                 this.logError(err, 'openPage');
             }
+            return this.getPageObserver();
         }
         closePage() {
             try {
+                this.getWorkoutList().close();
+                this.listObserver?.off('started', this.listUpdateHandler);
+                this.listObserver?.off('loading', this.listUpdateHandler);
+                this.listObserver?.off('loaded', this.listUpdateHandler);
+                this.listObserver?.off('updated', this.listUpdateHandler);
+                this.getWorkoutCalendar().off('updated', this.calendarUpdateHandler);
+                delete this.listObserver;
                 this.logEvent({ message: 'page closed', page: 'Workouts' });
                 super.closePage();
             }
@@ -82,10 +120,329 @@ let WorkoutListPageService = (() => {
             }
         }
         getPageDisplayProps() {
-            if (!this.getAppState().hasFeature('MOBILE_WORKOUTS')) {
-                return { pageType: 'placeholder' };
+            try {
+                if (!this.getAppState().hasFeature('MOBILE_WORKOUTS')) {
+                    return { pageType: 'placeholder' };
+                }
+                const service = this.getWorkoutList();
+                const loading = service.isStillLoading();
+                const upcoming = this.getUpcomingTrainingProps();
+                const allWorkouts = this.getAllWorkoutItems();
+                const groups = this.getGroupFilterProps();
+                const workouts = groups.selected ? allWorkouts.filter(w => w.group === groups.selected) : allWorkouts;
+                const selectedId = service.getSelected()?.id ?? null;
+                const isEmpty = allWorkouts.length === 0;
+                return { pageType: 'list', loading, upcoming, groups, workouts, selectedId, isEmpty };
+            }
+            catch (err) {
+                this.logError(err, 'getPageDisplayProps');
+                return {};
+            }
+        }
+        getWorkoutDetailsProps(id) {
+            try {
+                const card = this.findWorkoutCard(id);
+                if (!card)
+                    return null;
+                const workout = card.getData();
+                const settingsProps = card.openSettings();
+                const isScheduled = card.getCardType() === 'ScheduledWorkout';
+                return {
+                    id,
+                    title: card.getTitle(),
+                    description: workout?.description,
+                    duration: settingsProps.duration,
+                    workout,
+                    ftp: settingsProps.settings?.ftp,
+                    ftpRequired: settingsProps.ftpRequired,
+                    useErgMode: settingsProps.settings?.useErgMode,
+                    canStart: settingsProps.canStart,
+                    canStartWorkoutOnly: settingsProps.canStartWorkoutOnly,
+                    groups: settingsProps.categories,
+                    group: settingsProps.category,
+                    canDelete: card.canDelete(),
+                    isScheduled,
+                    date: isScheduled ? settingsProps.date : undefined
+                };
+            }
+            catch (err) {
+                this.logError(err, 'getWorkoutDetailsProps');
+                return null;
+            }
+        }
+        getImportDisplayProps() {
+            try {
+                const phase = this.importPhase ?? 'landing';
+                const knownGroups = this.getKnownGroups();
+                const group = this.importGroup ?? this.getLastUsedImportGroup();
+                const props = { phase, group, knownGroups };
+                if (phase === 'importing')
+                    props.importing = { fileName: this.importingFileName };
+                if (phase === 'result')
+                    props.result = this.importResult;
+                if (phase === 'error')
+                    props.error = this.importError;
+                return props;
+            }
+            catch (err) {
+                this.logError(err, 'getImportDisplayProps');
+                return { phase: 'landing', group: DEFAULT_IMPORT_GROUP, knownGroups: [] };
+            }
+        }
+        onSelectGroup(group) {
+            try {
+                this.groupFilter = group;
+                this.emitPageUpdate();
+            }
+            catch (err) {
+                this.logError(err, 'onSelectGroup');
             }
-            return { pageType: 'list' };
+        }
+        onOpenDetails(id) {
+            this.logEvent({ message: 'details opened', id });
+        }
+        onCloseDetails() {
+            this.logEvent({ message: 'details closed' });
+        }
+        onSetFtp(ftp) {
+            try {
+                const current = this.getWorkoutList().getStartSettings();
+                this.getWorkoutList().setStartSettings({ ...current, ftp });
+                this.emitPageUpdate();
+            }
+            catch (err) {
+                this.logError(err, 'onSetFtp');
+            }
+        }
+        onSetErgMode(enabled) {
+            try {
+                const current = this.getWorkoutList().getStartSettings();
+                this.getWorkoutList().setStartSettings({ ...current, useErgMode: enabled });
+                this.emitPageUpdate();
+            }
+            catch (err) {
+                this.logError(err, 'onSetErgMode');
+            }
+        }
+        onChangeGroup(id, group) {
+            try {
+                const card = this.findWorkoutCard(id);
+                card?.move(group);
+                this.emitPageUpdate();
+            }
+            catch (err) {
+                this.logError(err, 'onChangeGroup');
+            }
+        }
+        async onDelete(id) {
+            try {
+                const observer = this.getWorkoutList().deleteWorkout(id);
+                const deleted = await observer.wait();
+                this.emitPageUpdate();
+                return !!deleted;
+            }
+            catch (err) {
+                this.logError(err, 'onDelete');
+                return false;
+            }
+        }
+        onStart(id, opts) {
+            try {
+                const card = this.findWorkoutCard(id);
+                if (!card)
+                    return;
+                const settings = this.getWorkoutList().getStartSettings();
+                card.select({ ...settings, noRoute: opts?.noRoute });
+                this.getPageObserver()?.emit('start-ride', { id, noRoute: opts?.noRoute });
+            }
+            catch (err) {
+                this.logError(err, 'onStart');
+            }
+        }
+        onMarkForRoute(id) {
+            try {
+                const card = this.findWorkoutCard(id);
+                if (!card)
+                    return;
+                const settings = this.getWorkoutList().getStartSettings();
+                card.select({ ...settings, noRoute: false });
+                this.emitPageUpdate();
+            }
+            catch (err) {
+                this.logError(err, 'onMarkForRoute');
+            }
+        }
+        onClearSelection() {
+            try {
+                this.getWorkoutList().unselect();
+                this.emitPageUpdate();
+            }
+            catch (err) {
+                this.logError(err, 'onClearSelection');
+            }
+        }
+        onImportOpen() {
+            try {
+                this.importPhase = 'landing';
+                this.importGroup = this.getLastUsedImportGroup();
+                delete this.importError;
+                delete this.importResult;
+                this.emitImportUpdate();
+            }
+            catch (err) {
+                this.logError(err, 'onImportOpen');
+            }
+        }
+        onImportGroupChange(name) {
+            try {
+                this.importGroup = name;
+                this.emitImportUpdate();
+            }
+            catch (err) {
+                this.logError(err, 'onImportGroupChange');
+            }
+        }
+        onImportFile(file) {
+            const observer = new observer_1.Observer();
+            try {
+                const group = this.importGroup;
+                this.importPhase = 'importing';
+                this.importingFileName = file?.name;
+                this.emitImportUpdate();
+                this.getWorkoutList().import(file, { showImportCards: false })
+                    .then(([card]) => {
+                    if (group && group !== DEFAULT_IMPORT_GROUP)
+                        card.move(group);
+                    this.persistLastUsedImportGroup(group);
+                    this.importPhase = 'result';
+                    this.importResult = { workoutName: card.getTitle(), group };
+                    observer.emit('success');
+                    this.emitImportUpdate();
+                })
+                    .catch((err) => {
+                    this.importPhase = 'error';
+                    this.importError = err?.message;
+                    observer.emit('error', err);
+                    this.emitImportUpdate();
+                });
+            }
+            catch (err) {
+                this.logError(err, 'onImportFile');
+            }
+            return observer;
+        }
+        onImportClose() {
+            try {
+                delete this.importPhase;
+                delete this.importingFileName;
+                delete this.importResult;
+                delete this.importError;
+                this.emitImportUpdate();
+            }
+            catch (err) {
+                this.logError(err, 'onImportClose');
+            }
+        }
+        getUpcomingTrainingProps() {
+            const calendar = this.getWorkoutCalendar();
+            const scheduled = calendar.getScheduledWorkouts();
+            if (!scheduled || scheduled.length === 0)
+                return null;
+            const todayId = calendar.getScheduledToday()?.id ?? null;
+            const selectedWorkout = this.getWorkoutList().getSelected();
+            const items = scheduled.map(w => ({
+                id: w.id,
+                title: w.workout?.name,
+                date: w.day,
+                duration: this.formatDuration(w.workout?.duration),
+                isToday: todayId !== null && w.id === todayId,
+                selected: selectedWorkout?.id !== undefined && selectedWorkout.id === w.workout?.id,
+                workout: w.workout
+            }));
+            return { items, collapsedCount: UPCOMING_COLLAPSED_COUNT, todayId };
+        }
+        getGroupFilterProps() {
+            const available = this.getKnownGroups();
+            return { available, selected: this.groupFilter };
+        }
+        getKnownGroups() {
+            const lists = this.getWorkoutList().getLists(false) ?? [];
+            return lists.filter(l => l.getId() !== 'scheduled').map(l => l.getTitle());
+        }
+        getAllWorkoutItems() {
+            const lists = this.getWorkoutList().getLists(false) ?? [];
+            const items = [];
+            lists.forEach(list => {
+                if (list.getId() === 'scheduled')
+                    return;
+                list.getCards().forEach(card => {
+                    if (card.getCardType() !== 'Workout')
+                        return;
+                    const workoutCard = card;
+                    const props = workoutCard.getDisplayProperties();
+                    items.push({
+                        id: workoutCard.getId(),
+                        title: props.title,
+                        group: list.getTitle(),
+                        duration: props.duration,
+                        selected: props.selected,
+                        canDelete: props.canDelete,
+                        workout: props.workout
+                    });
+                });
+            });
+            return items;
+        }
+        findWorkoutCard(id) {
+            const lists = this.getWorkoutList().getLists(false) ?? [];
+            for (const list of lists) {
+                const card = list.getCards().find(c => c.getId() === id);
+                if (card)
+                    return card;
+            }
+            return undefined;
+        }
+        getLastUsedImportGroup() {
+            return this.getUserSettings().get('preferences.workouts.lastImportGroup', DEFAULT_IMPORT_GROUP);
+        }
+        persistLastUsedImportGroup(group) {
+            try {
+                this.getUserSettings().set('preferences.workouts.lastImportGroup', group);
+            }
+            catch (err) {
+                this.logError(err, 'persistLastUsedImportGroup');
+            }
+        }
+        formatDuration(duration) {
+            if (duration === undefined || duration === null)
+                return '';
+            if (duration < 120)
+                return `${duration.toFixed(0)}s`;
+            if (duration % 60 === 0)
+                return `${duration / 60}min`;
+            const secVal = duration % 60;
+            const minVal = (duration - secVal) / 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)
+                return `${h}:${min}:${sec}`;
+            return `${min}:${sec}`;
+        }
+        emitPageUpdate() {
+            this.getPageObserver()?.emit('page-update');
+        }
+        emitImportUpdate() {
+            this.getPageObserver()?.emit('import-update');
+        }
+        getWorkoutList() {
+            return (0, service_1.useWorkoutList)();
+        }
+        getWorkoutCalendar() {
+            return (0, calendar_1.useWorkoutCalendar)();
+        }
+        getUserSettings() {
+            return (0, settings_1.useUserSettings)();
         }
         getAppState() {
             return (0, appstate_1.useAppState)();