incyclist-services 1.3.14 → 1.3.16

package/lib/activities/base/model/index.d.ts

@@ -54,6 +54,7 @@ export type ActivitySummary = {
     title: string;
     name: string;
     routeId: string;
+    routeHash: string;
     previewImage?: string;
     startTime: number;
     rideTime: number;

package/lib/activities/base/repo/db.d.ts

@@ -31,6 +31,7 @@ export declare class ActivitiesRepository {
     protected loadSummaries(): Promise<void>;
     protected buildFromLegacy(): Promise<void>;
     protected listActivities(): Promise<Array<string>>;
+    protected fixMissingHash(): Promise<void>;
     protected loadDetailsByName(name: string): Promise<ActivityDetails>;
     protected loadDetails(name: string, id?: string): Promise<void>;
     protected bulkAddActivities(names: Array<string>): Promise<void>;

package/lib/activities/base/repo/db.js

@@ -148,6 +148,9 @@ let ActivitiesRepository = (() => {
             if ((result === null || result === void 0 ? void 0 : result.length) > 0 && (criteria === null || criteria === void 0 ? void 0 : criteria.routeId)) {
                 result = result.filter(ai => ai.summary.routeId === criteria.routeId);
             }
+            if ((result === null || result === void 0 ? void 0 : result.length) > 0 && (criteria === null || criteria === void 0 ? void 0 : criteria.routeHash)) {
+                result = result.filter(ai => ai.summary.routeHash === criteria.routeHash);
+            }
             if ((result === null || result === void 0 ? void 0 : result.length) > 0 && (criteria === null || criteria === void 0 ? void 0 : criteria.startPos) !== undefined) {
                 result = result.filter(ai => ai.summary.startPos === criteria.startPos);
             }
@@ -245,6 +248,7 @@ let ActivitiesRepository = (() => {
                     if (cnt !== this.activities.length) {
                         yield this.write(true);
                     }
+                    yield this.fixMissingHash();
                     return;
                 }
                 yield this.buildFromLegacy();
@@ -266,6 +270,26 @@ let ActivitiesRepository = (() => {
                 return this.getRepo().list(['db']);
             });
         }
+        fixMissingHash() {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const target = this.activities.filter(ai => ai.summary && ai.summary.routeHash === undefined);
+                    if (!target || target.length === 0) {
+                        return;
+                    }
+                    this.logger.logEvent({ message: 'fixing missing hashes in activities', cnt: target.length });
+                    const promises = [];
+                    target.forEach(ai => {
+                        promises.push(this.loadDetails(ai.summary.name).then(() => { var _a, _b; return ai.summary.routeHash = (_b = (_a = ai.details) === null || _a === void 0 ? void 0 : _a.route) === null || _b === void 0 ? void 0 : _b.hash; }));
+                    });
+                    yield Promise.allSettled(promises);
+                    yield this.write(true);
+                }
+                catch (err) {
+                    this.logError(err, 'fixMissingHash');
+                }
+            });
+        }
         loadDetailsByName(name) {
             return __awaiter(this, void 0, void 0, function* () {
                 let details;

package/lib/activities/base/repo/types.d.ts

@@ -1,6 +1,7 @@
 import { UploadInfo } from "../model";
 export interface ActivitySearchCriteria {
     routeId?: string;
+    routeHash?: string;
     startPos?: number;
     realityFactor?: number;
     uploadStatus?: UploadInfo | Array<UploadInfo>;

package/lib/activities/base/utils/index.js

@@ -6,6 +6,7 @@ const buildSummary = (activity, proposedName) => {
     const { id, title, route, screenshots, startTime: startTimeUTC, time: rideTime, distance, startPos, realityFactor = 100, links, laps } = activity;
     const name = proposedName !== null && proposedName !== void 0 ? proposedName : activity.name;
     const routeId = route === null || route === void 0 ? void 0 : route.id;
+    const routeHash = route === null || route === void 0 ? void 0 : route.hash;
     const shots = screenshots !== null && screenshots !== void 0 ? screenshots : [];
     const preview = (_a = shots.find(s => s.isHighlight)) !== null && _a !== void 0 ? _a : shots[0];
     const previewImage = preview === null || preview === void 0 ? void 0 : preview.fileName;
@@ -17,7 +18,7 @@ const buildSummary = (activity, proposedName) => {
         uploadStatus.push({ service: 'strava', status: 'success' });
     }
     return {
-        id, title, name, routeId, previewImage, startTime, rideTime, distance, startPos, realityFactor, uploadStatus, laps
+        id, title, name, routeId, routeHash, previewImage, startTime, rideTime, distance, startPos, realityFactor, uploadStatus, laps
     };
 };
 exports.buildSummary = buildSummary;

package/lib/activities/list/index.d.ts

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

package/lib/activities/list/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./service"), exports);
+__exportStar(require("./types"), exports);

package/lib/activities/list/service.d.ts

@@ -1,6 +1,6 @@
 import { IncyclistService } from "../../base/service";
 import { Observer, PromiseObserver } from "../../base/types/observer";
-import { ActivitiesRepository } from "../base";
+import { ActivitiesRepository, ActivitySearchCriteria } from "../base";
 import { ActivityInfo } from "../base/model";
 export declare class ActivityListService extends IncyclistService {
     protected preloadObserver: PromiseObserver<void>;
@@ -9,6 +9,9 @@ export declare class ActivityListService extends IncyclistService {
     protected observer: Observer;
     constructor();
     preload(): PromiseObserver<void>;
+    getPastActivities(filter: ActivitySearchCriteria, props?: {
+        details: boolean;
+    }): Array<ActivityInfo>;
     protected loadActivities(): Promise<void>;
     protected getRepo(): ActivitiesRepository;
     protected get activities(): Array<ActivityInfo>;

package/lib/activities/list/service.js

@@ -92,6 +92,13 @@ let ActivityListService = (() => {
             }
             return this.preloadObserver;
         }
+        getPastActivities(filter, props) {
+            const activities = this.getRepo().search(filter);
+            if (props === null || props === void 0 ? void 0 : props.details) {
+                activities.forEach(ai => this.getRepo().getWithDetails(ai.summary.id));
+            }
+            return activities;
+        }
         loadActivities() {
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise(done => {

package/lib/activities/list/type.d.ts

@@ -0,0 +1,6 @@
+export type PastActivityFilter = {
+    routeHash: string;
+    startPos: number;
+    realityFactor: number;
+    minDistance?: number;
+};

package/lib/activities/list/type.js

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

package/lib/activities/list/types.d.ts

@@ -0,0 +1,18 @@
+export type PastActivityLogEntry = {
+    routeHash?: string;
+    routeId?: string;
+    tsStart: number;
+    title: string;
+    time: number;
+    power: number;
+    heartrate?: number;
+    speed?: number;
+    distance: number;
+    routeDistance: number;
+    lap: number;
+    timeGap: string;
+    distanceGap: string;
+    lat?: number;
+    lng?: number;
+};
+export type PastActivityInfo = Array<PastActivityLogEntry | null>;

package/lib/activities/list/types.js

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

package/lib/activities/ride/service.d.ts

@@ -3,14 +3,16 @@ import { IncyclistService } from "../../base/service";
 import { Observer, PromiseObserver } from "../../base/types/observer";
 import { DeviceData } from "incyclist-devices";
 import { ExtendedIncyclistCapability, HealthStatus } from "../../devices";
-import { ActivitiesRepository, ActivityConverterFactory, ActivityDetails, ActivityLogRecord, ActivityRouteType, ScreenShotInfo } from "../base";
+import { ActivitiesRepository, ActivityConverterFactory, ActivityDetails, ActivityInfo, ActivityLogRecord, ActivityRouteType, ScreenShotInfo } from "../base";
 import { FreeRideStartSettings } from "../../routes/list/types";
+import { RouteSettings } from "../../routes/list/cards/RouteCard";
 import { RoutePoint } from "../../routes/base/types";
 import { ActivityState } from "./types";
 import { Route } from "../../routes/base/model/route";
 import { ActivityStatsCalculator } from "./stats";
 import { ActivityDuration } from "./duration";
 import { ActivityUploadFactory } from "../upload";
+import { PastActivityInfo, PastActivityLogEntry } from "../list";
 export declare class ActivityRideService extends IncyclistService {
     protected observer: Observer;
     protected activity: ActivityDetails;
@@ -45,7 +47,10 @@ export declare class ActivityRideService extends IncyclistService {
         elevationGainDisplay?: number;
         elevation?: number;
         isAutoResume?: boolean;
+        showPrev?: boolean;
         dataState: Record<string, HealthStatus>;
+        prevRides?: Array<ActivityInfo>;
+        prevRidesLogs?: PastActivityInfo;
     };
     constructor();
     init(id?: string): Observer;
@@ -63,8 +68,12 @@ export declare class ActivityRideService extends IncyclistService {
     getObserver(): Observer;
     addSceenshot(screenshot: ScreenShotInfo): void;
     onRouteUpdate(points: Array<RoutePoint>): void;
+    getPrevRideStats(activities: Array<ActivityInfo>, current: ActivityLogRecord): PastActivityInfo;
+    protected getActivityLog(ai: ActivityInfo, current: ActivityLogRecord): PastActivityLogEntry | null;
+    protected getCurrentActivityLog(ai: ActivityInfo, current: ActivityLogRecord): PastActivityLogEntry | null;
     protected onPositionUpdate(position: RoutePoint): void;
     protected onDeviceData(data: DeviceData): void;
+    protected initPrevActivities(settings: RouteSettings): void;
     protected onDeviceHealthUpdate(udid: string, status: HealthStatus, capabilities: Array<ExtendedIncyclistCapability>): void;
     emit(eventName: string | symbol, ...args: any[]): boolean;
     protected _save(): Promise<void>;

package/lib/activities/ride/service.js

@@ -65,6 +65,7 @@ const stats_1 = require("./stats");
 const duration_1 = require("./duration");
 const upload_1 = require("../upload");
 const api_1 = require("../../api");
+const list_1 = require("../list");
 const SAVE_INTERVAL = 5000;
 let ActivityRideService = (() => {
     let _classDecorators = [types_1.Singleton];
@@ -101,6 +102,13 @@ let ActivityRideService = (() => {
                 }));
             }
             this.activity = this.createActivity(id);
+            const settings = (0, routes_1.useRouteList)().getStartSettings();
+            if ((settings === null || settings === void 0 ? void 0 : settings.type) === 'Route') {
+                const rs = settings;
+                if (rs.showPrev) {
+                    this.initPrevActivities(rs);
+                }
+            }
             this.durationCalculator = new duration_1.ActivityDuration(this.activity);
             this.getDeviceRide().on('data', this.deviceDataHandler);
             return observer;
@@ -337,6 +345,101 @@ let ActivityRideService = (() => {
             this.current.route.details.distance = points[points.length - 1].routeDistance;
             (0, route_1.addDetails)(this.current.route, this.current.route.details);
         }
+        getPrevRideStats(activities, current) {
+            var _a;
+            if (!(activities === null || activities === void 0 ? void 0 : activities.length))
+                return [];
+            const logs = (_a = activities.map(ai => { return this.getActivityLog(ai, current); })) === null || _a === void 0 ? void 0 : _a.filter(a => a !== null);
+            if (logs.length === 0)
+                return logs;
+            logs.push(this.getCurrentActivityLog(activities[0], current));
+            const sorted = logs.sort((a, b) => b.distance - a.distance);
+            return sorted;
+        }
+        getActivityLog(ai, current) {
+            var _a, _b, _c;
+            try {
+                if (!ai.details) {
+                    return null;
+                }
+                const logs = ai.details.logs;
+                const totalDistance = ai.summary.distance;
+                if (current.distance > totalDistance)
+                    return null;
+                let prev = undefined;
+                let res = logs.find((log, idx) => {
+                    if (log.time >= current.time) {
+                        if (idx > 0)
+                            prev = logs[idx - 1];
+                        return true;
+                    }
+                    return false;
+                });
+                if (!res) {
+                    res = logs[logs.length - 1];
+                }
+                else {
+                    if (Math.abs(res.time - current.time) > 0.1) {
+                        const t = res.time - current.time;
+                        const v = res.speed / 3.6;
+                        res.distance -= (v * t);
+                    }
+                }
+                const distanceDelta = res.distance - current.distance;
+                const { power, heartrate, distance, speed } = res;
+                const routeDistance = res.distance + ai.summary.startPos;
+                let lat, lng;
+                if ((_c = (_b = (_a = this.current) === null || _a === void 0 ? void 0 : _a.route) === null || _b === void 0 ? void 0 : _b.description) === null || _c === void 0 ? void 0 : _c.hasGpx) {
+                    const point = (0, route_1.getPosition)(this.current.route, { distance: routeDistance, nearest: true });
+                    lat = point === null || point === void 0 ? void 0 : point.lat;
+                    lng = point === null || point === void 0 ? void 0 : point.lng;
+                }
+                const distanceGap = Math.abs(distanceDelta) > 1000 ? `${(distanceDelta / 1000).toFixed(1)}km` : `${distanceDelta.toFixed(0)}m`;
+                prev = undefined;
+                res = logs.find((log, idx) => {
+                    if (log.distance >= current.distance) {
+                        if (idx > 0)
+                            prev = logs[idx - 1];
+                        return true;
+                    }
+                    return false;
+                });
+                const s = res.distance - current.distance;
+                const v = res.speed / 3.6;
+                const t = v === 0 ? Infinity : s / v;
+                res.time -= t;
+                const timeGap = `${Number(current.time - res.time).toFixed(1)}s`;
+                const routeHash = ai.summary.routeHash;
+                const routeId = ai.summary.routeId;
+                const tsStart = ai.summary.startTime;
+                const title = new Date(ai.summary.startTime).toLocaleDateString();
+                const calculate = { time: current.time, routeHash, routeId, tsStart, title, power, heartrate, speed, distance, timeGap, distanceGap, routeDistance, lat, lng };
+                return calculate;
+            }
+            catch (err) {
+                this.logError(err, 'getActivityLog');
+                return null;
+            }
+        }
+        getCurrentActivityLog(ai, current) {
+            try {
+                const timeGap = '';
+                const distanceGap = '';
+                const routeHash = ai.summary.routeHash;
+                const routeId = ai.summary.routeId;
+                const tsStart = ai.summary.startTime;
+                const title = 'current';
+                const routeDistance = current.distance;
+                const { power, heartrate, distance, speed, lat, lng } = current;
+                const calculate = { routeHash, routeId, tsStart, title, power, heartrate, speed, distance, timeGap, distanceGap, lat, lng };
+                calculate.routeDistance = calculate.distance + ai.summary.startPos;
+                return calculate;
+            }
+            catch (err) {
+                this.logError(err, 'getCurrentActivityLog');
+                return null;
+            }
+        }
         onPositionUpdate(position) {
             this.current.position = position;
         }
@@ -370,6 +473,23 @@ let ActivityRideService = (() => {
                 this.logError(err, 'onDeviceData');
             }
         }
+        initPrevActivities(settings) {
+            var _a;
+            try {
+                if (!this.current || !((_a = this.activity) === null || _a === void 0 ? void 0 : _a.route))
+                    return;
+                this.current.showPrev = settings.showPrev;
+                const { startPos, realityFactor } = settings;
+                const routeId = this.activity.route.id;
+                const routeHash = this.activity.route.hash;
+                const filter = { routeId, routeHash, startPos, realityFactor };
+                const prevRides = (0, list_1.useActivityList)().getPastActivities(filter, { details: true });
+                this.current.prevRides = prevRides;
+            }
+            catch (err) {
+                this.logError(err, 'initPrevActivities');
+            }
+        }
         onDeviceHealthUpdate(udid, status, capabilities) {
             if (!this.current)
                 return;
@@ -659,8 +779,6 @@ let ActivityRideService = (() => {
                         routeDistance: this.current.routeDistance,
                         distance
                     };
-                    this.emit('data', data);
-                    this.prevEmit = data;
                     const logRecord = this.createLogRecord();
                     if (logRecord) {
                         this.activity.logs.push(logRecord);
@@ -668,6 +786,13 @@ let ActivityRideService = (() => {
                     }
                     this.activity.distance = this.current.routeDistance - this.activity.startPos;
                     this.activity.totalElevation = this.current.elevationGain;
+                    let list;
+                    if (this.current.showPrev) {
+                        list = this.getPrevRideStats(this.current.prevRides, logRecord);
+                        this.emit('prevRides', list);
+                    }
+                    this.emit('data', data, list);
+                    this.prevEmit = data;
                     this.logActivityUpdateMessage();
                     this.updateRepo();
                 }

package/lib/avatars/index.d.ts

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

package/lib/avatars/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./service"), exports);
+__exportStar(require("./types"), exports);

package/lib/avatars/service.d.ts

@@ -0,0 +1,17 @@
+import { IncyclistService } from "../base/service";
+import { Avatar, AvatarOption } from "./types";
+export declare class AvatarService extends IncyclistService {
+    protected options: Array<AvatarOption>;
+    protected registered: Record<string, Avatar>;
+    protected currentBucket: number;
+    constructor();
+    setCurrentRiderAvatar(avatar: Avatar): void;
+    get(id: string): Avatar;
+    delete(id: string): void;
+    deleteAll(): void;
+    protected buildOptions(): void;
+    protected getNextAvailable(): Avatar;
+    protected cleanup(id: string, isCurrent?: boolean): void;
+    protected find(avatar: any): AvatarOption;
+}
+export declare const useAvatars: () => AvatarService;

package/lib/avatars/service.js

@@ -0,0 +1,139 @@
+"use strict";
+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;
+};
+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 __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAvatars = exports.AvatarService = void 0;
+const service_1 = require("../base/service");
+const types_1 = require("../base/types");
+let AvatarService = (() => {
+    let _classDecorators = [types_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = service_1.IncyclistService;
+    var AvatarService = _classThis = class extends _classSuper {
+        constructor() {
+            super('Avatars');
+            this.options = [];
+            this.registered = {};
+            this.currentBucket = 0;
+            this.buildOptions();
+        }
+        setCurrentRiderAvatar(avatar) {
+            this.cleanup('current', true);
+            let currentOption = this.find(avatar);
+            if (!currentOption) {
+                currentOption = { avatar, usageCnt: 0 };
+                this.options.push(currentOption);
+            }
+            currentOption.usageCnt++;
+            return;
+        }
+        get(id) {
+            if (!this.registered[id])
+                this.registered[id] = this.getNextAvailable();
+            return this.registered[id];
+        }
+        delete(id) {
+            this.cleanup(id);
+        }
+        deleteAll() {
+            const currentAvatar = this.registered.current;
+            this.options.forEach(o => { o.usageCnt = 0; });
+            this.currentBucket = 0;
+            const currentOption = this.find(currentAvatar);
+            currentOption.usageCnt = 1;
+            this.registered = { current: currentAvatar };
+        }
+        buildOptions() {
+            var _a;
+            if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.length) > 0)
+                return;
+            this.options = [];
+            const colors = ['yellow', 'red', 'blue', 'green', 'purple', 'orange', 'pink', 'brown', 'grey', 'black', 'white'];
+            colors.forEach(helmet => {
+                colors.forEach(shirt => {
+                    this.options.push({ avatar: { helmet, shirt }, usageCnt: 0 });
+                });
+            });
+        }
+        getNextAvailable() {
+            let available = this.options.find(a => a.usageCnt === this.currentBucket);
+            if (!available) {
+                this.currentBucket++;
+                const currentOption = this.find('current');
+                currentOption.usageCnt++;
+                available = this.options.find(a => a.usageCnt === this.currentBucket);
+            }
+            available.usageCnt++;
+            return available === null || available === void 0 ? void 0 : available.avatar;
+        }
+        cleanup(id, isCurrent = false) {
+            if (this.registered[id]) {
+                const prev = this.find(this.registered[id]);
+                if (prev) {
+                    if (isCurrent)
+                        prev.usageCnt = 0;
+                    else
+                        prev.usageCnt--;
+                }
+                delete this.registered[id];
+            }
+            const currentAvatar = this.registered.current;
+            const inUse = this.options.filter(a => !currentAvatar || (a.avatar.helmet !== currentAvatar.helmet && a.avatar.shirt !== currentAvatar.shirt)).sort((a, b) => b.usageCnt - a.usageCnt);
+            this.currentBucket = inUse[0].usageCnt;
+        }
+        find(avatar) {
+            return this.options.find(a => a.avatar.helmet === avatar.helmet && a.avatar.shirt === avatar.shirt);
+        }
+    };
+    __setFunctionName(_classThis, "AvatarService");
+    (() => {
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        AvatarService = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return AvatarService = _classThis;
+})();
+exports.AvatarService = AvatarService;
+const useAvatars = () => new AvatarService();
+exports.useAvatars = useAvatars;

package/lib/avatars/types.d.ts

@@ -0,0 +1,9 @@
+export type Color = 'yellow' | 'red' | 'blue' | 'green' | 'purple' | 'orange' | 'pink' | 'brown' | 'grey' | 'black' | 'white';
+export type Avatar = {
+    helmet: Color;
+    shirt: Color;
+};
+export type AvatarOption = {
+    avatar: Avatar;
+    usageCnt: number;
+};

package/lib/avatars/types.js

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

package/lib/devices/ride/service.d.ts

@@ -50,6 +50,7 @@ export declare class DeviceRideService extends EventEmitter {
     cancelStart(): Promise<boolean>;
     startRide(_props: any): void;
     stop(udid?: string): Promise<boolean>;
+    resetLimits(): Promise<void>;
     pause(): void;
     resume(): void;
     protected verifySelected(selectedDevices: any, capability: IncyclistCapability): void;
@@ -60,6 +61,7 @@ export declare class DeviceRideService extends EventEmitter {
     sendUpdate(request: UpdateRequest): Promise<void>;
     getCyclingMode(udid?: string): CyclingMode;
     resetCyclingMode(sendInit?: boolean): Promise<void>;
+    enforceERG(): Promise<void>;
     onCyclingModeChanged(udid: string, mode: string, settings: any): Promise<void>;
     onDeviceDeleted(settings: IncyclistDeviceSettings): void;
     enforceSimulator(enforced?: boolean): void;

package/lib/devices/ride/service.js

@@ -727,6 +727,17 @@ class DeviceRideService extends events_1.default {
             return true;
         });
     }
+    resetLimits() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const mode = this.getCyclingMode();
+                const resetRequest = (_a = mode === null || mode === void 0 ? void 0 : mode.getBikeInitRequest()) !== null && _a !== void 0 ? _a : {};
+                yield this.sendUpdate(Object.assign(Object.assign({}, resetRequest), { slope: 0, forced: true }));
+            }
+            catch (_b) { }
+        });
+    }
     pause() {
         const adapters = this.getAdapterList();
         adapters === null || adapters === void 0 ? void 0 : adapters.forEach(ai => {
@@ -897,6 +908,30 @@ class DeviceRideService extends events_1.default {
             }
         });
     }
+    enforceERG() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const adapters = this.getAdapterList();
+                const adapterInfo = adapters === null || adapters === void 0 ? void 0 : adapters.find(ai => ai.adapter.hasCapability(incyclist_devices_1.IncyclistCapability.Control));
+                if (!(adapterInfo === null || adapterInfo === void 0 ? void 0 : adapterInfo.adapter))
+                    return;
+                const { udid, adapter } = adapterInfo;
+                if (adapter.getCyclingMode().getModeProperty('eppSupport'))
+                    return;
+                const modes = adapter.getSupportedCyclingModes().filter(C => C.supportsERGMode());
+                if (modes.length > 0) {
+                    const mode = new modes[0](adapter);
+                    const modeInfo = this.configurationService.getModeSettings(udid, mode.getName());
+                    const settings = modeInfo.settings;
+                    const device = adapter;
+                    device.setCyclingMode(mode, settings);
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', error: err.message, fn: 'enforceERG' });
+            }
+        });
+    }
     onCyclingModeChanged(udid, mode, settings) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;

package/lib/index.d.ts

@@ -4,5 +4,6 @@ export * from './api';
 export * from './routes';
 export * from './workouts';
 export * from './coaches';
+export * from './avatars';
 export * from './activities';
 export { useUserSettings, initUserSettings, UserSettingsService, UserSettingsBinding, IUserSettingsBinding } from './settings';

package/lib/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./api"), exports);
 __exportStar(require("./routes"), exports);
 __exportStar(require("./workouts"), exports);
 __exportStar(require("./coaches"), exports);
+__exportStar(require("./avatars"), exports);
 __exportStar(require("./activities"), exports);
 var settings_1 = require("./settings");
 Object.defineProperty(exports, "useUserSettings", { enumerable: true, get: function () { return settings_1.useUserSettings; } });

package/lib/routes/list/cards/RouteCard.d.ts

@@ -31,6 +31,7 @@ export interface StartSettings {
     convertProgress?: number;
     loopOverwrite?: boolean;
     nextOverwrite?: boolean;
+    showPrev?: boolean;
 }
 export type RouteSettings = StartSettings & RouteStartSettings;
 export type RouteCardProps = {

package/lib/workouts/ride/service.d.ts

@@ -21,6 +21,7 @@ export declare class WorkoutRide extends IncyclistService {
     protected currentLimits: ActiveWorkoutLimit;
     protected updateInterval: NodeJS.Timeout;
     protected currentStep: StepDefinition;
+    protected isFreeRide: boolean;
     constructor();
     init(): Observer;
     start(paused?: boolean): Workout;
@@ -34,10 +35,13 @@ export declare class WorkoutRide extends IncyclistService {
     getDashboardDisplayProperties(): WorkoutDisplayProperties;
     getCurrentLimits(): ActiveWorkoutLimit;
     inUse(): boolean;
+    appliesLimits(): boolean;
     isActive(): boolean;
     getWorkout(): Workout;
     getObserver(): Observer;
     protected update(startIfInitialized?: boolean): void;
+    protected startFreeRide(): Promise<void>;
+    protected stopFreeRide(): Promise<void>;
     protected resetLimits(): Promise<void>;
     protected resetTimes(): void;
     protected setCurrentLimits(trainingTime?: number): void;

package/lib/workouts/ride/service.js

@@ -68,6 +68,7 @@ let WorkoutRide = (() => {
         constructor() {
             super('WorkoutRide');
             this.state = 'idle';
+            this.isFreeRide = true;
         }
         init() {
             var _a, _b;
@@ -282,6 +283,9 @@ let WorkoutRide = (() => {
         inUse() {
             return this.state !== 'idle' && this.state !== 'completed';
         }
+        appliesLimits() {
+            return this.inUse() && !this.isFreeRide;
+        }
         isActive() {
             return this.state === 'active';
         }
@@ -315,6 +319,12 @@ let WorkoutRide = (() => {
                 const prevStep = this.currentStep;
                 this.setCurrentLimits(time);
                 if (this.currentStep !== prevStep) {
+                    if (!this.currentStep.power && prevStep.power) {
+                        this.startFreeRide();
+                    }
+                    else if (this.currentStep.power && !prevStep.power) {
+                        this.stopFreeRide();
+                    }
                     this.emit('step-changed', this.getDashboardDisplayProperties());
                 }
                 else if (Math.round(time) !== prevTime) {
@@ -325,16 +335,31 @@ let WorkoutRide = (() => {
                 this.logError(err, 'update');
             }
         }
+        startFreeRide() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.settings.useErgMode) {
+                    (0, devices_1.useDeviceRide)().resetCyclingMode(false);
+                }
+                this.resetLimits();
+            });
+        }
+        stopFreeRide() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.settings.useErgMode) {
+                    (0, devices_1.useDeviceRide)().enforceERG();
+                }
+                this.resetLimits();
+            });
+        }
         resetLimits() {
             return __awaiter(this, void 0, void 0, function* () {
                 const rideService = (0, devices_1.useDeviceRide)();
-                rideService.resetCyclingMode();
                 const mode = rideService.getCyclingMode();
-                const data = rideService.getData();
                 const isERG = mode ? mode.constructor.supportsERGMode() : false;
                 if (!this.currentLimits || !mode)
                     return;
                 yield rideService.waitForUpdateFinish();
+                const data = rideService.getData();
                 if (isERG) {
                     rideService.sendUpdate({ targetPower: data.power });
                 }
@@ -374,6 +399,7 @@ let WorkoutRide = (() => {
                 request.maxHrm = ((_d = limits.hrm) === null || _d === void 0 ? void 0 : _d.max) ? Math.round(limits.hrm.max) : undefined;
                 this.currentLimits = Object.assign(Object.assign({}, request), { duration: limits.duration, remaining: limits.remaining });
             }
+            this.isFreeRide = limits.power === undefined || limits.power === null;
             this.logger.logEvent(Object.assign(Object.assign({ message: 'workout requests' }, this.currentLimits), { ftp }));
             this.emit('request-update', this.currentLimits);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.3.14",
+  "version": "1.3.16",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },
@@ -43,7 +43,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.2.2",
+    "incyclist-devices": "^2.2.3",
     "promise.any": "^2.0.6",
     "tcx-builder": "^1.1.1",
     "uuid": "^9.0.0",