incyclist-services 1.7.76 → 1.7.78

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

@@ -0,0 +1,455 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkoutListPageService = exports.WorkoutListPageService = void 0;
+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("../list/service");
+const DEFAULT_IMPORT_GROUP = 'My Workouts';
+const UPCOMING_COLLAPSED_COUNT = 3;
+let WorkoutListPageService = (() => {
+    let _classDecorators = [types_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    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');
+        }
+        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_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)();
+        }
+    };
+    return WorkoutListPageService = _classThis;
+})();
+exports.WorkoutListPageService = WorkoutListPageService;
+const getWorkoutListPageService = () => new WorkoutListPageService();
+exports.getWorkoutListPageService = getWorkoutListPageService;

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

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

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

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

package/lib/cjs/workouts/ride/page/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("./service"), exports);
+__exportStar(require("./types"), exports);