incyclist-services 1.7.76 → 1.7.77

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

@@ -0,0 +1,500 @@
+"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) {
+            if (!current)
+                return { current: null, upcoming: [] };
+            const limits = this.getWorkoutRide().getCurrentLimits();
+            if (!limits)
+                return { current: null, upcoming: [] };
+            const currentStep = {
+                label: this.formatCurrentStepLabel(limits),
+                targetPower: limits.targetPower ?? null,
+                duration: limits.duration,
+                remaining: limits.remaining,
+                isCurrent: true
+            };
+            const elapsedTime = this.getElapsedActivityTime();
+            const steps = current.steps ?? [];
+            const currentIndex = steps.findIndex(s => s.start <= elapsedTime && s.end > elapsedTime);
+            const upcoming = currentIndex === -1
+                ? []
+                : steps.slice(currentIndex + 1, currentIndex + 1 + UPCOMING_STEPS_COUNT).map(step => ({
+                    label: (0, graph_1.getStepPower)(step, ftp) || 'free',
+                    targetPower: this.getStepAbsolutePower(step, ftp),
+                    duration: step.duration,
+                    remaining: null,
+                    isCurrent: false
+                }));
+            return { current: currentStep, upcoming };
+        }
+        buildDashboardLine(wo) {
+            const limits = this.getWorkoutRide().getCurrentLimits();
+            return {
+                targetPower: limits?.targetPower ?? null,
+                targetDuration: limits?.duration ?? 0,
+                remaining: limits?.remaining ?? 0,
+                text: wo.title ?? '',
+                mode: wo.mode ?? null
+            };
+        }
+        formatCurrentStepLabel(limits) {
+            if (limits.targetPower === undefined || limits.targetPower === null)
+                return 'free';
+            if (limits.minPower !== undefined && limits.maxPower !== undefined && limits.minPower !== limits.maxPower)
+                return `${Math.round(limits.minPower)}-${Math.round(limits.maxPower)}W`;
+            return `${Math.round(limits.targetPower)}W`;
+        }
+        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: { current: null, upcoming: [] },
+                dashboard: { targetPower: null, targetDuration: 0, remaining: 0, 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/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';

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

@@ -0,0 +1,156 @@
+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 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 getWorkoutGraphSeries(workout, opts) {
+    const { ftp, absValues = false } = opts ?? {};
+    const wo = coerceToWorkout(workout);
+    if (!wo)
+        return [];
+    const bars = [];
+    let stepStart = 0;
+    for (let limits = wo.getLimits(0, true); limits !== undefined; limits = wo.getLimits(stepStart + 0.01, true)) {
+        const step = limits.step;
+        if (step.steady) {
+            const bar = buildSteadyBar(step, stepStart, ftp, absValues);
+            if (bar)
+                bars.push(bar);
+        }
+        else {
+            bars.push(...buildRampBars(wo, step, stepStart, ftp, absValues));
+        }
+        stepStart += step.getDuration();
+    }
+    return bars;
+}