incyclist-services 1.7.76 → 1.7.78

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

@@ -0,0 +1,197 @@
+import { Workout } from "../model";
+export const 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;
+}
+export 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})`;
+}
+export 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 resolvePowerWatts(power, ftp) {
+    if (!power)
+        return {};
+    const toWatts = (v) => {
+        if (v === undefined)
+            return undefined;
+        if (power.type === 'watt')
+            return Math.round(v);
+        return ftp === undefined ? undefined : Math.round(v / 100 * ftp);
+    };
+    return { min: toWatts(power.min), max: toWatts(power.max) };
+}
+function formatRange(low, high, unit, rangePrefix = '') {
+    if (low !== undefined && high !== undefined && Math.round(low) !== Math.round(high))
+        return `${rangePrefix}${Math.round(low)}-${Math.round(high)}${unit}`;
+    const v = high ?? low;
+    return v === undefined ? '' : `${Math.round(v)}${unit}`;
+}
+export function getStepTargetText(step, ftp, powerOverrideWatts) {
+    const { min: minPower, max: maxPower } = powerOverrideWatts ?? resolvePowerWatts(step.power, ftp);
+    const ascending = step.steady || step.cooldown === false;
+    const lowPower = ascending ? minPower : maxPower;
+    const highPower = ascending ? maxPower : minPower;
+    const rangePrefix = step.steady ? '' : 'Ramp ';
+    const powerText = formatRange(lowPower, highPower, 'W', rangePrefix);
+    const hrText = formatRange(step.hrm?.min, step.hrm?.max, 'HR');
+    const cadenceText = formatRange(step.cadence?.min, step.cadence?.max, ' rpm');
+    const parts = [powerText, hrText, cadenceText].filter(Boolean);
+    return parts.length ? parts.join(' at ') : 'free';
+}
+function coerceToWorkout(workout) {
+    if (workout instanceof Workout)
+        return workout;
+    try {
+        return new 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;
+}
+export function getFlattenedSteps(workout) {
+    const wo = coerceToWorkout(workout);
+    if (!wo)
+        return [];
+    const result = [];
+    let stepStart = 0;
+    for (let limits = wo.getLimits(0, true); limits !== undefined; limits = wo.getLimits(stepStart + 0.01, true)) {
+        const step = limits.step;
+        const duration = step.getDuration();
+        result.push({ step, start: stepStart, end: stepStart + duration, duration });
+        stepStart += duration;
+    }
+    return result;
+}
+export function getWorkoutGraphSeries(workout, opts) {
+    const { ftp, absValues = false } = opts ?? {};
+    const wo = coerceToWorkout(workout);
+    if (!wo)
+        return [];
+    const bars = [];
+    getFlattenedSteps(wo).forEach(({ step, start: stepStart }) => {
+        if (step.steady) {
+            const bar = buildSteadyBar(step, stepStart, ftp, absValues);
+            if (bar)
+                bars.push(bar);
+        }
+        else {
+            bars.push(...buildRampBars(wo, step, stepStart, ftp, absValues));
+        }
+    });
+    return bars;
+}

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

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

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

@@ -1,4 +1,3 @@
 export * from './Workout';
 export * from './Segment';
 export * from './Step';
-export * from './types';

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

@@ -133,6 +133,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/esm/workouts/index.js

@@ -1,3 +1,5 @@
 export * from './list';
 export * from './ride';
 export * from './base/model';
+export * from './base/graph';
+export * from './page';

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

@@ -1,4 +1,3 @@
 export * from './WorkoutCreateCard';
 export * from './WorkoutImportCard';
 export * from './WorkoutCard';
-export * from './types';

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

@@ -1,3 +1,2 @@
 export * from './service';
 export * from './cards';
-export * from './pageService';

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

@@ -36,6 +36,12 @@ 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 "./service";
+const DEFAULT_IMPORT_GROUP = 'My Workouts';
+const UPCOMING_COLLAPSED_COUNT = 3;
 let WorkoutListPageService = (() => {
     let _classDecorators = [Singleton];
     let _classDescriptor;
@@ -43,34 +49,66 @@ let WorkoutListPageService = (() => {
     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');
-            __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();
             }
@@ -79,10 +117,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();
+            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();