incyclist-services 1.7.71 → 1.7.72

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

@@ -1362,8 +1362,15 @@ let DeviceRideService = (() => {
         canEnforceSimulator() {
             const selected = (0, routes_1.getRouteList)().getSelected();
             const personalApiKey = this.getGoogleMaps().hasPersonalApiKey();
+            if (!selected?.description)
+                return false;
             if (selected?.description?.hasVideo || personalApiKey)
                 return true;
+            if (!selected.description.hasVideo) {
+                const rideView = (0, settings_1.useUserSettings)().getValue('preferences.rideView', null);
+                if (rideView === 'map')
+                    return true;
+            }
             return (0, settings_1.useUserSettings)().isNewUser();
         }
         logEvent(event) {

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

@@ -377,7 +377,7 @@ let RideDisplayService = (() => {
                 return { ...props, ...childProps };
             }
             catch (err) {
-                this.logError(err, 'getDisplayProperties');
+                this.logError(err, 'getDisplayProperties', { state: this.state });
                 return { state: this.state };
             }
         }
@@ -425,7 +425,7 @@ let RideDisplayService = (() => {
         async stopRide(props = {}) {
             try {
                 if (this.state !== 'Starting' && this.state !== 'Idle') {
-                    this.logEvent({ message: "activity stopped", activity: this.activity?.id });
+                    this.logEvent({ message: "activity stopped", activity: this.activity?.id, lastState: this.state });
                 }
                 const prevState = this.state;
                 this.state = prevState === 'Starting' ? 'Closing' : 'Finished';
@@ -449,7 +449,6 @@ let RideDisplayService = (() => {
                 }
                 if (prevState !== 'Starting')
                     this.enableScreensaver();
-                this.state = 'Idle';
             }
             catch (err) {
                 this.logError(err, 'stopRide');
@@ -458,9 +457,10 @@ let RideDisplayService = (() => {
         }
         async closePrevRide() {
             try {
-                if (this.observer || (this.state !== 'Idle')) {
+                if (this.observer || (this.state !== 'Idle' && this.state !== 'Finished')) {
                     await this.stopRide({ noStateUpdates: true });
                 }
+                this.state = 'Idle';
             }
             catch (err) {
                 this.logError(err, 'init');

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

@@ -196,6 +196,12 @@ let RidePageService = (() => {
         }
         onMenuClose() {
             try {
+                const state = this.getRideDisplay().getState();
+                if (state === 'Finished' || this.menuProps.finished) {
+                    this.moveToPreviousPage();
+                    this.closePage();
+                    return;
+                }
                 this.menuProps = null;
                 this.updatePageDisplay();
             }
@@ -223,6 +229,15 @@ let RidePageService = (() => {
                 this.logError(err, 'onResume');
             }
         }
+        onFinished() {
+            try {
+                this.menuProps = { showResume: false, finished: true };
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onResume');
+            }
+        }
         onEndRide() {
             try {
                 this.getRideDisplay().stop();
@@ -336,6 +351,9 @@ let RidePageService = (() => {
                 case 'Paused':
                     this.menuProps = { showResume: true };
                     break;
+                case 'Finished':
+                    this.menuProps = { showResume: false, finished: true };
+                    break;
                 case 'Active':
                     this.menuProps = null;
                     break;

package/lib/cjs/ride/route/RouteDisplayService.js

@@ -276,7 +276,7 @@ let RouteDisplayService = (() => {
                 const mode = this.getDeviceRide().getCyclingMode();
                 const isSIM = mode?.isSIM();
                 const realityFactor = this.startSettings?.realityFactor ?? 100;
-                const targetSlope = (this.position.slope ?? 0) * realityFactor / 100;
+                const targetSlope = (this.position?.slope ?? 0) * realityFactor / 100;
                 if (props?.limits && !isSIM) {
                     delete this.prevRequestSlope;
                     return { ...props?.limits, slope: targetSlope };

package/lib/esm/activities/upload/trainingpeaks.js

@@ -0,0 +1,123 @@
+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 { Injectable } from '../../base/decorators/Injection';
+import { IncyclistService } from '../../base/service';
+import { Singleton } from '../../base/types';
+import { TrainingPeaksAppConnection } from '../../apps/trainingpeaks/TrainingPeaksAppConnection';
+import { ActivityUploadFactory } from './factory';
+let TrainingPeaksUpload = (() => {
+    let _classDecorators = [Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = IncyclistService;
+    let _instanceExtraInitializers = [];
+    let _getConnection_decorators;
+    var TrainingPeaksUpload = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _getConnection_decorators = [Injectable];
+            __esDecorate(this, null, _getConnection_decorators, { kind: "method", name: "getConnection", static: false, private: false, access: { has: obj => "getConnection" in obj, get: obj => obj.getConnection }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            TrainingPeaksUpload = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        isInitialized = __runInitializers(this, _instanceExtraInitializers);
+        connection = new TrainingPeaksAppConnection();
+        constructor() {
+            super('TrainingPeaksUpload');
+            this.isInitialized = false;
+            this.init();
+        }
+        init() {
+            if (this.isInitialized)
+                return true;
+            this.isInitialized = this.getConnection().init();
+            return this.isInitialized;
+        }
+        isConnected() {
+            return this.getConnection().isConnected();
+        }
+        async upload(activity, format = 'TCX') {
+            try {
+                const ok = this.ensureInitialized();
+                if (!ok) {
+                    this.logEvent({ message: 'TrainingPeaks upload skipped', reason: 'not initialized' });
+                    return false;
+                }
+                if (!this.isConnected())
+                    return false;
+                const lcFormat = format.toLowerCase();
+                const ucFormat = format.toUpperCase();
+                this.logEvent({ message: 'TrainingPeaks upload', format: ucFormat });
+                if (!activity.links)
+                    activity.links = {};
+                const fileName = activity[`${lcFormat}FileName`];
+                const res = await this.getApi().upload(fileName, { name: activity.title, description: '' });
+                this.logEvent({ message: 'TrainingPeaks upload success', activityId: res.trainingPeaksId });
+                activity.links.trainingpeaks = {
+                    activity_id: String(res.trainingPeaksId),
+                    url: this.getUrl(res.trainingPeaksId)
+                };
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'TrainingPeaks upload failure', error: err.message });
+                activity.links.trainingpeaks = { error: err.message };
+                return false;
+            }
+        }
+        getUrl(activityId) {
+            return `https://www.trainingpeaks.com/athlete/workouts/${activityId}`;
+        }
+        ensureInitialized() {
+            if (!this.isInitialized)
+                this.init();
+            return this.isInitialized;
+        }
+        getConnection() {
+            return this.connection;
+        }
+        getApi() {
+            return this.getConnection().getApi();
+        }
+    };
+    return TrainingPeaksUpload = _classThis;
+})();
+export { TrainingPeaksUpload };
+const factory = new ActivityUploadFactory();
+factory.add('trainingpeaks', new TrainingPeaksUpload());

package/lib/esm/apps/base/api/trainingpeaks/api.js

@@ -0,0 +1,143 @@
+import { EventLogger } from 'gd-eventlog';
+import { Observer } from '../../../../base/types/observer';
+import { valid } from '../../../../utils/valid';
+import { sleep } from '../../../../utils/sleep';
+import { AppApiBase } from '../base';
+const UPLOAD_POLL_INTERVAL_MS = 2000;
+const UPLOAD_TIMEOUT_MS = 60000;
+export class TrainingPeaksApi extends AppApiBase {
+    config;
+    logger;
+    observer;
+    constructor() {
+        super();
+        this.logger = new EventLogger('TrainingPeaksApi');
+        this.observer = new Observer();
+    }
+    getBaseUrl() {
+        return process.env.TRAININGPEAKS_API || 'https://api.sandbox.trainingpeaks.com';
+    }
+    getOauthBaseUrl() {
+        return process.env.TRAININGPEAKS_OAUTH_URL || 'https://oauth.sandbox.trainingpeaks.com';
+    }
+    init(config) {
+        this.config = config;
+        return this.observer;
+    }
+    update(config) {
+        if (!this.config)
+            throw new Error('update not allowed before init');
+        this.config = { ...this.config, ...config };
+    }
+    isAuthenticated() {
+        return valid(this.config?.accessToken);
+    }
+    async getLoggedInAthlete() {
+        await this.verifyAuthentication();
+        const response = await this.get('/v1/athlete/profile');
+        return response.data;
+    }
+    async getCalendarWorkouts(opts) {
+        await this.verifyAuthentication();
+        const oldest = opts?.oldest ?? new Date();
+        const newest = opts?.newest ?? new Date(oldest.valueOf() + 30 * 24 * 60 * 60 * 1000);
+        const fmt = (d) => d.toISOString().slice(0, 10);
+        const response = await this.get(`/v2/workouts/${fmt(oldest)}/${fmt(newest)}`);
+        return response.data;
+    }
+    async getWorkoutFile(id, format = 'zwo') {
+        await this.verifyAuthentication();
+        const response = await this.get(`/v2/workouts/wod/file/${id}?format=${format}`);
+        return response.data;
+    }
+    async upload(fileName, props) {
+        await this.verifyAuthentication();
+        const reqOpts = {
+            headers: { Authorization: `bearer ${this.config.accessToken}` }
+        };
+        const form = await this.createForm('/v3/file', { file: { type: 'file', fileName } }, reqOpts);
+        const response = await this.postForm(form);
+        const location = response.headers?.['location'] ?? '';
+        const trackingId = location.split('/').filter(Boolean).pop();
+        if (!trackingId) {
+            throw new Error('TrainingPeaks upload failed: no tracking ID returned');
+        }
+        return this.waitForUploadComplete(trackingId, props?.externalId);
+    }
+    async getUploadStatus(trackingId) {
+        await this.verifyAuthentication();
+        const response = await this.get(`/v3/status/${trackingId}`);
+        return response.data;
+    }
+    async verifyAuthentication() {
+        if (!this.isAuthenticated())
+            throw new Error('not authenticated');
+        await this.verifyToken();
+    }
+    async verifyToken() {
+        if (!this.isTokenStillValid()) {
+            try {
+                await this.refreshToken();
+            }
+            catch {
+                throw new Error('token refresh failed');
+            }
+        }
+    }
+    isTokenStillValid() {
+        if (!this.config?.expiration)
+            return false;
+        return Date.now() < this.config.expiration.valueOf();
+    }
+    async refreshToken() {
+        this.logger.logEvent({ message: 'TrainingPeaks refresh token start' });
+        try {
+            const response = await this.getApi().request({
+                method: 'post',
+                url: `${this.getOauthBaseUrl()}/oauth/token`,
+                data: new URLSearchParams({
+                    grant_type: 'refresh_token',
+                    refresh_token: this.config.refreshToken,
+                    client_id: this.config.clientId,
+                    client_secret: this.config.clientSecret,
+                }).toString(),
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+            });
+            const data = response.data;
+            this.config.accessToken = data.access_token;
+            this.config.refreshToken = data.refresh_token;
+            this.config.expiration = new Date(Date.now() + data.expires_in * 1000);
+            this.logger.logEvent({ message: 'TrainingPeaks refresh token success' });
+            this.observer.emit('token.updated', this.config);
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'TrainingPeaks refresh token error', error: err.message });
+            throw err;
+        }
+    }
+    async waitForUploadComplete(trackingId, externalId) {
+        const deadline = Date.now() + UPLOAD_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            const status = await this.getUploadStatus(trackingId);
+            if (status.Completed) {
+                if (!status.WorkoutIds?.length) {
+                    throw new Error(`TrainingPeaks upload failed: ${status.Status}`);
+                }
+                return { trainingPeaksId: status.WorkoutIds[0], externalId };
+            }
+            await sleep(UPLOAD_POLL_INTERVAL_MS);
+        }
+        throw new Error('TrainingPeaks upload timed out');
+    }
+    async get(url, config) {
+        const props = config ?? {};
+        const response = await this.getApi().request({
+            method: 'get',
+            url: this.getBaseUrl() + url,
+            headers: { Authorization: `bearer ${this.config.accessToken}` },
+            validateStatus: (status) => (status >= 200 && status < 300) || status === 403,
+            ...props
+        });
+        return response;
+    }
+}

package/lib/esm/apps/base/api/trainingpeaks/index.js

@@ -0,0 +1 @@
+export { TrainingPeaksApi } from './api';

package/lib/esm/apps/base/api/trainingpeaks/types.js

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

package/lib/esm/apps/trainingpeaks/TrainingPeaksAppConnection.js

@@ -0,0 +1,189 @@
+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 { getBindings } from '../../api';
+import { Injectable, Singleton } from '../../base/decorators';
+import { valid } from '../../utils/valid';
+import { TrainingPeaksApi } from '../base/api/trainingpeaks';
+import { ConnectedAppService } from '../base/app';
+let TrainingPeaksAppConnection = (() => {
+    let _classDecorators = [Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ConnectedAppService;
+    let _instanceExtraInitializers = [];
+    let _getSecretBindings_decorators;
+    var TrainingPeaksAppConnection = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _getSecretBindings_decorators = [Injectable];
+            __esDecorate(this, null, _getSecretBindings_decorators, { kind: "method", name: "getSecretBindings", static: false, private: false, access: { has: obj => "getSecretBindings" in obj, get: obj => obj.getSecretBindings }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            TrainingPeaksAppConnection = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        config = __runInitializers(this, _instanceExtraInitializers);
+        api;
+        tokenUpdateHandler = this.updateConfig.bind(this);
+        constructor() {
+            super('TrainingPeaksAppConnection', 'trainingpeaks');
+        }
+        async connect(credentials) {
+            this.ensureInitialized();
+            this.logEvent({ message: 'Connect with TrainingPeaks' });
+            try {
+                const isConnected = this.isConnected();
+                const config = this.buildConfigFromCredentials(credentials);
+                if (isConnected) {
+                    this.getApi().update(config);
+                }
+                else {
+                    this.initApi(config);
+                    this.saveCredentials(config);
+                }
+                this.logEvent({ message: 'Connect with TrainingPeaks success' });
+                return true;
+            }
+            catch (err) {
+                this.logError(err, 'connect');
+                throw err;
+            }
+        }
+        isConnecting() {
+            return false;
+        }
+        disconnect() {
+            try {
+                this.config = undefined;
+                this.getApi().init(undefined);
+                this.saveCredentials();
+            }
+            catch (err) {
+                this.logError(err, 'disconnect');
+            }
+        }
+        isConnected() {
+            if (!this.isInitialized) {
+                this.init();
+            }
+            return valid(this.config);
+        }
+        getCredentials() {
+            try {
+                return this.getUserSettings().get('user.auth.trainingpeaks', null);
+            }
+            catch {
+                return null;
+            }
+        }
+        getApi() {
+            if (!this.api)
+                this.api = new TrainingPeaksApi();
+            return this.api;
+        }
+        initAuth() {
+            let isInitialized = false;
+            try {
+                const auth = this.getCredentials();
+                const clientId = this.getSecret('TRAININGPEAKS_CLIENT_ID');
+                const clientSecret = this.getSecret('TRAININGPEAKS_CLIENT_SECRET');
+                if (clientId && clientSecret && auth) {
+                    this.logEvent({ message: 'TrainingPeaks init done', hasCredentials: true });
+                    this.config = this.buildConfigFromCredentials(auth);
+                    this.initApi(this.config);
+                }
+                else {
+                    this.logEvent({ message: 'TrainingPeaks init done', hasCredentials: false });
+                }
+                isInitialized = true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', error: err.message, fn: 'init', stack: err.stack });
+                isInitialized = false;
+                delete this.config;
+            }
+            return isInitialized;
+        }
+        updateConfig(config) {
+            const { accessToken, refreshToken, expiration } = config;
+            this.config = { ...this.config, accessToken, refreshToken, expiration };
+            this.saveCredentials();
+        }
+        saveCredentials(config) {
+            if (config)
+                this.config = config;
+            try {
+                if (!this.isConnected()) {
+                    this.logEvent({ message: 'TrainingPeaks delete credentials' });
+                    this.getUserSettings().set('user.auth.trainingpeaks', null);
+                    return;
+                }
+                this.logEvent({ message: 'TrainingPeaks save credentials' });
+                this.getUserSettings().set('user.auth.trainingpeaks', {
+                    accesstoken: this.config.accessToken,
+                    refreshtoken: this.config.refreshToken,
+                    expiration: this.config.expiration?.valueOf().toString()
+                });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'saveCredentials', error: err.message, stack: err.stack });
+            }
+            this.logEvent({ message: 'TrainingPeaks save credentials done' });
+        }
+        buildConfigFromCredentials(credentials) {
+            return {
+                clientId: this.getSecret('TRAININGPEAKS_CLIENT_ID'),
+                clientSecret: this.getSecret('TRAININGPEAKS_CLIENT_SECRET'),
+                accessToken: credentials?.accesstoken,
+                refreshToken: credentials?.refreshtoken,
+                expiration: credentials?.expiration ? new Date(Number(credentials.expiration)) : undefined
+            };
+        }
+        initApi(config) {
+            const observer = this.getApi().init(config);
+            observer.on('token.updated', this.tokenUpdateHandler);
+        }
+        getSecret(key) {
+            return this.getSecretBindings()?.getSecret(key);
+        }
+        getSecretBindings() {
+            return getBindings()?.secret;
+        }
+    };
+    return TrainingPeaksAppConnection = _classThis;
+})();
+export { TrainingPeaksAppConnection };

package/lib/esm/apps/trainingpeaks/types.js

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

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

@@ -1356,8 +1356,15 @@ let DeviceRideService = (() => {
         canEnforceSimulator() {
             const selected = getRouteList().getSelected();
             const personalApiKey = this.getGoogleMaps().hasPersonalApiKey();
+            if (!selected?.description)
+                return false;
             if (selected?.description?.hasVideo || personalApiKey)
                 return true;
+            if (!selected.description.hasVideo) {
+                const rideView = useUserSettings().getValue('preferences.rideView', null);
+                if (rideView === 'map')
+                    return true;
+            }
             return useUserSettings().isNewUser();
         }
         logEvent(event) {

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

@@ -374,7 +374,7 @@ let RideDisplayService = (() => {
                 return { ...props, ...childProps };
             }
             catch (err) {
-                this.logError(err, 'getDisplayProperties');
+                this.logError(err, 'getDisplayProperties', { state: this.state });
                 return { state: this.state };
             }
         }
@@ -422,7 +422,7 @@ let RideDisplayService = (() => {
         async stopRide(props = {}) {
             try {
                 if (this.state !== 'Starting' && this.state !== 'Idle') {
-                    this.logEvent({ message: "activity stopped", activity: this.activity?.id });
+                    this.logEvent({ message: "activity stopped", activity: this.activity?.id, lastState: this.state });
                 }
                 const prevState = this.state;
                 this.state = prevState === 'Starting' ? 'Closing' : 'Finished';
@@ -446,7 +446,6 @@ let RideDisplayService = (() => {
                 }
                 if (prevState !== 'Starting')
                     this.enableScreensaver();
-                this.state = 'Idle';
             }
             catch (err) {
                 this.logError(err, 'stopRide');
@@ -455,9 +454,10 @@ let RideDisplayService = (() => {
         }
         async closePrevRide() {
             try {
-                if (this.observer || (this.state !== 'Idle')) {
+                if (this.observer || (this.state !== 'Idle' && this.state !== 'Finished')) {
                     await this.stopRide({ noStateUpdates: true });
                 }
+                this.state = 'Idle';
             }
             catch (err) {
                 this.logError(err, 'init');

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

@@ -193,6 +193,12 @@ let RidePageService = (() => {
         }
         onMenuClose() {
             try {
+                const state = this.getRideDisplay().getState();
+                if (state === 'Finished' || this.menuProps.finished) {
+                    this.moveToPreviousPage();
+                    this.closePage();
+                    return;
+                }
                 this.menuProps = null;
                 this.updatePageDisplay();
             }
@@ -220,6 +226,15 @@ let RidePageService = (() => {
                 this.logError(err, 'onResume');
             }
         }
+        onFinished() {
+            try {
+                this.menuProps = { showResume: false, finished: true };
+                this.updatePageDisplay();
+            }
+            catch (err) {
+                this.logError(err, 'onResume');
+            }
+        }
         onEndRide() {
             try {
                 this.getRideDisplay().stop();
@@ -333,6 +348,9 @@ let RidePageService = (() => {
                 case 'Paused':
                     this.menuProps = { showResume: true };
                     break;
+                case 'Finished':
+                    this.menuProps = { showResume: false, finished: true };
+                    break;
                 case 'Active':
                     this.menuProps = null;
                     break;

package/lib/esm/ride/route/RouteDisplayService.js

@@ -270,7 +270,7 @@ let RouteDisplayService = (() => {
                 const mode = this.getDeviceRide().getCyclingMode();
                 const isSIM = mode?.isSIM();
                 const realityFactor = this.startSettings?.realityFactor ?? 100;
-                const targetSlope = (this.position.slope ?? 0) * realityFactor / 100;
+                const targetSlope = (this.position?.slope ?? 0) * realityFactor / 100;
                 if (props?.limits && !isSIM) {
                     delete this.prevRequestSlope;
                     return { ...props?.limits, slope: targetSlope };

package/lib/esm/workouts/calendar/sync/trainingpeaks/provider.js

@@ -0,0 +1,201 @@
+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 { useAppsService } from '../../../../apps';
+import { TrainingPeaksAppConnection } from '../../../../apps/trainingpeaks/TrainingPeaksAppConnection';
+import { Injectable } from '../../../../base/decorators';
+import { IncyclistService } from '../../../../base/service';
+import { Observer } from '../../../../base/types';
+import { getFirstDayOfCurrentWeek, waitNextTick } from '../../../../utils';
+import { ZwoParser } from '../../../base/parsers/zwo/zwo';
+import { WorkoutSyncFactory } from '../factory';
+const SYNC_DAYS = 30;
+let TrainingPeaksCalendarSyncProvider = (() => {
+    let _classSuper = IncyclistService;
+    let _instanceExtraInitializers = [];
+    let _getApi_decorators;
+    let _getConnection_decorators;
+    let _getAppsService_decorators;
+    return class TrainingPeaksCalendarSyncProvider extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _getApi_decorators = [Injectable];
+            _getConnection_decorators = [Injectable];
+            _getAppsService_decorators = [Injectable];
+            __esDecorate(this, null, _getApi_decorators, { kind: "method", name: "getApi", static: false, private: false, access: { has: obj => "getApi" in obj, get: obj => obj.getApi }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getConnection_decorators, { kind: "method", name: "getConnection", static: false, private: false, access: { has: obj => "getConnection" in obj, get: obj => obj.getConnection }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getAppsService_decorators, { kind: "method", name: "getAppsService", static: false, private: false, access: { has: obj => "getAppsService" in obj, get: obj => obj.getAppsService }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        lastSyncTS = __runInitializers(this, _instanceExtraInitializers);
+        observer;
+        stopRequested;
+        workouts;
+        constructor() {
+            super('TrainingPeaksCalendarSync');
+            this.lastSyncTS = 0;
+            this.workouts = [];
+        }
+        sync() {
+            if (this.observer)
+                return this.observer;
+            this.observer = new Observer();
+            const onDone = () => {
+                waitNextTick().then(() => {
+                    this.stopRequested = false;
+                    delete this.observer;
+                });
+            };
+            this.observer.once('done', onDone);
+            this.observer.once('loaded', onDone);
+            this.observer.once('stop', () => { this.stopSync(); });
+            this.loadWorkouts();
+            return this.observer;
+        }
+        isConnected() {
+            try {
+                if (this.getApi().isAuthenticated())
+                    return true;
+                return this.getConnection().isConnected();
+            }
+            catch {
+                return false;
+            }
+        }
+        reset() {
+            this.lastSyncTS = 0;
+            this.workouts = [];
+        }
+        stopSync() {
+            this.stopRequested = true;
+        }
+        async loadWorkouts() {
+            const isFirst = this.lastSyncTS === 0;
+            const event = isFirst ? 'loaded' : 'done';
+            try {
+                if (!this.isConnected()) {
+                    this.observer.emit(event, [], 'trainingpeaks');
+                    return [];
+                }
+                if (!this.getAppsService().isEnabled('trainingpeaks', 'WorkoutDownload')) {
+                    await waitNextTick();
+                    this.observer.emit(event, [], 'trainingpeaks');
+                    return [];
+                }
+                const oldest = getFirstDayOfCurrentWeek();
+                const newest = new Date(oldest.valueOf() + SYNC_DAYS * 24 * 60 * 60 * 1000);
+                const all = await this.getApi().getCalendarWorkouts({ oldest, newest }) ?? [];
+                const bike = all.filter(w => w.WorkoutType === 'Bike');
+                await this.parseWorkouts(bike);
+                this.observer.emit(event, this.workouts, 'trainingpeaks');
+                this.lastSyncTS = Date.now();
+                return this.workouts;
+            }
+            catch {
+                this.observer.emit(event, [], 'trainingpeaks');
+                return [];
+            }
+        }
+        async parseWorkouts(workouts) {
+            const zwoParser = new ZwoParser();
+            const promises = [];
+            const transform = async (w) => {
+                try {
+                    const day = new Date(w.WorkoutDay);
+                    const updated = w.LastModifiedDate ? new Date(w.LastModifiedDate) : undefined;
+                    if (!w.WorkoutFileFormats?.includes('zwo')) {
+                        this.logEvent({
+                            message: 'workout skipped - no ZWO format available',
+                            workoutId: w.Id,
+                            title: w.Title,
+                            availableFormats: w.WorkoutFileFormats ?? []
+                        });
+                        return;
+                    }
+                    const fileContent = await this.getApi().getWorkoutFile(w.Id, 'zwo');
+                    const workout = await zwoParser.fromStr(fileContent, w.Title);
+                    const entry = {
+                        day,
+                        updated,
+                        workoutId: String(w.Id),
+                        workout
+                    };
+                    const existingIdx = this.workouts.findIndex(e => e.workoutId === String(w.Id));
+                    const isExisting = existingIdx !== -1;
+                    if (this.lastSyncTS > 0) {
+                        if (!isExisting) {
+                            this.observer.emit('added', entry, 'trainingpeaks');
+                        }
+                        else if (updated && updated.valueOf() > this.lastSyncTS) {
+                            this.observer.emit('updated', entry, 'trainingpeaks');
+                        }
+                    }
+                    if (isExisting) {
+                        this.workouts[existingIdx] = entry;
+                    }
+                    else {
+                        this.workouts.push(entry);
+                    }
+                }
+                catch (err) {
+                    this.logEvent({ message: 'error parsing workout', error: err.message, workoutId: w.Id, title: w.Title });
+                }
+            };
+            if (this.lastSyncTS > 0) {
+                const deleted = this.workouts.filter(e => !workouts.some(w => String(w.Id) === e.workoutId));
+                for (const e of deleted) {
+                    this.observer.emit('deleted', e, 'trainingpeaks');
+                }
+                this.workouts = this.workouts.filter(e => workouts.some(w => String(w.Id) === e.workoutId));
+            }
+            for (const w of workouts) {
+                promises.push(transform(w));
+            }
+            await Promise.all(promises);
+            return this.workouts;
+        }
+        getApi() {
+            return this.getConnection().getApi();
+        }
+        getConnection() {
+            return new TrainingPeaksAppConnection();
+        }
+        getAppsService() {
+            return useAppsService();
+        }
+    };
+})();
+export { TrainingPeaksCalendarSyncProvider };
+const factory = new WorkoutSyncFactory();
+factory.add('trainingpeaks', new TrainingPeaksCalendarSyncProvider());

package/lib/types/activities/upload/trainingpeaks.d.ts

@@ -0,0 +1,16 @@
+import { IncyclistService } from '../../base/service';
+import { TrainingPeaksAppConnection } from '../../apps/trainingpeaks/TrainingPeaksAppConnection';
+import { ActivityDetails } from '../base';
+import { IActivityUpload } from './types';
+export declare class TrainingPeaksUpload extends IncyclistService implements IActivityUpload {
+    protected isInitialized: boolean;
+    protected connection: TrainingPeaksAppConnection;
+    constructor();
+    init(): boolean;
+    isConnected(): boolean;
+    upload(activity: ActivityDetails, format?: string): Promise<boolean>;
+    getUrl(activityId: number | string): string;
+    protected ensureInitialized(): boolean;
+    protected getConnection(): TrainingPeaksAppConnection;
+    protected getApi(): import("../../apps/base/api/trainingpeaks").TrainingPeaksApi;
+}

package/lib/types/apps/base/api/trainingpeaks/api.d.ts

@@ -0,0 +1,30 @@
+import { AxiosResponse } from 'axios';
+import { EventLogger } from 'gd-eventlog';
+import { Observer } from '../../../../base/types/observer';
+import { AppApiBase } from '../base';
+import { TrainingPeaksAthlete, TrainingPeaksConfig, TrainingPeaksUploadProps, TrainingPeaksUploadResult, TrainingPeaksUploadStatus, TrainingPeaksWorkout } from './types';
+export declare class TrainingPeaksApi extends AppApiBase {
+    protected config: TrainingPeaksConfig;
+    protected logger: EventLogger;
+    protected observer: Observer;
+    constructor();
+    protected getBaseUrl(): string;
+    protected getOauthBaseUrl(): string;
+    init(config: TrainingPeaksConfig): Observer;
+    update(config: Partial<TrainingPeaksConfig>): void;
+    isAuthenticated(): boolean;
+    getLoggedInAthlete(): Promise<TrainingPeaksAthlete>;
+    getCalendarWorkouts(opts?: {
+        oldest?: Date;
+        newest?: Date;
+    }): Promise<TrainingPeaksWorkout[]>;
+    getWorkoutFile(id: number, format?: string): Promise<string>;
+    upload(fileName: string, props?: TrainingPeaksUploadProps): Promise<TrainingPeaksUploadResult>;
+    getUploadStatus(trackingId: string): Promise<TrainingPeaksUploadStatus>;
+    protected verifyAuthentication(): Promise<void>;
+    protected verifyToken(): Promise<void>;
+    protected isTokenStillValid(): boolean;
+    protected refreshToken(): Promise<void>;
+    protected waitForUploadComplete(trackingId: string, externalId?: string): Promise<TrainingPeaksUploadResult>;
+    protected get(url: string, config?: object): Promise<AxiosResponse>;
+}

package/lib/types/apps/base/api/trainingpeaks/index.d.ts

@@ -0,0 +1,2 @@
+export { TrainingPeaksApi } from './api';
+export type { TrainingPeaksConfig, TrainingPeaksWorkout, TrainingPeaksUploadProps, TrainingPeaksUploadResult, TrainingPeaksUploadStatus, TrainingPeaksAthlete } from './types';

package/lib/types/apps/base/api/trainingpeaks/types.d.ts

@@ -0,0 +1,55 @@
+export type TrainingPeaksConfig = {
+    accessToken: string;
+    refreshToken: string;
+    clientId: string;
+    clientSecret: string;
+    expiration?: Date;
+};
+export type TrainingPeaksRefreshTokenResponse = {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_token: string;
+    scope: string;
+};
+export type TrainingPeaksAthlete = {
+    Id: number;
+    Username: string;
+    FirstName: string;
+    LastName: string;
+    Email: string;
+};
+export type TrainingPeaksWorkout = {
+    Id: number;
+    AthleteId: number;
+    Title: string;
+    WorkoutType: string;
+    WorkoutDay: string;
+    StartTimePlanned?: string;
+    TotalTimePlanned?: number;
+    TotalTime?: number;
+    DistancePlanned?: number;
+    Distance?: number;
+    TssPlanned?: number;
+    TssActual?: number;
+    IFPlanned?: number;
+    Completed: boolean;
+    LastModifiedDate: string;
+    WorkoutFileFormats?: string[];
+    Description?: string;
+};
+export type TrainingPeaksUploadStatus = {
+    Completed: boolean;
+    Status: string;
+    WorkoutIds: number[];
+};
+export type TrainingPeaksUploadProps = {
+    name?: string;
+    description?: string;
+    format?: string;
+    externalId?: string;
+};
+export type TrainingPeaksUploadResult = {
+    trainingPeaksId: number;
+    externalId?: string;
+};

package/lib/types/apps/trainingpeaks/TrainingPeaksAppConnection.d.ts

@@ -0,0 +1,22 @@
+import { TrainingPeaksApi, TrainingPeaksConfig } from '../base/api/trainingpeaks';
+import { ConnectedAppService } from '../base/app';
+import { TrainingPeaksCredentials } from './types';
+export declare class TrainingPeaksAppConnection extends ConnectedAppService<TrainingPeaksCredentials> {
+    protected config: TrainingPeaksConfig;
+    protected api: TrainingPeaksApi;
+    protected tokenUpdateHandler: any;
+    constructor();
+    connect(credentials: TrainingPeaksCredentials): Promise<boolean>;
+    isConnecting(): boolean;
+    disconnect(): void;
+    isConnected(): boolean;
+    getCredentials(): TrainingPeaksCredentials;
+    getApi(): TrainingPeaksApi;
+    protected initAuth(): boolean;
+    protected updateConfig(config: TrainingPeaksConfig): void;
+    protected saveCredentials(config?: TrainingPeaksConfig): void;
+    protected buildConfigFromCredentials(credentials: TrainingPeaksCredentials): TrainingPeaksConfig;
+    protected initApi(config: TrainingPeaksConfig): void;
+    protected getSecret(key: string): string;
+    protected getSecretBindings(): import("../../api").ISecretBinding;
+}

package/lib/types/apps/trainingpeaks/types.d.ts

@@ -0,0 +1,6 @@
+import { AppCredentials } from '../base/types';
+export interface TrainingPeaksCredentials extends AppCredentials {
+    accesstoken: string;
+    refreshtoken: string;
+    expiration?: string;
+}

package/lib/types/ride/page/service.d.ts

@@ -23,6 +23,7 @@ export declare class RidePageService extends IncyclistPageService implements IRi
     onMenuClose(): void;
     onPause(): void;
     onResume(): void;
+    onFinished(): void;
     onEndRide(): void;
     onRetryStart(): void;
     onIgnoreStart(): void;

package/lib/types/ride/page/types.d.ts

@@ -24,7 +24,8 @@ export interface GPXRidePageDisplayProps extends RidePageDisplayProps {
 }
 export type AnyRidePageDisplayProps = VideoRidePageDisplayProps | RidePageDisplayProps;
 export interface RideMenuProps {
-    showResume: boolean;
+    showResume?: boolean;
+    finished?: boolean;
 }
 interface RidePageCallbacks {
     onMenuOpen(): void;

package/lib/types/workouts/calendar/sync/trainingpeaks/provider.d.ts

@@ -0,0 +1,22 @@
+import { TrainingPeaksAppConnection } from '../../../../apps/trainingpeaks/TrainingPeaksAppConnection';
+import { TrainingPeaksWorkout } from '../../../../apps/base/api/trainingpeaks/types';
+import { IncyclistService } from '../../../../base/service';
+import { Observer } from '../../../../base/types';
+import { WorkoutCalendarEntry } from '../../types';
+import { IWorkoutSyncProvider } from '../types';
+export declare class TrainingPeaksCalendarSyncProvider extends IncyclistService implements IWorkoutSyncProvider {
+    protected lastSyncTS: number;
+    protected observer: Observer;
+    protected stopRequested: boolean;
+    protected workouts: WorkoutCalendarEntry[];
+    constructor();
+    sync(): Observer;
+    isConnected(): boolean;
+    reset(): void;
+    protected stopSync(): void;
+    protected loadWorkouts(): Promise<WorkoutCalendarEntry[]>;
+    protected parseWorkouts(workouts: TrainingPeaksWorkout[]): Promise<WorkoutCalendarEntry[]>;
+    protected getApi(): import("../../../../apps/base/api/trainingpeaks").TrainingPeaksApi;
+    protected getConnection(): TrainingPeaksAppConnection;
+    protected getAppsService(): import("../../../../apps").AppsService;
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "incyclist-services",
-  "version": "1.7.71",
+  "version": "1.7.72",
   "peerDependencies": {
     "gd-eventlog": "^0.1.27"
   },
   "dependencies": {
     "@garmin/fitsdk": "^21.200.0",
     "axios": "^1.15.2",
-    "incyclist-devices": "^3.0.21",
+    "incyclist-devices": "^3.0.22",
     "promise.any": "^2.0.6",
     "semver": "^7.7.4",
     "tcx-builder": "^1.1.1",