incyclist-services 1.7.93 → 1.7.95

package/lib/cjs/activities/upload/index.js

@@ -14,7 +14,6 @@ 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("./velohero"), exports);
 __exportStar(require("./strava"), exports);
 __exportStar(require("./intervals"), exports);
 __exportStar(require("./types"), exports);

package/lib/cjs/apps/index.js

@@ -18,4 +18,3 @@ __exportStar(require("./base"), exports);
 __exportStar(require("./googleMaps"), exports);
 __exportStar(require("./service"), exports);
 __exportStar(require("./strava"), exports);
-__exportStar(require("./velohero"), exports);

package/lib/cjs/apps/service.js

@@ -43,7 +43,6 @@ const settings_1 = require("../settings");
 const base_1 = require("./base");
 const IntervalsAppConnection_1 = require("./intervals/IntervalsAppConnection");
 const komoot_1 = require("./komoot");
-const VeloHeroAppConnection_1 = require("./velohero/VeloHeroAppConnection");
 let AppsService = (() => {
     let _classDecorators = [types_1.Singleton];
     let _classDescriptor;
@@ -67,7 +66,7 @@ let AppsService = (() => {
             __runInitializers(_classThis, _classExtraInitializers);
         }
         services = (__runInitializers(this, _instanceExtraInitializers), {
-            ActivityUpload: ['strava', 'velohero', 'intervals'],
+            ActivityUpload: ['strava', 'intervals'],
             WorkoutUpload: [],
             WorkoutDownload: ['intervals'],
             ActivityDownload: [],
@@ -75,7 +74,6 @@ let AppsService = (() => {
         });
         serviceMap = [
             { name: 'Strava', key: 'strava', iconUrl: 'https://static.cdnlogo.com/logos/s/42/strava-wordmark.svg', connection: new base_1.StravaAppConnection() },
-            { name: 'VeloHero', key: 'velohero', iconUrl: 'images/velo-white.png', connection: new VeloHeroAppConnection_1.VeloHeroAppConnection() },
             { name: 'Komoot', key: 'komoot', iconUrl: 'https://www.komoot.com/assets/4d8ae313eec53e6e.svg', connection: new komoot_1.KomootAppConnection() },
             { name: 'Intervals.icu', key: 'intervals', iconUrl: 'images/intervals.png', connection: new IntervalsAppConnection_1.IntervalsAppConnection() },
         ];

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

@@ -95,9 +95,15 @@ let DevicesPageService = (() => {
                 if (this.promiseOpen !== undefined) {
                     return this.getPageObserver();
                 }
-                this.stateMachine.start(() => {
+                const onStateMachineUpdate = () => {
                     this.getPageObserver().emit('page-update');
-                });
+                };
+                this.stateMachine.start(onStateMachineUpdate);
+                if (this.stateMachine.state !== 'Idle') {
+                    this.logEvent({ message: 'state machine was not in expected state on open, resetting', page: 'Pairing', state: this.stateMachine.state });
+                    this.stateMachine.stop();
+                    this.stateMachine.start(onStateMachineUpdate);
+                }
                 this.promiseOpen = new Promise((done) => {
                     this.start()
                         .catch((err) => { this.logError(err, 'openPage'); })
@@ -321,7 +327,7 @@ let DevicesPageService = (() => {
             this.updatePage();
         }
         async closeDeviceSelection(enabled) {
-            this.logEvent({ message: 'capability closed', capability: this.openedCapability });
+            this.logEvent({ message: 'capability closed', capability: this.openedCapability, enabled, caller: new Error().stack });
             if (!enabled) {
                 const all = this.state.capabilities ?? [];
                 const requested = all.find(c => c.capability === this.openedCapability);

package/lib/cjs/devices/page/statemachine.js

@@ -68,6 +68,8 @@ let PairingPageStateMachine = (() => {
         selectStateChangeCallback;
         retryTimeout;
         selectionTimeout;
+        pairingPromise;
+        scanningPromise;
         constructor() {
             this.logger = new gd_eventlog_1.EventLogger('PairingPageState');
         }
@@ -99,6 +101,8 @@ let PairingPageStateMachine = (() => {
                 this.unregisterServiceEventHandlers();
                 delete this.stateChangeCallback;
                 this.resetTimeouts();
+                delete this.pairingPromise;
+                delete this.scanningPromise;
                 this.setState('Closed');
                 this.logIncomingEvent('stop', prev, 'Closed');
             }
@@ -199,14 +203,20 @@ let PairingPageStateMachine = (() => {
                         this.resetTimeouts();
                         this.setState('Done');
                     }
-                    else {
+                    else if (!this.pairingPromise) {
                         this.setState('Pairing');
-                        service.startPairing(adapters, {});
+                        this.pairingPromise = Promise.resolve(service.startPairing(adapters, {}))
+                            .catch(err => { this.logError(err, 'startPairing'); })
+                            .finally(() => { delete this.pairingPromise; });
                     }
                 }
                 else if (this.selectState === 'Closed' || this.selectState === 'Active') {
-                    this.setState('Scanning');
-                    service.startScanning(adapters, {});
+                    if (!this.scanningPromise) {
+                        this.setState('Scanning');
+                        this.scanningPromise = Promise.resolve(service.startScanning(adapters, {}))
+                            .catch(err => { this.logError(err, 'startScanning'); })
+                            .finally(() => { delete this.scanningPromise; });
+                    }
                 }
                 if (this.state !== oldState)
                     this.logger.logEvent({ message: 'state changed', stateTransition: { from: oldState, to: this.state } });

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVirtualShiftingEnabled = isVirtualShiftingEnabled;
+exports.getLoadButtonMode = getLoadButtonMode;
+function isVirtualShiftingEnabled(mode) {
+    try {
+        if (!mode)
+            return false;
+        if (mode.isSIM()) {
+            const virtshiftMode = mode.getSetting('virtshift');
+            return (virtshiftMode === 'Mixed' || virtshiftMode === 'Incyclist' || virtshiftMode === 'SmartTrainer' || virtshiftMode === 'Enabled');
+        }
+        if (mode.isResistance()) {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+function getLoadButtonMode(mode) {
+    if (!mode)
+        return 'power';
+    if (mode.isSIM() || mode.isResistance()) {
+        return isVirtualShiftingEnabled(mode) ? 'gear' : 'hidden';
+    }
+    return 'power';
+}

package/lib/cjs/devices/ride/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("./cyclingMode"), exports);

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

@@ -432,8 +432,11 @@ let RideDisplayService = (() => {
                 this.observer?.stop({ immediately: props.noStateUpdates });
                 if (props.noStateUpdates)
                     delete this.observer;
-                else
-                    (0, utils_1.waitNextTick)().then(() => delete this.observer);
+                else {
+                    const observerToClear = this.observer;
+                    (0, utils_1.waitNextTick)().then(() => { if (this.observer === observerToClear)
+                        delete this.observer; });
+                }
                 if (prevState === 'Finished' || prevState === 'Idle' || prevState === 'Closing') {
                     this.state = 'Idle';
                     return;
@@ -553,7 +556,7 @@ let RideDisplayService = (() => {
                 const { time, speed, routeDistance, distance } = currentValues;
                 const data = { time, speed, routeDistance, distance };
                 this.getRideModeService().onActivityUpdate(data, currentValues);
-                this.observer.emit('data-update', data, currentValues);
+                this.observer?.emit('data-update', data, currentValues);
             }
         }
         onWorkoutStopped() {
@@ -1085,16 +1088,7 @@ let RideDisplayService = (() => {
         isVirtualShiftingEnabled() {
             try {
                 const mode = this.getDeviceRide().getCyclingMode();
-                if (!mode)
-                    return false;
-                if (mode.isSIM()) {
-                    const virtshiftMode = mode.getSetting('virtshift');
-                    return (virtshiftMode === 'Mixed' || virtshiftMode === 'Incyclist' || virtshiftMode === 'SmartTrainer' || virtshiftMode === 'Enabled');
-                }
-                if (mode.isResistance()) {
-                    return true;
-                }
-                return false;
+                return (0, devices_1.isVirtualShiftingEnabled)(mode);
             }
             catch (err) {
                 this.logError(err, 'isVirtualShiftingEnabled');

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

@@ -374,6 +374,10 @@ let RLVDisplayService = (() => {
                 if (time !== undefined) {
                     this.currentVideo.buffering = `${time}s`;
                     this.currentVideo.bufferTime = time;
+                    if (time > 200) {
+                        this.logEvent({ message: 'video conversion >200s' });
+                        this.onVideoLoaded(0);
+                    }
                 }
                 else if (progress !== undefined)
                     this.currentVideo.buffering = `${progress}%`;
@@ -390,11 +394,12 @@ let RLVDisplayService = (() => {
         onVideoLoadError(error, video = this.currentVideo) {
             video.loaded = false;
             video.error = this.buildVideoError(error, video);
+            const isCurrentVideo = video === this.currentVideo;
             if (video.isInitial) {
-                this.logEvent({ message: 'could not load video', video: this.getVideoUrl(video), error: error.message, errorCode: this.getCode(error) });
+                this.logEvent({ message: 'could not load video', video: this.getVideoUrl(video), error: error.message, errorCode: this.getCode(error), isCurrentVideo });
             }
             else {
-                this.logEvent({ message: 'could not load next video', video: this.getVideoUrl(video), error: error.message, errorCode: this.getCode(error) });
+                this.logEvent({ message: 'could not load next video', video: this.getVideoUrl(video), error: error.message, errorCode: this.getCode(error), isCurrentVideo });
                 const errIdx = this.videos.indexOf(video);
                 if (errIdx !== -1) {
                     this.videos.splice(errIdx);

package/lib/cjs/ride/workout/WorkoutDisplayService.js

@@ -35,6 +35,7 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkoutDisplayService = void 0;
+const devices_1 = require("../../devices");
 const workouts_1 = require("../../workouts");
 const base_1 = require("../base/base");
 const decorators_1 = require("../../base/decorators");
@@ -56,6 +57,9 @@ let WorkoutDisplayService = (() => {
         prevPowerTs = __runInitializers(this, _instanceExtraInitializers);
         buildRequest(props = {}) {
             if (props?.limits) {
+                const mode = this.getDeviceRide().getCyclingMode();
+                if ((0, devices_1.getLoadButtonMode)(mode) !== 'power')
+                    return {};
                 return props.limits;
             }
             else
@@ -76,12 +80,12 @@ let WorkoutDisplayService = (() => {
             }
         }
         getLogProps() {
-            const workout = this.getWorkoutList().getSelected();
+            const workout = this.getWorkoutList().getSelected() ?? this.getWorkoutRide().getWorkout();
             const settings = this.getWorkoutList().getStartSettings() ?? {};
             const bikeProps = this.getBikeLogProps();
             return {
                 mode: 'workout',
-                workout: workout.name,
+                workout: workout?.name,
                 ...settings,
                 ...bikeProps
             };

package/lib/cjs/routes/list/cards/RouteCard.js

@@ -165,6 +165,8 @@ let RouteCard = (() => {
                 path = normalizedUrl.replace('file://', '');
             if (normalizedUrl.startsWith('video:///'))
                 path = normalizedUrl.replace('video://', '');
+            if (path && /^\/[A-Za-z]:[\\/]/.test(path))
+                path = path.slice(1);
             if (path) {
                 return await this.fileExists(path);
             }

package/lib/cjs/video/Mp4BoxParser.js

@@ -65,6 +65,152 @@ const parseStsdCodec = (buf, stsdBox) => {
         return undefined;
     return buf.toString('ascii', entryOffset + 4, entryOffset + 8);
 };
+const CHROMA_FORMAT_NAMES = {
+    0: '4:0:0 (monochrome)', 1: '4:2:0', 2: '4:2:2', 3: '4:4:4'
+};
+const findSampleEntryChildBoxes = (buf, stsdBox) => {
+    const entryOffset = stsdBox.bodyStart + 8;
+    if (entryOffset + 4 > buf.length)
+        return [];
+    const entrySize = buf.readUInt32BE(entryOffset);
+    const childStart = entryOffset + 86;
+    const childEnd = Math.min(entryOffset + entrySize, buf.length);
+    if (childStart >= childEnd)
+        return [];
+    return findBoxes(buf, childStart, childEnd);
+};
+const AVC_PROFILE_NAMES = {
+    66: 'Baseline', 77: 'Main', 88: 'Extended', 100: 'High',
+    110: 'High 10', 122: 'High 4:2:2', 144: 'High 4:4:4', 244: 'High 4:4:4 Predictive'
+};
+const AVC_HIGH_FAMILY_PROFILES = new Set([100, 110, 122, 144, 244]);
+const parseAvcC = (buf, avcCBox) => {
+    const start = avcCBox.bodyStart;
+    if (start + 4 > buf.length)
+        return undefined;
+    const profileIdc = buf.readUInt8(start + 1);
+    const levelIdc = buf.readUInt8(start + 3);
+    const details = {
+        profile: AVC_PROFILE_NAMES[profileIdc] ?? `unknown (${profileIdc})`,
+        profileId: profileIdc,
+        level: (levelIdc / 10).toFixed(1)
+    };
+    if (!AVC_HIGH_FAMILY_PROFILES.has(profileIdc))
+        return details;
+    try {
+        let offset = start + 5;
+        if (offset >= buf.length)
+            return details;
+        const numSps = buf.readUInt8(offset) & 0x1f;
+        offset += 1;
+        for (let i = 0; i < numSps; i++) {
+            if (offset + 2 > buf.length)
+                return details;
+            offset += 2 + buf.readUInt16BE(offset);
+        }
+        if (offset >= buf.length)
+            return details;
+        const numPps = buf.readUInt8(offset);
+        offset += 1;
+        for (let i = 0; i < numPps; i++) {
+            if (offset + 2 > buf.length)
+                return details;
+            offset += 2 + buf.readUInt16BE(offset);
+        }
+        if (offset + 3 > buf.length)
+            return details;
+        details.chromaFormat = CHROMA_FORMAT_NAMES[buf.readUInt8(offset) & 0x03];
+        details.bitDepthLuma = (buf.readUInt8(offset + 1) & 0x07) + 8;
+        details.bitDepthChroma = (buf.readUInt8(offset + 2) & 0x07) + 8;
+    }
+    catch { }
+    return details;
+};
+const HEVC_PROFILE_NAMES = {
+    1: 'Main', 2: 'Main 10', 3: 'Main Still Picture', 4: 'Range Extensions',
+    5: 'High Throughput', 6: 'Multiview Main', 7: 'Scalable Main', 8: '3D Main',
+    9: 'Screen Content Coding', 10: 'Scalable Range Extensions'
+};
+const parseHvcC = (buf, hvcCBox) => {
+    const start = hvcCBox.bodyStart;
+    if (start + 19 > buf.length)
+        return undefined;
+    const byte1 = buf.readUInt8(start + 1);
+    const generalProfileIdc = byte1 & 0x1f;
+    const generalTierFlag = (byte1 >> 5) & 0x01;
+    const generalLevelIdc = buf.readUInt8(start + 12);
+    const chromaFormatIdc = buf.readUInt8(start + 16) & 0x03;
+    return {
+        profile: HEVC_PROFILE_NAMES[generalProfileIdc] ?? `unknown (${generalProfileIdc})`,
+        profileId: generalProfileIdc,
+        tier: generalTierFlag ? 'High' : 'Main',
+        level: (generalLevelIdc / 30).toFixed(1),
+        chromaFormat: CHROMA_FORMAT_NAMES[chromaFormatIdc],
+        bitDepthLuma: (buf.readUInt8(start + 17) & 0x07) + 8,
+        bitDepthChroma: (buf.readUInt8(start + 18) & 0x07) + 8
+    };
+};
+const AV1_PROFILE_NAMES = { 0: 'Main', 1: 'High', 2: 'Professional' };
+const av1Level = (levelIdx) => `${2 + Math.floor(levelIdx / 4)}.${levelIdx % 4}`;
+const av1BitDepth = (highBitdepth, twelveBit) => {
+    if (twelveBit)
+        return 12;
+    return highBitdepth ? 10 : 8;
+};
+const av1ChromaFormat = (monochrome, subsamplingX, subsamplingY) => {
+    if (monochrome)
+        return CHROMA_FORMAT_NAMES[0];
+    if (subsamplingX && subsamplingY)
+        return '4:2:0';
+    if (subsamplingX && !subsamplingY)
+        return '4:2:2';
+    return '4:4:4';
+};
+const parseAv1C = (buf, av1CBox) => {
+    const start = av1CBox.bodyStart;
+    if (start + 3 > buf.length)
+        return undefined;
+    const byte1 = buf.readUInt8(start + 1);
+    const seqProfile = (byte1 >> 5) & 0x07;
+    const seqLevelIdx0 = byte1 & 0x1f;
+    const byte2 = buf.readUInt8(start + 2);
+    const seqTier0 = (byte2 >> 7) & 0x01;
+    const highBitdepth = (byte2 >> 6) & 0x01;
+    const twelveBit = (byte2 >> 5) & 0x01;
+    const monochrome = (byte2 >> 4) & 0x01;
+    const chromaSubsamplingX = (byte2 >> 3) & 0x01;
+    const chromaSubsamplingY = (byte2 >> 2) & 0x01;
+    const bitDepth = av1BitDepth(highBitdepth, twelveBit);
+    const chromaFormat = av1ChromaFormat(monochrome, chromaSubsamplingX, chromaSubsamplingY);
+    return {
+        profile: AV1_PROFILE_NAMES[seqProfile] ?? `unknown (${seqProfile})`,
+        profileId: seqProfile,
+        tier: seqTier0 ? 'High' : 'Main',
+        level: av1Level(seqLevelIdx0),
+        chromaFormat,
+        bitDepthLuma: bitDepth,
+        bitDepthChroma: bitDepth,
+        monochrome: !!monochrome
+    };
+};
+const parseCodecDetails = (buf, codec, stsdBox) => {
+    if (!codec)
+        return undefined;
+    const childBoxes = findSampleEntryChildBoxes(buf, stsdBox);
+    if (codec === 'avc1' || codec === 'avc3') {
+        const avcCBox = findBox(childBoxes, 'avcC');
+        return avcCBox ? parseAvcC(buf, avcCBox) : undefined;
+    }
+    if (codec === 'hev1' || codec === 'hvc1') {
+        const hvcCBox = findBox(childBoxes, 'hvcC');
+        return hvcCBox ? parseHvcC(buf, hvcCBox) : undefined;
+    }
+    if (codec === 'av01') {
+        const av1CBox = findBox(childBoxes, 'av1C');
+        return av1CBox ? parseAv1C(buf, av1CBox) : undefined;
+    }
+    return undefined;
+};
 const parseTkhdDimensions = (buf, tkhdBox) => {
     if (tkhdBox.bodyStart >= buf.length)
         return {};
@@ -88,18 +234,22 @@ const parseTrak = (buf, trakBox) => {
     const minfBox = findBox(mdiaChildren, 'minf');
     const handlerType = hdlrBox ? parseHandlerType(buf, hdlrBox) : undefined;
     let codec;
+    let codecDetails;
     if (minfBox) {
         const minfChildren = findBoxes(buf, minfBox.bodyStart, minfBox.bodyEnd);
         const stblBox = findBox(minfChildren, 'stbl');
         if (stblBox) {
             const stblChildren = findBoxes(buf, stblBox.bodyStart, stblBox.bodyEnd);
             const stsdBox = findBox(stblChildren, 'stsd');
-            if (stsdBox)
+            if (stsdBox) {
                 codec = parseStsdCodec(buf, stsdBox);
+                if (handlerType === 'vide')
+                    codecDetails = parseCodecDetails(buf, codec, stsdBox);
+            }
         }
     }
     const dimensions = (handlerType === 'vide' && tkhdBox) ? parseTkhdDimensions(buf, tkhdBox) : {};
-    return { handlerType, codec, ...dimensions };
+    return { handlerType, codec, codecDetails, ...dimensions };
 };
 const parseMp4Boxes = (headBuffer, tailBuffer) => {
     const result = { moovLocation: 'not-found', incomplete: true };
@@ -130,13 +280,15 @@ const applyMoov = (buf, moovBox, result) => {
     const moovChildren = findBoxes(buf, moovBox.bodyStart, moovBox.bodyEnd);
     const trakBoxes = moovChildren.filter(b => b.type === 'trak');
     trakBoxes.forEach(trakBox => {
-        const { handlerType, codec, width, height } = parseTrak(buf, trakBox);
+        const { handlerType, codec, width, height, codecDetails } = parseTrak(buf, trakBox);
         if (handlerType === 'vide') {
             result.videoCodec = codec;
             if (width)
                 result.width = width;
             if (height)
                 result.height = height;
+            if (codecDetails)
+                result.codecDetails = codecDetails;
         }
         else if (handlerType === 'soun') {
             result.audioCodec = codec;

package/lib/cjs/video/VideoConversion.js

@@ -135,7 +135,7 @@ let VideoConversion = (() => {
             const frames = mapping?.length > 0 ? Math.max(...mapping.map(m => m.frame)) : 0;
             const framerate = this.route.details?.video?.framerate;
             const time = framerate ? Math.round(info.frames / framerate) : parseTime(info.timemark);
-            const pct = frames ? Math.floor(info.frames / frames * 100) : undefined;
+            const pct = (frames && !isNaN(frames)) ? Math.floor(info.frames / frames * 100) : undefined;
             const cpu = this.getCpuStats(info);
             if (frames || time) {
                 this.observer.emit('convert-progress', pct, info.frames, time);

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

@@ -172,7 +172,8 @@ let WorkoutRidePageService = (() => {
                     steps: this.buildUpcomingSteps(current, wo.ftp),
                     dashboard: this.buildDashboardLine(wo),
                     gestureHint: this.buildGestureHint(base.startOverlayProps === null),
-                    loadIncrement: this.getLoadIncrement()
+                    loadIncrement: this.getLoadIncrement(),
+                    loadButtonMode: wo.loadButtonMode ?? 'power'
                 };
             }
             catch (err) {
@@ -334,6 +335,15 @@ let WorkoutRidePageService = (() => {
                 return undefined;
             }
         }
+        getLoadButtonMode() {
+            try {
+                return this.getWorkoutRide().getLoadButtonMode();
+            }
+            catch (err) {
+                this.logError(err, 'getLoadButtonMode');
+                return 'power';
+            }
+        }
         onRideStateUpdate(state) {
             this.subscribeToWorkoutObserver();
             switch (state) {
@@ -512,7 +522,8 @@ let WorkoutRidePageService = (() => {
                 steps: { previous: null, current: null, upcoming: [], hasMore: false },
                 dashboard: { text: '', mode: null },
                 gestureHint: null,
-                loadIncrement: DEFAULT_LOAD_INCREMENT
+                loadIncrement: DEFAULT_LOAD_INCREMENT,
+                loadButtonMode: 'power'
             };
         }
         updatePageDisplay() {

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

@@ -57,14 +57,17 @@ let WorkoutRide = (() => {
     let _instanceExtraInitializers = [];
     let _getUserSettings_decorators;
     let _getWorkoutList_decorators;
+    let _getDeviceRide_decorators;
     var WorkoutRide = class extends _classSuper {
         static { _classThis = this; }
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _getUserSettings_decorators = [decorators_1.Injectable];
             _getWorkoutList_decorators = [decorators_1.Injectable];
+            _getDeviceRide_decorators = [decorators_1.Injectable];
             __esDecorate(this, null, _getUserSettings_decorators, { kind: "method", name: "getUserSettings", static: false, private: false, access: { has: obj => "getUserSettings" in obj, get: obj => obj.getUserSettings }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getWorkoutList_decorators, { kind: "method", name: "getWorkoutList", static: false, private: false, access: { has: obj => "getWorkoutList" in obj, get: obj => obj.getWorkoutList }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getDeviceRide_decorators, { kind: "method", name: "getDeviceRide", static: false, private: false, access: { has: obj => "getDeviceRide" in obj, get: obj => obj.getDeviceRide }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             WorkoutRide = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -269,16 +272,68 @@ let WorkoutRide = (() => {
                 this.logError(err, 'backward', { ts, limits });
             }
         }
+        isPowerRangeAdjustable(delta) {
+            if (this.currentLimits?.minPower === this.currentLimits?.maxPower)
+                return false;
+            return delta >= 0
+                ? this.currentLimits?.targetPower < this.currentLimits?.maxPower
+                : this.currentLimits?.targetPower > this.currentLimits?.minPower;
+        }
+        getPowerRangeDeltaVal(magnitude) {
+            if (!this.settings?.ftp)
+                return magnitude;
+            return magnitude === 1 ? 5 : 50;
+        }
+        getPowerRangeAdjustmentWatts(magnitude, increase) {
+            const nominal = this.getPowerRangeDeltaVal(magnitude);
+            const headroom = increase
+                ? this.currentLimits.maxPower - this.currentLimits.targetPower
+                : this.currentLimits.targetPower - this.currentLimits.minPower;
+            return Math.min(nominal, headroom);
+        }
+        getLoadButtonMode() {
+            try {
+                const mode = this.getDeviceRide().getCyclingMode();
+                return (0, devices_1.getLoadButtonMode)(mode);
+            }
+            catch (err) {
+                this.logError(err, 'getLoadButtonMode');
+                return 'power';
+            }
+        }
+        getGearButtonLabels() {
+            return { inc5: '+5', inc1: '+1', dec1: '-1', dec5: '-5' };
+        }
+        getLoadButtonLabels() {
+            const label = (magnitude, increase) => {
+                const sign = increase ? '+' : '-';
+                const delta = increase ? magnitude : -magnitude;
+                return this.isPowerRangeAdjustable(delta)
+                    ? `${sign}${this.getPowerRangeAdjustmentWatts(magnitude, increase)}W`
+                    : `${sign}${magnitude}%`;
+            };
+            return {
+                inc5: label(5, true),
+                inc1: label(1, true),
+                dec1: label(1, false),
+                dec5: label(5, false),
+            };
+        }
         powerUp(delta) {
             if (delta < 0)
                 return this.powerDown(-delta);
             this.logEvent({ message: 'workout power up', delta });
             try {
-                if (this.currentLimits?.minPower !== this.currentLimits?.maxPower && this.currentLimits?.targetPower < this.currentLimits?.maxPower) {
-                    let deltaVal = delta;
-                    if (this.settings?.ftp) {
-                        deltaVal = delta === 1 ? 5 : 50;
-                    }
+                const loadButtonMode = this.getLoadButtonMode();
+                if (loadButtonMode === 'hidden')
+                    return undefined;
+                if (loadButtonMode === 'gear') {
+                    this.gearChange(delta);
+                    this.logEvent({ message: 'workout gear shift', gearDelta: delta });
+                    return { type: 'gear', value: delta };
+                }
+                if (this.isPowerRangeAdjustable(delta)) {
+                    const deltaVal = this.getPowerRangeDeltaVal(delta);
                     this.currentLimits.targetPower = Math.min(this.currentLimits.targetPower + deltaVal, this.currentLimits.maxPower);
                     this.logEvent({ message: 'workout target power adjusted', targetPower: this.currentLimits.targetPower });
                     this.emit('update', this.getDashboardDisplayProperties());
@@ -304,11 +359,16 @@ let WorkoutRide = (() => {
         powerDown(delta) {
             this.logEvent({ message: 'workout power down', delta });
             try {
-                if (this.currentLimits?.minPower !== this.currentLimits?.maxPower && this.currentLimits?.targetPower > this.currentLimits?.minPower) {
-                    let deltaVal = delta;
-                    if (this.settings?.ftp) {
-                        deltaVal = delta === 1 ? 5 : 50;
-                    }
+                const loadButtonMode = this.getLoadButtonMode();
+                if (loadButtonMode === 'hidden')
+                    return undefined;
+                if (loadButtonMode === 'gear') {
+                    this.gearChange(-delta);
+                    this.logEvent({ message: 'workout gear shift', gearDelta: -delta });
+                    return { type: 'gear', value: -delta };
+                }
+                if (this.isPowerRangeAdjustable(-delta)) {
+                    const deltaVal = this.getPowerRangeDeltaVal(delta);
                     this.currentLimits.targetPower = Math.max(this.currentLimits.targetPower - deltaVal, this.currentLimits.minPower);
                     this.logEvent({ message: 'workout target power adjusted', targetPower: this.currentLimits.targetPower });
                     this.emit('update', this.getDashboardDisplayProperties());
@@ -331,6 +391,9 @@ let WorkoutRide = (() => {
                 return undefined;
             }
         }
+        gearChange(gearDelta) {
+            this.getDeviceRide().sendUpdate({ gearDelta });
+        }
         toggleCyclingMode() {
             const deviceRide = (0, devices_1.useDeviceRide)();
             deviceRide.toggleCyclingMode();
@@ -344,6 +407,7 @@ let WorkoutRide = (() => {
                 const { start, stop } = this.getZoomParameters(this.trainingTime);
                 const title = this.getStepTitle(this.trainingTime);
                 const canShowBackward = Math.round((this.trainingTime ?? 0)) > 0;
+                const loadButtonMode = this.getLoadButtonMode();
                 const props = {
                     workout: this.workout, title,
                     ftp: this.settings.ftp,
@@ -351,7 +415,9 @@ let WorkoutRide = (() => {
                     start, stop,
                     mode: this.getCyclingModeText(),
                     canShowBackward,
-                    canShowForward: true
+                    canShowForward: true,
+                    loadButtonMode,
+                    loadButtons: loadButtonMode === 'power' ? this.getLoadButtonLabels() : this.getGearButtonLabels()
                 };
                 return props;
             }
@@ -618,6 +684,9 @@ let WorkoutRide = (() => {
         getWorkoutList() {
             return (0, list_1.useWorkoutList)();
         }
+        getDeviceRide() {
+            return (0, devices_1.useDeviceRide)();
+        }
     };
     return WorkoutRide = _classThis;
 })();

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

@@ -1,4 +1,3 @@
-export * from './velohero';
 export * from './strava';
 export * from './intervals';
 export * from './types';