incyclist-services 1.7.76 → 1.7.78

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)();

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

@@ -35,6 +35,7 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWorkoutList = exports.useWorkoutList = exports.WorkoutListService = void 0;
+const api_1 = require("../../api");
 const cardlist_1 = require("../../base/cardlist");
 const service_1 = require("../../base/service");
 const types_1 = require("../../base/types");
@@ -60,14 +61,17 @@ let WorkoutListService = (() => {
     let _instanceExtraInitializers = [];
     let _getWorkoutCalendar_decorators;
     let _getAppState_decorators;
+    let _getBindings_decorators;
     var WorkoutListService = class extends _classSuper {
         static { _classThis = this; }
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _getWorkoutCalendar_decorators = [decorators_1.Injectable];
             _getAppState_decorators = [decorators_1.Injectable];
+            _getBindings_decorators = [decorators_1.Injectable];
             __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, _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(this, null, _getBindings_decorators, { kind: "method", name: "getBindings", static: false, private: false, access: { has: obj => "getBindings" in obj, get: obj => obj.getBindings }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             WorkoutListService = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -84,6 +88,7 @@ let WorkoutListService = (() => {
         language;
         selectedWorkout;
         ftp;
+        useErgModeOverride;
         scheduledToday;
         scheduledList;
         selectedCard;
@@ -170,7 +175,8 @@ let WorkoutListService = (() => {
             let useErgMode = true;
             try {
                 const userSettings = this.getUserSettings();
-                useErgMode = userSettings.get('preferences.useErgMode', true);
+                const globalErgMode = userSettings.get('preferences.useErgMode', true);
+                useErgMode = this.useErgModeOverride ?? globalErgMode;
                 const user = userSettings.get('user', undefined);
                 ftp = this.ftp ?? user?.ftp ?? 200;
             }
@@ -181,8 +187,7 @@ let WorkoutListService = (() => {
         }
         setStartSettings(settings) {
             try {
-                const userSettings = this.getUserSettings();
-                userSettings.set('preferences.useErgMode', settings?.useErgMode);
+                this.useErgModeOverride = settings?.useErgMode;
                 this.ftp = settings?.ftp;
             }
             catch (err) {
@@ -237,7 +242,9 @@ let WorkoutListService = (() => {
                     this.getWorkoutCalendar().once('scheduled', (event) => {
                         this.scheduledToday = event;
                         this.getAppState().setState('scheduledToday', event.workout.id);
-                        this.getAppState().setPersistedState('page', 'workouts');
+                        if (!this.isMobile()) {
+                            this.getAppState().setPersistedState('page', 'workouts');
+                        }
                     });
                     this.getWorkoutCalendar().init();
                     this.preloadObserver.start()
@@ -339,13 +346,15 @@ let WorkoutListService = (() => {
         getScheduledWorkouts(scheduled) {
             const schedList = new cardlist_1.CardList('scheduled', 'Scheduled Workouts');
             scheduled.forEach(w => schedList.add(new ScheduledWorkoutCard_1.ScheduledWorkoutCard(w)));
-            const today = this.getAppState().getState('scheduledToday');
-            if (today) {
-                schedList.getCards().forEach(c => {
-                    if (c.getId() === today) {
-                        c.select();
-                    }
-                });
+            if (!this.isMobile()) {
+                const today = this.getAppState().getState('scheduledToday');
+                if (today) {
+                    schedList.getCards().forEach(c => {
+                        if (c.getId() === today) {
+                            c.select();
+                        }
+                    });
+                }
             }
             const newList = (this.scheduledList === undefined || this.scheduledList === null);
             if (newList) {
@@ -430,7 +439,7 @@ let WorkoutListService = (() => {
                 if (typeof target === 'string') {
                     targetList = this.lists.find(l => l.getTitle() === target);
                     if (!targetList)
-                        return;
+                        targetList = this.addList(target);
                 }
                 else {
                     targetList = target;
@@ -444,6 +453,18 @@ let WorkoutListService = (() => {
                 this.logError(err, 'moveCard');
             }
         }
+        deleteWorkout(id) {
+            try {
+                const { card } = this.findCard(id) ?? {};
+                if (!card)
+                    return observer_1.PromiseObserver.alwaysReturning(false);
+                return card.delete();
+            }
+            catch (err) {
+                this.logError(err, 'deleteWorkout');
+                return observer_1.PromiseObserver.alwaysReturning(false);
+            }
+        }
         canDisplayStart() {
             const routes = this.getRouteList();
             return (0, valid_1.valid)(routes.getSelected());
@@ -648,6 +669,12 @@ let WorkoutListService = (() => {
         getAppState() {
             return (0, appstate_1.useAppState)();
         }
+        isMobile() {
+            return this.getBindings()?.appInfo?.getChannel() === 'mobile';
+        }
+        getBindings() {
+            return (0, api_1.getBindings)();
+        }
         getRepo() {
             if (!this.db)
                 this.db = new db_1.WorkoutsDbLoader();

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

@@ -0,0 +1,17 @@
+"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("./service"), exports);