incyclist-services 1.7.76 → 1.7.78

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

@@ -0,0 +1,498 @@
+"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.getWorkoutRidePageService = exports.WorkoutRidePageService = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const decorators_1 = require("../../../base/decorators");
+const types_1 = require("../../../base/types");
+const pages_1 = require("../../../base/pages");
+const display_1 = require("../../../ride/display");
+const activities_1 = require("../../../activities");
+const service_1 = require("../service");
+const graph_1 = require("../../base/graph");
+const BACKGROUND_PAUSE_TIMEOUT_MS = 300000;
+const UPCOMING_STEPS_COUNT = 3;
+const DEFAULT_LOAD_INCREMENT = 1;
+let WorkoutRidePageService = (() => {
+    let _classDecorators = [types_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = pages_1.IncyclistPageService;
+    let _instanceExtraInitializers = [];
+    let _getRideDisplay_decorators;
+    let _getWorkoutRide_decorators;
+    let _getActivityRide_decorators;
+    var WorkoutRidePageService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _getRideDisplay_decorators = [decorators_1.Injectable];
+            _getWorkoutRide_decorators = [decorators_1.Injectable];
+            _getActivityRide_decorators = [decorators_1.Injectable];
+            __esDecorate(this, null, _getRideDisplay_decorators, { kind: "method", name: "getRideDisplay", static: false, private: false, access: { has: obj => "getRideDisplay" in obj, get: obj => obj.getRideDisplay }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getWorkoutRide_decorators, { kind: "method", name: "getWorkoutRide", static: false, private: false, access: { has: obj => "getWorkoutRide" in obj, get: obj => obj.getWorkoutRide }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getActivityRide_decorators, { kind: "method", name: "getActivityRide", static: false, private: false, access: { has: obj => "getActivityRide" in obj, get: obj => obj.getActivityRide }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            WorkoutRidePageService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        rideEventHandler = (__runInitializers(this, _instanceExtraInitializers), {});
+        workoutEventHandler = {};
+        workoutObserverSubscribed = false;
+        backgroundTimer;
+        backgroundPausedByService = false;
+        menuProps = null;
+        isInitialized = false;
+        constructor() {
+            super('WorkoutRidePage');
+            this.rideEventHandler['state-update'] = this.onRideStateUpdate.bind(this);
+            this.workoutEventHandler['step-changed'] = this.onWorkoutUpdate.bind(this);
+            this.workoutEventHandler['update'] = this.onWorkoutUpdate.bind(this);
+            this.workoutEventHandler['forward'] = this.onWorkoutUpdate.bind(this);
+            this.workoutEventHandler['backward'] = this.onWorkoutUpdate.bind(this);
+            this.workoutEventHandler['completed'] = this.onWorkoutFinished.bind(this);
+            this.workoutEventHandler['stopped'] = this.onWorkoutFinished.bind(this);
+        }
+        openPage(simulate) {
+            try {
+                this.logEvent({ message: 'page shown', page: 'WorkoutRide' });
+                gd_eventlog_1.EventLogger.setGlobalConfig('page', 'WorkoutRide');
+                super.openPage();
+                try {
+                    const service = this.getRideDisplay();
+                    if (!this.isInitialized) {
+                        service.init();
+                        this.isInitialized = true;
+                    }
+                    this.registerRideEventHandlers();
+                    this.subscribeToWorkoutObserver();
+                    service.start(simulate);
+                }
+                catch (err) {
+                    this.logError(err, 'openPage');
+                }
+            }
+            catch (err) {
+                this.logError(err, 'openPage');
+            }
+            return this.getPageObserver();
+        }
+        closePage() {
+            try {
+                gd_eventlog_1.EventLogger.setGlobalConfig('page', null);
+                this.logEvent({ message: 'page closed', page: 'WorkoutRide' });
+                this.getRideDisplay().stop(true);
+                this.unregisterRideEventHandlers();
+                this.unsubscribeFromWorkoutObserver();
+                this.menuProps = null;
+                this.isInitialized = false;
+                super.closePage();
+            }
+            catch (err) {
+                this.logError(err, 'closePage');
+            }
+        }
+        async pausePage() {
+            try {
+                this.backgroundTimer = setTimeout(() => {
+                    this.getRideDisplay().pause('device');
+                    this.backgroundPausedByService = true;
+                }, BACKGROUND_PAUSE_TIMEOUT_MS);
+                return super.pausePage();
+            }
+            catch (err) {
+                this.logError(err, 'pausePage');
+            }
+        }
+        async resumePage() {
+            try {
+                if (this.backgroundTimer) {
+                    clearTimeout(this.backgroundTimer);
+                }
+                return super.resumePage();
+            }
+            catch (err) {
+                this.logError(err, 'resumePage');
+            }
+        }
+        getRideObserver() {
+            return this.rideObserver ?? null;
+        }
+        getPageDisplayProps() {
+            try {
+                const rideType = this.getRideDisplay().getRideType();
+                if (rideType !== 'Workout') {
+                    this.logError(new Error(`unexpected ride type '${rideType}' for WorkoutRidePage`), 'getPageDisplayProps');
+                    return this.getEmptyDisplayProps();
+                }
+                const base = this.buildBaseProps();
+                const wo = this.getWorkoutRide().getDashboardDisplayProperties();
+                const current = this.getRideDisplay().getDisplayProperties().workout;
+                return {
+                    ...base,
+                    title: wo.title ?? '',
+                    graph: this.buildGraphPlan(current, wo.ftp),
+                    steps: this.buildUpcomingSteps(current, wo.ftp),
+                    dashboard: this.buildDashboardLine(wo)
+                };
+            }
+            catch (err) {
+                this.logError(err, 'getPageDisplayProps');
+                return this.getEmptyDisplayProps();
+            }
+        }
+        getGraphActuals() {
+            try {
+                const state = this.getRideDisplay().getState();
+                if (state === 'Idle' || state === 'Starting' || state === 'Started') {
+                    return { power: [], heartrate: [], position: 0 };
+                }
+                const logs = this.getActivityRide().getActivity()?.logs ?? [];
+                const power = [];
+                const heartrate = [];
+                logs.forEach(log => {
+                    if (log.power !== undefined)
+                        power.push({ x: log.time, y: log.power });
+                    if (log.heartrate !== undefined)
+                        heartrate.push({ x: log.time, y: log.heartrate });
+                });
+                return { power, heartrate, position: this.getElapsedActivityTime() };
+            }
+            catch (err) {
+                this.logError(err, 'getGraphActuals');
+                return { power: [], heartrate: [], position: 0 };
+            }
+        }
+        onMenuOpen() {
+            try {
+                const state = this.getRideDisplay().getState();
+                this.menuProps = { showResume: state === 'Paused', ...this.getStepFlags() };
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onMenuOpen');
+            }
+        }
+        onMenuClose() {
+            try {
+                this.menuProps = null;
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onMenuClose');
+            }
+        }
+        onPause() {
+            try {
+                this.getRideDisplay().pause('user');
+                this.menuProps = { showResume: true, ...this.getStepFlags() };
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onPause');
+            }
+        }
+        onResume() {
+            try {
+                this.getRideDisplay().resume();
+                this.menuProps = null;
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onResume');
+            }
+        }
+        onStop() {
+            try {
+                this.getRideDisplay().stop(true);
+                this.emitNavigateBack();
+            }
+            catch (err) {
+                this.logError(err, 'onStop');
+            }
+        }
+        onStepBack() {
+            try {
+                this.getRideDisplay().backward();
+            }
+            catch (err) {
+                this.logError(err, 'onStepBack');
+            }
+        }
+        onStepForward() {
+            try {
+                this.getRideDisplay().forward();
+            }
+            catch (err) {
+                this.logError(err, 'onStepForward');
+            }
+        }
+        onIncreaseLoad() {
+            this.adjustLoad(DEFAULT_LOAD_INCREMENT);
+        }
+        onDecreaseLoad() {
+            this.adjustLoad(-DEFAULT_LOAD_INCREMENT);
+        }
+        onRetryStart() {
+            try {
+                this.getRideDisplay().retryStart();
+            }
+            catch (err) {
+                this.logError(err, 'onRetryStart');
+            }
+        }
+        onIgnoreStart() {
+            try {
+                this.getRideDisplay().startWithMissingSensors();
+            }
+            catch (err) {
+                this.logError(err, 'onIgnoreStart');
+            }
+        }
+        onCancelStart() {
+            try {
+                this.rideObserver?.stop();
+                this.getRideDisplay().cancelStart()
+                    .then(() => {
+                    this.moveToPreviousPage();
+                    this.closePage();
+                })
+                    .catch((err) => { this.logError(err, 'onCancelStart'); });
+            }
+            catch (err) {
+                this.logError(err, 'onCancelStart');
+            }
+        }
+        adjustLoad(deltaPct) {
+            try {
+                if (deltaPct >= 0)
+                    this.getWorkoutRide().powerUp(deltaPct);
+                else
+                    this.getWorkoutRide().powerDown(-deltaPct);
+            }
+            catch (err) {
+                this.logError(err, 'adjustLoad');
+            }
+        }
+        onRideStateUpdate(state) {
+            this.subscribeToWorkoutObserver();
+            switch (state) {
+                case 'Paused':
+                    this.menuProps = { showResume: true, ...this.getStepFlags() };
+                    this.updatePageDisplay();
+                    break;
+                case 'Active':
+                    this.menuProps = null;
+                    this.updatePageDisplay();
+                    break;
+                case 'Finished':
+                    this.emitNavigateBack();
+                    break;
+                case 'Error':
+                    this.updatePageDisplay();
+                    break;
+            }
+        }
+        onWorkoutUpdate() {
+            this.updatePageDisplay();
+        }
+        onWorkoutFinished() {
+            this.emitNavigateBack();
+        }
+        subscribeToWorkoutObserver() {
+            if (this.workoutObserverSubscribed)
+                return;
+            const observer = this.getWorkoutRide().getObserver();
+            if (!observer)
+                return;
+            Object.keys(this.workoutEventHandler).forEach(event => observer.on(event, this.workoutEventHandler[event]));
+            this.workoutObserverSubscribed = true;
+        }
+        unsubscribeFromWorkoutObserver() {
+            if (!this.workoutObserverSubscribed)
+                return;
+            const observer = this.getWorkoutRide().getObserver();
+            Object.keys(this.workoutEventHandler).forEach(event => observer?.off(event, this.workoutEventHandler[event]));
+            this.workoutObserverSubscribed = false;
+        }
+        registerRideEventHandlers() {
+            Object.keys(this.rideEventHandler).forEach(event => this.rideObserver?.on(event, this.rideEventHandler[event]));
+        }
+        unregisterRideEventHandlers() {
+            Object.keys(this.rideEventHandler).forEach(event => this.rideObserver?.off(event, this.rideEventHandler[event]));
+        }
+        buildBaseProps() {
+            const state = this.getRideDisplay().getState();
+            const isStarting = state === 'Idle' || state === 'Starting' || state === 'Error';
+            return {
+                rideState: state,
+                rideType: this.getRideDisplay().getRideType(),
+                startOverlayProps: isStarting ? this.getRideDisplay().getStartOverlayProps() : null,
+                menuProps: this.menuProps,
+                startGateProps: null
+            };
+        }
+        buildGraphPlan(current, ftp) {
+            if (!current) {
+                return { bars: [], ftp: ftp ?? 0, ftpLine: ftp ?? 0, domain: { x: [0, 0], y: [0, 0] } };
+            }
+            const bars = (0, graph_1.getWorkoutGraphSeries)(current, { ftp, absValues: true });
+            const lastBarX = bars.length ? bars.at(-1).x : 0;
+            const maxX = Math.max(this.getLastLogTime(), lastBarX, current.duration ?? 0);
+            const maxBarPower = bars.length ? Math.max(...bars.map(b => b.y)) : 0;
+            return {
+                bars,
+                ftp,
+                ftpLine: ftp,
+                domain: { x: [0, maxX], y: [0, maxBarPower * 1.1] }
+            };
+        }
+        buildUpcomingSteps(current, ftp) {
+            const empty = { previous: null, current: null, upcoming: [], hasMore: false };
+            if (!current)
+                return empty;
+            const limits = this.getWorkoutRide().getCurrentLimits();
+            if (!limits)
+                return empty;
+            const currentStep = {
+                label: (0, graph_1.getStepTargetText)(limits.step ?? {}, ftp, { min: limits.minPower, max: limits.maxPower }),
+                targetPower: limits.targetPower ?? null,
+                duration: limits.duration,
+                remaining: limits.remaining,
+                isCurrent: true
+            };
+            const elapsedTime = this.getElapsedActivityTime();
+            const flattened = (0, graph_1.getFlattenedSteps)(current);
+            const currentIndex = flattened.findIndex(s => s.start <= elapsedTime && s.end > elapsedTime);
+            const toDisplay = (entry) => ({
+                label: (0, graph_1.getStepTargetText)(entry.step, ftp),
+                targetPower: this.getStepAbsolutePower(entry.step, ftp),
+                duration: entry.duration,
+                remaining: null,
+                isCurrent: false
+            });
+            if (currentIndex === -1)
+                return { previous: null, current: currentStep, upcoming: [], hasMore: false };
+            const previous = currentIndex > 0 ? toDisplay(flattened[currentIndex - 1]) : null;
+            const upcomingEntries = flattened.slice(currentIndex + 1, currentIndex + 1 + UPCOMING_STEPS_COUNT);
+            const upcoming = upcomingEntries.map(toDisplay);
+            const hasMore = currentIndex + 1 + UPCOMING_STEPS_COUNT < flattened.length;
+            return { previous, current: currentStep, upcoming, hasMore };
+        }
+        buildDashboardLine(wo) {
+            const limits = this.getWorkoutRide().getCurrentLimits();
+            const title = wo.title ?? '';
+            if (!limits)
+                return { text: title, mode: wo.mode ?? null };
+            const target = (0, graph_1.getStepTargetText)(limits.step ?? {}, wo.ftp, { min: limits.minPower, max: limits.maxPower });
+            const duration = (0, graph_1.getStepDuration)({ duration: limits.duration });
+            const text = title ? `${target} for ${duration} - ${title}` : `${target} for ${duration}`;
+            return { text, mode: wo.mode ?? null };
+        }
+        getStepAbsolutePower(step, ftp) {
+            const p = step.power;
+            if (!p)
+                return null;
+            const val = p.max ?? p.min;
+            if (val === undefined)
+                return null;
+            if (p.type === 'watt')
+                return Math.round(val);
+            if (ftp === undefined)
+                return null;
+            return Math.round(val / 100 * ftp);
+        }
+        getStepFlags() {
+            const wo = this.getWorkoutRide().getDashboardDisplayProperties();
+            return { canStepBack: !!wo.canShowBackward, canStepForward: !!wo.canShowForward };
+        }
+        getLastLogTime() {
+            const logs = this.getActivityRide().getActivity()?.logs;
+            if (!logs || logs.length === 0)
+                return 0;
+            return logs.at(-1).time ?? 0;
+        }
+        getElapsedActivityTime() {
+            return this.getActivityRide().getActivity()?.time ?? 0;
+        }
+        getEmptyDisplayProps() {
+            return {
+                rideState: 'Error',
+                rideType: null,
+                startOverlayProps: null,
+                menuProps: null,
+                startGateProps: null,
+                title: '',
+                graph: { bars: [], ftp: 0, ftpLine: 0, domain: { x: [0, 0], y: [0, 0] } },
+                steps: { previous: null, current: null, upcoming: [], hasMore: false },
+                dashboard: { text: '', mode: null }
+            };
+        }
+        updatePageDisplay() {
+            this.getPageObserver()?.emit('page-update');
+        }
+        emitNavigateBack() {
+            this.getPageObserver()?.emit('navigate-back');
+        }
+        moveToPreviousPage() {
+            this.moveTo('$contentPage');
+        }
+        get rideObserver() {
+            try {
+                return this.getRideDisplay()?.getObserver();
+            }
+            catch (err) {
+                this.logError(err, 'get rideObserver');
+            }
+            return null;
+        }
+        getRideDisplay() {
+            return (0, display_1.useRideDisplay)();
+        }
+        getWorkoutRide() {
+            return (0, service_1.useWorkoutRide)();
+        }
+        getActivityRide() {
+            return (0, activities_1.useActivityRide)();
+        }
+    };
+    return WorkoutRidePageService = _classThis;
+})();
+exports.WorkoutRidePageService = WorkoutRidePageService;
+const getWorkoutRidePageService = () => new WorkoutRidePageService();
+exports.getWorkoutRidePageService = getWorkoutRidePageService;

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

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

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

@@ -498,7 +498,7 @@ let WorkoutRide = (() => {
             request.maxCadence = limits?.cadence?.max ? Math.round(limits.cadence.max) : undefined;
             request.minHrm = limits.hrm?.min ? Math.round(limits.hrm.min) : undefined;
             request.maxHrm = limits.hrm?.max ? Math.round(limits.hrm.max) : undefined;
-            this.currentLimits = { ...request, duration: limits.duration, remaining: limits.remaining };
+            this.currentLimits = { ...request, duration: limits.duration, remaining: limits.remaining, step: limits.step };
         }
         getZoomParameters(time) {
             let start, stop;

package/lib/cjs/workouts/types.js

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

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

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

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

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

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

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