incyclist-services 1.7.76 → 1.7.78

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

@@ -0,0 +1,494 @@
+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 { EventLogger } from "gd-eventlog";
+import { Injectable } from "../../../base/decorators";
+import { Singleton } from "../../../base/types";
+import { IncyclistPageService } from "../../../base/pages";
+import { useRideDisplay } from "../../../ride/display";
+import { useActivityRide } from "../../../activities";
+import { useWorkoutRide } from "../service";
+import { getFlattenedSteps, getStepDuration, getStepTargetText, getWorkoutGraphSeries } from "../../base/graph";
+const BACKGROUND_PAUSE_TIMEOUT_MS = 300000;
+const UPCOMING_STEPS_COUNT = 3;
+const DEFAULT_LOAD_INCREMENT = 1;
+let WorkoutRidePageService = (() => {
+    let _classDecorators = [Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = 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 = [Injectable];
+            _getWorkoutRide_decorators = [Injectable];
+            _getActivityRide_decorators = [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' });
+                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 {
+                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 = 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: 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 = getFlattenedSteps(current);
+            const currentIndex = flattened.findIndex(s => s.start <= elapsedTime && s.end > elapsedTime);
+            const toDisplay = (entry) => ({
+                label: 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 = getStepTargetText(limits.step ?? {}, wo.ftp, { min: limits.minPower, max: limits.maxPower });
+            const duration = 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 useRideDisplay();
+        }
+        getWorkoutRide() {
+            return useWorkoutRide();
+        }
+        getActivityRide() {
+            return useActivityRide();
+        }
+    };
+    return WorkoutRidePageService = _classThis;
+})();
+export { WorkoutRidePageService };
+export const getWorkoutRidePageService = () => new WorkoutRidePageService();

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

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

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

@@ -495,7 +495,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/esm/workouts/types.js

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

package/lib/types/types.d.ts

@@ -6,3 +6,4 @@ export type * from './activities/types';
 export type * from './ride/types';
 export type * from './settings/types';
 export type * from './apps/types';
+export type * from './workouts/types';

package/lib/types/workouts/base/graph/index.d.ts

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

package/lib/types/workouts/base/graph/series.d.ts

@@ -0,0 +1,18 @@
+import { Step, Workout } from "../model";
+import { StepDefinition } from "../model/types";
+import { WorkoutGraphPlanBar, WorkoutGraphSeriesOptions } from "./types";
+export declare const WORKOUT_ZONE_COLORS: string[];
+export declare function getStepDuration(step: StepDefinition): string;
+export declare function getStepPower(step: StepDefinition, ftp?: number): string;
+export declare function getStepTargetText(step: StepDefinition, ftp?: number, powerOverrideWatts?: {
+    min?: number;
+    max?: number;
+}): string;
+export interface FlattenedStep {
+    step: Step;
+    start: number;
+    end: number;
+    duration: number;
+}
+export declare function getFlattenedSteps(workout: Workout): FlattenedStep[];
+export declare function getWorkoutGraphSeries(workout: Workout, opts?: WorkoutGraphSeriesOptions): WorkoutGraphPlanBar[];

package/lib/types/workouts/base/graph/types.d.ts

@@ -0,0 +1,11 @@
+export interface WorkoutGraphPlanBar {
+    x0: number;
+    x: number;
+    y: number;
+    y0: number;
+    zone: number;
+}
+export interface WorkoutGraphSeriesOptions {
+    ftp?: number;
+    absValues?: boolean;
+}

package/lib/types/workouts/base/model/index.d.ts

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

package/lib/types/workouts/base/parsers/intervals/parser.d.ts

@@ -1,7 +1,8 @@
 import { EventLogger } from "gd-eventlog";
 import { WorkoutParser } from "../types";
 import { FileInfo } from "../../../../api";
-import { Limit, PowerLimit, SegmentDefinition, StepDefinition, Workout } from "../../model";
+import { Workout } from "../../model";
+import { Limit, PowerLimit, SegmentDefinition, StepDefinition } from "../../model/types";
 import { IntervalsStep, IntervalsValue, IntervalsWorkout } from "./types";
 export declare class IntervalsJsonParser implements WorkoutParser<string | IntervalsWorkout> {
     protected logger: EventLogger;

package/lib/types/workouts/calendar/service.d.ts

@@ -23,6 +23,7 @@ export declare class WorkoutCalendarService extends IncyclistService {
     reset(): void;
     isInitialized(): boolean;
     getScheduledWorkouts(): Array<ScheduledWorkout>;
+    getScheduledToday(): ScheduledWorkout | undefined;
     setActive(active: boolean): void;
     onAppConnected(app: string, success?: boolean): void;
     onAppDisconnected(app: string): void;

package/lib/types/workouts/index.d.ts

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

package/lib/types/workouts/list/cards/index.d.ts

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

package/lib/types/workouts/list/index.d.ts

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