incyclist-services 1.7.76 → 1.7.78

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

@@ -32,6 +32,7 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
+import { getBindings } from "../../api";
 import { CardList } from "../../base/cardlist";
 import { IncyclistService } from "../../base/service";
 import { ListObserver, Singleton } from "../../base/types";
@@ -57,14 +58,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 = [Injectable];
             _getAppState_decorators = [Injectable];
+            _getBindings_decorators = [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 });
@@ -81,6 +85,7 @@ let WorkoutListService = (() => {
         language;
         selectedWorkout;
         ftp;
+        useErgModeOverride;
         scheduledToday;
         scheduledList;
         selectedCard;
@@ -167,7 +172,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;
             }
@@ -178,8 +184,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) {
@@ -234,7 +239,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()
@@ -336,13 +343,15 @@ let WorkoutListService = (() => {
         getScheduledWorkouts(scheduled) {
             const schedList = new CardList('scheduled', 'Scheduled Workouts');
             scheduled.forEach(w => schedList.add(new 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) {
@@ -427,7 +436,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;
@@ -441,6 +450,18 @@ let WorkoutListService = (() => {
                 this.logError(err, 'moveCard');
             }
         }
+        deleteWorkout(id) {
+            try {
+                const { card } = this.findCard(id) ?? {};
+                if (!card)
+                    return PromiseObserver.alwaysReturning(false);
+                return card.delete();
+            }
+            catch (err) {
+                this.logError(err, 'deleteWorkout');
+                return PromiseObserver.alwaysReturning(false);
+            }
+        }
         canDisplayStart() {
             const routes = this.getRouteList();
             return valid(routes.getSelected());
@@ -645,6 +666,12 @@ let WorkoutListService = (() => {
         getAppState() {
             return useAppState();
         }
+        isMobile() {
+            return this.getBindings()?.appInfo?.getChannel() === 'mobile';
+        }
+        getBindings() {
+            return getBindings();
+        }
         getRepo() {
             if (!this.db)
                 this.db = new WorkoutsDbLoader();

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

@@ -0,0 +1 @@
+export * from './service';

package/lib/esm/workouts/page/service.js

@@ -0,0 +1,451 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Singleton } from "../../base/types";
+import { IncyclistPageService } from "../../base/pages";
+import { Injectable } from "../../base/decorators";
+import { useAppState } from "../../appstate";
+import { Observer } from "../../base/types/observer";
+import { useUserSettings } from "../../settings";
+import { useWorkoutCalendar } from "../calendar";
+import { useWorkoutList } from "../list/service";
+const DEFAULT_IMPORT_GROUP = 'My Workouts';
+const UPCOMING_COLLAPSED_COUNT = 3;
+let WorkoutListPageService = (() => {
+    let _classDecorators = [Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = 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 = [Injectable];
+            _getWorkoutCalendar_decorators = [Injectable];
+            _getUserSettings_decorators = [Injectable];
+            _getAppState_decorators = [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');
+        }
+        openPage() {
+            try {
+                super.openPage();
+                this.logEvent({ message: 'page shown', page: 'Workouts' });
+                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();
+            }
+            catch (err) {
+                this.logError(err, 'closePage');
+            }
+        }
+        getPageDisplayProps() {
+            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');
+            }
+        }
+        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();
+            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 useWorkoutList();
+        }
+        getWorkoutCalendar() {
+            return useWorkoutCalendar();
+        }
+        getUserSettings() {
+            return useUserSettings();
+        }
+        getAppState() {
+            return useAppState();
+        }
+    };
+    return WorkoutListPageService = _classThis;
+})();
+export { WorkoutListPageService };
+export const getWorkoutListPageService = () => new WorkoutListPageService();

package/lib/esm/workouts/page/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/workouts/ride/index.js

@@ -1,2 +1,3 @@
 export * from './service';
 export * from './types';
+export * from './page';

package/lib/esm/workouts/ride/page/index.js

@@ -0,0 +1,2 @@
+export * from './service';
+export * from './types';