From 63a472d64c332b7e4c491fc4890ad1d6f37c690a Mon Sep 17 00:00:00 2001 From: Ride Control Date: Tue, 21 Jul 2026 11:39:43 -0700 Subject: [PATCH 1/7] refactor: deduplicate saved workout snapshots --- src/lib/indexed-db.ts | 14 ++ src/lib/saved-sessions.ts | 192 ++++++++++++++++++++++----- src/lib/session-workout-snapshots.ts | 76 +++++++++++ tests/saved-sessions.test.ts | 46 +++++++ 4 files changed, 294 insertions(+), 34 deletions(-) create mode 100644 src/lib/indexed-db.ts create mode 100644 src/lib/session-workout-snapshots.ts diff --git a/src/lib/indexed-db.ts b/src/lib/indexed-db.ts new file mode 100644 index 0000000..a1d00b1 --- /dev/null +++ b/src/lib/indexed-db.ts @@ -0,0 +1,14 @@ +export function indexedDbRequestResult(request: IDBRequest): Promise { + return new Promise((resolve, reject) => { + request.addEventListener('success', () => resolve(request.result), { once: true }); + request.addEventListener('error', () => reject(request.error), { once: true }); + }); +} + +export function indexedDbTransactionComplete(transaction: IDBTransaction): Promise { + return new Promise((resolve, reject) => { + transaction.addEventListener('complete', () => resolve(), { once: true }); + transaction.addEventListener('abort', () => reject(transaction.error), { once: true }); + transaction.addEventListener('error', () => reject(transaction.error), { once: true }); + }); +} diff --git a/src/lib/saved-sessions.ts b/src/lib/saved-sessions.ts index b6d3eb2..6dc5102 100644 --- a/src/lib/saved-sessions.ts +++ b/src/lib/saved-sessions.ts @@ -4,23 +4,33 @@ import type { SessionFeeling, SessionMetadata, SessionSnapshot, + SessionWorkout, } from '../types'; import { restoreElevationTotals } from './elevation'; +import { indexedDbRequestResult, indexedDbTransactionComplete } from './indexed-db'; import { aggregateGear, aggregateResistance, controlModeForHistory, restoreAggregate, } from './session'; +import { + createSessionWorkoutSnapshot, + restoreSessionWorkoutSnapshot, + restoreSnapshotWorkout, + type SessionWorkoutSnapshot, +} from './session-workout-snapshots'; import { IMPORTED_TCX_ID_PREFIX } from './tcx-schema'; -import { isFiniteNumber, isString } from './type-guards'; +import { isFiniteNumber, isRecord, isString } from './type-guards'; import { restoreSessionWorkout } from './workouts'; const DATABASE_NAME = 'ridecontrol-sessions'; -const DATABASE_VERSION = 1; +const DATABASE_VERSION = 2; const SESSION_STORE = 'sessions'; const SUMMARY_STORE = 'session-summaries'; +const WORKOUT_STORE = 'session-workouts'; const ENDED_AT_INDEX = 'endedAt'; +const WORKOUT_SNAPSHOT_INDEX = 'workoutSnapshotId'; const MERIDIEM_SUFFIX = /\s*(AM|PM)$/i; const SESSION_DATE_FORMATTER = new Intl.DateTimeFormat(undefined, { dateStyle: 'full' }); const SESSION_IMPORT_FORMATTER = new Intl.DateTimeFormat(undefined, { @@ -38,20 +48,43 @@ export const SESSION_FEELING_OPTIONS: { label: string; value: SessionFeeling }[] type SessionTiming = Pick; +export type SavedSessionRecord = Omit & { + workout?: SessionWorkout; + workoutSnapshotId?: string; +}; + let databasePromise: Promise | undefined; -function requestResult(request: IDBRequest): Promise { - return new Promise((resolve, reject) => { - request.addEventListener('success', () => resolve(request.result), { once: true }); - request.addEventListener('error', () => reject(request.error), { once: true }); - }); +function storedSessionRecords(session: SavedSession): { + session: SavedSessionRecord; + snapshot?: SessionWorkoutSnapshot; +} { + const snapshot = createSessionWorkoutSnapshot(session.workout); + const { workout: _workout, ...record } = session; + return { + session: snapshot ? { ...record, workoutSnapshotId: snapshot.id } : record, + snapshot, + }; } -function transactionComplete(transaction: IDBTransaction): Promise { - return new Promise((resolve, reject) => { - transaction.addEventListener('complete', () => resolve(), { once: true }); - transaction.addEventListener('abort', () => reject(transaction.error), { once: true }); - transaction.addEventListener('error', () => reject(transaction.error), { once: true }); +function migrateLegacySessionWorkouts(sessions: IDBObjectStore, workouts: IDBObjectStore): void { + const request = sessions.openCursor(); + request.addEventListener('success', () => { + const cursor = request.result; + if (!cursor) { + return; + } + const value: unknown = cursor.value; + if (isRecord(value) && !isString(value.workoutSnapshotId)) { + const workout = restoreSnapshotWorkout(value.workout); + const snapshot = createSessionWorkoutSnapshot(workout); + if (snapshot) { + const { workout: _workout, ...record } = value; + workouts.put(snapshot); + cursor.update({ ...record, workoutSnapshotId: snapshot.id }); + } + } + cursor.continue(); }); } @@ -63,15 +96,25 @@ function openDatabase(): Promise { const request = indexedDB.open(DATABASE_NAME, DATABASE_VERSION); request.addEventListener( 'upgradeneeded', - () => { + (event) => { const database = request.result; - if (!database.objectStoreNames.contains(SESSION_STORE)) { - database.createObjectStore(SESSION_STORE, { keyPath: 'id' }); + const { oldVersion } = event as IDBVersionChangeEvent; + const sessions = database.objectStoreNames.contains(SESSION_STORE) + ? request.transaction?.objectStore(SESSION_STORE) + : database.createObjectStore(SESSION_STORE, { keyPath: 'id' }); + if (sessions && !sessions.indexNames.contains(WORKOUT_SNAPSHOT_INDEX)) { + sessions.createIndex(WORKOUT_SNAPSHOT_INDEX, WORKOUT_SNAPSHOT_INDEX); } if (!database.objectStoreNames.contains(SUMMARY_STORE)) { const summaries = database.createObjectStore(SUMMARY_STORE, { keyPath: 'id' }); summaries.createIndex(ENDED_AT_INDEX, ENDED_AT_INDEX); } + const workouts = database.objectStoreNames.contains(WORKOUT_STORE) + ? request.transaction?.objectStore(WORKOUT_STORE) + : database.createObjectStore(WORKOUT_STORE, { keyPath: 'id' }); + if (oldVersion < 2 && sessions && workouts) { + migrateLegacySessionWorkouts(sessions, workouts); + } }, { once: true } ); @@ -121,6 +164,30 @@ function normalizedImportedAt(importedAt: unknown): number | undefined { return isFiniteNumber(importedAt) && importedAt >= 0 ? importedAt : undefined; } +async function getSessionWorkoutSnapshot( + database: IDBDatabase, + id: string +): Promise { + const transaction = database.transaction(WORKOUT_STORE, 'readonly'); + const completed = indexedDbTransactionComplete(transaction); + const value: unknown = await indexedDbRequestResult( + transaction.objectStore(WORKOUT_STORE).get(id) + ); + await completed; + return restoreSessionWorkoutSnapshot(value); +} + +export function normalizeSavedSessionRecord( + record: SavedSessionRecord, + snapshot?: SessionWorkoutSnapshot +): SavedSession { + const { workoutSnapshotId: _workoutSnapshotId, ...session } = record; + return normalizeSavedSession({ + ...session, + workout: snapshot?.workout ?? restoreSessionWorkout(record.workout), + }); +} + export function normalizeSavedSessionSummary(session: SavedSessionSummary): SavedSessionSummary { return { ...session, @@ -140,9 +207,14 @@ type StoreGetter = (name: string) => T; export function saveSessionRecords( getStore: StoreGetter>, session: SavedSession -): void { - getStore(SESSION_STORE).put(session); +): { snapshotId?: string } { + const records = storedSessionRecords(session); + getStore(SESSION_STORE).put(records.session); getStore(SUMMARY_STORE).put(sessionSummary(session)); + if (records.snapshot) { + getStore(WORKOUT_STORE).put(records.snapshot); + } + return { snapshotId: records.snapshot?.id }; } export function deleteSessionRecords( @@ -155,32 +227,65 @@ export function deleteSessionRecords( export async function saveSession(session: SavedSession): Promise { const database = await openDatabase(); - const transaction = database.transaction([SESSION_STORE, SUMMARY_STORE], 'readwrite'); - const completed = transactionComplete(transaction); - saveSessionRecords((name) => transaction.objectStore(name), session); + const transaction = database.transaction( + [SESSION_STORE, SUMMARY_STORE, WORKOUT_STORE], + 'readwrite' + ); + const completed = indexedDbTransactionComplete(transaction); + const sessions = transaction.objectStore(SESSION_STORE); + const previous = await indexedDbRequestResult( + sessions.get(session.id) as IDBRequest + ); + const { snapshotId } = saveSessionRecords((name) => transaction.objectStore(name), session); + if (previous?.workoutSnapshotId && previous.workoutSnapshotId !== snapshotId) { + const remaining = await indexedDbRequestResult( + sessions.index(WORKOUT_SNAPSHOT_INDEX).count(previous.workoutSnapshotId) + ); + if (remaining === 0) { + transaction.objectStore(WORKOUT_STORE).delete(previous.workoutSnapshotId); + } + } await completed; } export async function deleteSavedSession(id: string): Promise { const database = await openDatabase(); - const transaction = database.transaction([SESSION_STORE, SUMMARY_STORE], 'readwrite'); - const completed = transactionComplete(transaction); + const transaction = database.transaction( + [SESSION_STORE, SUMMARY_STORE, WORKOUT_STORE], + 'readwrite' + ); + const completed = indexedDbTransactionComplete(transaction); + const sessions = transaction.objectStore(SESSION_STORE); + const record = await indexedDbRequestResult( + sessions.get(id) as IDBRequest + ); deleteSessionRecords((name) => transaction.objectStore(name), id); + if (record?.workoutSnapshotId) { + const remaining = await indexedDbRequestResult( + sessions.index(WORKOUT_SNAPSHOT_INDEX).count(record.workoutSnapshotId) + ); + if (remaining === 0) { + transaction.objectStore(WORKOUT_STORE).delete(record.workoutSnapshotId); + } + } await completed; } export async function getSavedSession(id: string): Promise { const database = await openDatabase(); const transaction = database.transaction(SESSION_STORE, 'readonly'); - const completed = transactionComplete(transaction); - const session = await requestResult( - transaction.objectStore(SESSION_STORE).get(id) as IDBRequest + const completed = indexedDbTransactionComplete(transaction); + const record = await indexedDbRequestResult( + transaction.objectStore(SESSION_STORE).get(id) as IDBRequest ); await completed; - if (!session) { + if (!record) { return; } - return normalizeSavedSession(session); + const snapshot = record.workoutSnapshotId + ? await getSessionWorkoutSnapshot(database, record.workoutSnapshotId) + : undefined; + return normalizeSavedSessionRecord(record, snapshot); } export function normalizeSavedSession(session: SavedSession): SavedSession { @@ -207,8 +312,8 @@ export function normalizeSavedSession(session: SavedSession): SavedSession { export async function countSavedSessions(): Promise { const database = await openDatabase(); const transaction = database.transaction(SUMMARY_STORE, 'readonly'); - const completed = transactionComplete(transaction); - const count = await requestResult(transaction.objectStore(SUMMARY_STORE).count()); + const completed = indexedDbTransactionComplete(transaction); + const count = await indexedDbRequestResult(transaction.objectStore(SUMMARY_STORE).count()); await completed; return count; } @@ -219,7 +324,7 @@ export async function listSavedSessions( ): Promise { const database = await openDatabase(); const transaction = database.transaction(SUMMARY_STORE, 'readonly'); - const completed = transactionComplete(transaction); + const completed = indexedDbTransactionComplete(transaction); const index = transaction.objectStore(SUMMARY_STORE).index(ENDED_AT_INDEX); const range = beforeEndedAt === undefined ? undefined : IDBKeyRange.upperBound(beforeEndedAt, true); @@ -244,12 +349,31 @@ export async function listSavedSessions( export async function listAllSavedSessions(): Promise { const database = await openDatabase(); const transaction = database.transaction(SESSION_STORE, 'readonly'); - const completed = transactionComplete(transaction); - const sessions = await requestResult( - transaction.objectStore(SESSION_STORE).getAll() as IDBRequest + const completed = indexedDbTransactionComplete(transaction); + const records = await indexedDbRequestResult( + transaction.objectStore(SESSION_STORE).getAll() as IDBRequest ); await completed; - return sessions.map(normalizeSavedSession).sort((left, right) => right.endedAt - left.endedAt); + const workoutTransaction = database.transaction(WORKOUT_STORE, 'readonly'); + const workoutsCompleted = indexedDbTransactionComplete(workoutTransaction); + const snapshotValues: unknown[] = await indexedDbRequestResult( + workoutTransaction.objectStore(WORKOUT_STORE).getAll() + ); + await workoutsCompleted; + const snapshots = new Map( + snapshotValues.flatMap((value) => { + const snapshot = restoreSessionWorkoutSnapshot(value); + return snapshot ? [[snapshot.id, snapshot] as const] : []; + }) + ); + return records + .map((record) => + normalizeSavedSessionRecord( + record, + record.workoutSnapshotId ? snapshots.get(record.workoutSnapshotId) : undefined + ) + ) + .sort((left, right) => right.endedAt - left.endedAt); } export interface SessionGroup { diff --git a/src/lib/session-workout-snapshots.ts b/src/lib/session-workout-snapshots.ts new file mode 100644 index 0000000..f94b992 --- /dev/null +++ b/src/lib/session-workout-snapshots.ts @@ -0,0 +1,76 @@ +import type { SessionWorkout, WorkoutCourse } from '../types'; +import { isRecord, isString } from './type-guards'; +import { restoreWorkoutCourse } from './workouts'; + +const SNAPSHOT_ID_PREFIX = 'session-workout:'; +const FNV_PRIME = 16_777_619; +const FNV_OFFSET_BASIS = 2_166_136_261; +const SECOND_HASH_SEED = 3_332_611_411; + +export interface SessionWorkoutSnapshot { + id: string; + workout: SessionWorkout; +} + +function hashSource(source: string, seed: number): string { + let hash = seed; + for (let index = 0; index < source.length; index += 1) { + hash ^= source.charCodeAt(index); + hash = Math.imul(hash, FNV_PRIME); + } + return (hash >>> 0).toString(16).padStart(8, '0'); +} + +function workoutSnapshotSource(course: WorkoutCourse): string { + return JSON.stringify({ + baseResistance: course.baseResistance, + description: course.description, + descriptionAttribution: course.descriptionAttribution ?? null, + difficulty: course.difficulty, + distance: course.distance, + elevationGain: course.elevationGain, + id: course.id, + name: course.name, + points: course.points.map((point) => [ + point.distance, + point.elevation, + point.latitude, + point.longitude, + point.x, + point.y, + ]), + routeType: course.routeType, + startingLocation: course.startingLocation ?? null, + }); +} + +export function createSessionWorkoutSnapshot( + workout: SessionWorkout | undefined +): SessionWorkoutSnapshot | undefined { + if (!workout) { + return; + } + const source = workoutSnapshotSource(workout.course); + return { + id: `${SNAPSHOT_ID_PREFIX}${hashSource(source, FNV_OFFSET_BASIS)}${hashSource(source, SECOND_HASH_SEED)}-${source.length}`, + workout, + }; +} + +export function restoreSnapshotWorkout(value: unknown): SessionWorkout | undefined { + if (!isRecord(value)) { + return; + } + const course = restoreWorkoutCourse(value.course); + return course ? { course } : undefined; +} + +export function restoreSessionWorkoutSnapshot(value: unknown): SessionWorkoutSnapshot | undefined { + if (!(isRecord(value) && isString(value.id))) { + return; + } + const workout = restoreSnapshotWorkout(value.workout); + return value.id.startsWith(SNAPSHOT_ID_PREFIX) && workout + ? { id: value.id, workout } + : undefined; +} diff --git a/tests/saved-sessions.test.ts b/tests/saved-sessions.test.ts index ee59b62..39c46b5 100644 --- a/tests/saved-sessions.test.ts +++ b/tests/saved-sessions.test.ts @@ -12,11 +12,16 @@ import { groupSessionsByDate, isImportedSession, normalizeSavedSession, + normalizeSavedSessionRecord, requestPersistentSessionStorage, saveSessionRecords, sessionListAfterDelete, sessionSummary, } from '../src/lib/saved-sessions'; +import { + createSessionWorkoutSnapshot, + restoreSessionWorkoutSnapshot, +} from '../src/lib/session-workout-snapshots'; import { WORKOUT_COURSES } from '../src/lib/workouts'; import type { SavedSession, SavedSessionSummary, SessionSnapshot } from '../src/types'; @@ -127,6 +132,47 @@ describe('saved session utilities', () => { ); }); + test('deduplicates immutable workout snapshots outside session records', () => { + const [workout] = WORKOUT_COURSES; + if (!workout) { + throw new Error('Expected a built-in workout course'); + } + const session = { + ...createSavedSession(snapshot, { comments: '' }, 1234, 'session-with-workout'), + workout: { course: workout }, + }; + const writes = new Map(); + const { snapshotId } = saveSessionRecords( + (name) => + ({ + put: (value: unknown) => { + writes.set(name, [...(writes.get(name) ?? []), value]); + return {} as IDBRequest; + }, + }) as Pick, + session + ); + const storedSession = writes.get('sessions')?.[0]; + const storedWorkout = writes.get('session-workouts')?.[0]; + expect(storedSession).toMatchObject({ workoutSnapshotId: snapshotId }); + expect('workout' in (storedSession as Record)).toBeFalse(); + expect(storedWorkout).toMatchObject({ id: snapshotId, workout: session.workout }); + expect( + normalizeSavedSessionRecord( + storedSession as Parameters[0], + storedWorkout as Parameters[1] + ).workout + ).toEqual(session.workout); + expect(createSessionWorkoutSnapshot({ course: { ...workout } })?.id).toBe(snapshotId); + const revisedSnapshot = createSessionWorkoutSnapshot({ + course: { ...workout, name: `${workout.name} revised` }, + }); + expect(revisedSnapshot?.id).not.toBe(snapshotId); + expect(restoreSessionWorkoutSnapshot(revisedSnapshot)).toMatchObject({ + workout: { course: { name: `${workout.name} revised` } }, + }); + }); + test('restores resistance aggregates for legacy saved sessions', () => { const session = createSavedSession(snapshot, { comments: '' }, 1234, 'legacy'); const legacy = { From 92ddbbb305efbd046ada00b25974cd884b0394b8 Mon Sep 17 00:00:00 2001 From: Ride Control Date: Tue, 21 Jul 2026 11:39:49 -0700 Subject: [PATCH 2/7] feat: browse backend-powered BikeGPX routes --- README.md | 12 +- bun.lock | 5 + package.json | 1 + src/app.tsx | 1 + src/build-env.d.ts | 1 + src/components/bikegpx-browser-dialog.tsx | 827 ++++++++++++++++++++++ src/components/workout-map-dialog.tsx | 161 +---- src/components/workout-panel.tsx | 133 ++-- src/components/workout-route-map.tsx | 162 +++++ src/hooks/use-bikegpx-catalog.ts | 77 ++ src/hooks/use-workout-library.ts | 15 +- src/lib/bikegpx.ts | 221 ++++++ src/lib/workout-metrics.ts | 15 + src/lib/workouts.ts | 14 - tests/bikegpx.test.ts | 105 +++ tests/components.test.tsx | 8 +- tests/workouts.test.ts | 2 +- 17 files changed, 1530 insertions(+), 230 deletions(-) create mode 100644 src/components/bikegpx-browser-dialog.tsx create mode 100644 src/components/workout-route-map.tsx create mode 100644 src/hooks/use-bikegpx-catalog.ts create mode 100644 src/lib/bikegpx.ts create mode 100644 src/lib/workout-metrics.ts create mode 100644 tests/bikegpx.test.ts diff --git a/README.md b/README.md index 1c7ef45..1212f94 100644 --- a/README.md +++ b/README.md @@ -14,11 +14,11 @@ Bike trainer control web app using Web Bluetooth. Tested with Wahoo KICKR Core 2 - Connects to compatible bike trainers and standard Bluetooth heart rate monitors through Web Bluetooth, remembers authorized devices, and restores the trainer, heart-rate monitor, and both Click controllers from one browser permission snapshot after a reload. The trainer and heart-rate monitor begin reconnecting immediately and independently; remembered Click controllers join those parallel attempts only during an active ride session. Trainers and active Click controllers keep advertisement discovery active through the GATT handshake so Chrome can react as soon as they broadcast, while heart-rate monitors use direct GATT retries because common HRMs do not reliably surface advertisements through Chrome's watcher. A shared coordinator deduplicates requests to the same physical device without letting a slow sensor block the others, and each device's service and notification setup stays sequential for reliable GATT communication. - Shows live speed, power, cadence, heart rate, elapsed time, distance, and estimated calories, with MPH and KM/H display modes. - Provides direct resistance control with buttons, a slider, and keyboard shortcuts with matching button feedback, shows smoothing progress inside the slider thumb, and records resistance changes alongside the other ride metrics. -- Offers original terrain workouts built as repeatable courses, with gentle, rolling, and climbing options and distinctive winding top-down route shapes. Courses explicitly support loops, point-to-point routes, and out-and-back routes; an out-and-back follows the supplied path to its turnaround, then reverses the same location and elevation data back to the start before repeating. Prairie Roll adds a non-intersecting, curving 15-mile loop of long, gradual rollers centered around 20% resistance and ranging from roughly 15–25%. Granite Switchbacks adds a sustained four-mile ascent whose hairpin corners briefly get steeper before immediately returning to the steady climbing grade, followed by a ridge and a descending sequence of five recovery rollers. Ridgeline Time Trial is a ten-mile out-and-back with a gradual five-mile, roughly 300-foot hillclimb to the turnaround and the identical terrain in reverse on the return. Every course begins flat without giving nearly level routes an unnecessarily long rollout: low-climb courses use about 0.4 km, moderate rollers use about 0.8 km, and climbing-focused courses retain a 1.5 km rollout. The course then automatically adjusts trainer resistance from the current grade, tracks the rider in compact, vertically aligned top-down and elevation views with a clearly labelled ridden-this-lap, ridden-this-trip, or ridden-this-route path and pulsing position markers while pedaling, and uses clear mid-contrast preview lines with a shared elevation scale so gentle rollers remain visibly low beside genuinely mountainous routes. It shows course distance progress to two decimal places alongside course percentage, current grade, and effective trainer resistance directly on the map, with grade and resistance values matching their graph colors, and derives cumulative ride climbing and downhill from course distance so those totals remain aligned with the advertised full-course climb. Elevation appears in feet with MPH or meters with KM/H, and terrain totals and progress are recorded with the session and preserved in saved history and TCX import/export. Restored or currently open sessions always resolve bundled workout IDs to the latest course definition, preventing older embedded map geometry from lingering after a course update. A workout can be selected before riding or planned while viewing a completed session; a newly planned workout immediately replaces the prior course on the dashboard at 0% progress without changing the completed ride's recorded data. It then remains locked from the moment riding begins until that session ends; definition refreshes for that same workout remain allowed without opening a path to switch courses. Workout terrain remains the base load when Zwift Click is paired, allowing virtual gears to scale that resistance without losing the grade-driven course behavior. -- Downloads terrain workouts as standard GPX 1.1 files containing geographic track points and elevation data, with names and descriptions readable by ordinary GPX tools and Ride Control extensions for stable ids, difficulty, baseline resistance, exact workout distance, saved starting location, and point-to-point, loop, or out-and-back course type. Valid GPX tracks or routes from other tools can be imported through the file picker or by dropping a GPX anywhere in the workout tray, then saved into a custom library on the current device; each newly imported workout appears immediately at the top and keeps that position after reloading. The tray also links to BikeGPX's collection of thousands of downloadable routes. An imported route's linked “Starts in” description opens an in-app map dialog beside the workout tray, fits its complete path with start and finish markers over an attributed OpenStreetMap base map, and continuously animates a standard bicycle marker along the route. Routes whose start and finish are genuinely near each other become loops automatically; other GPX routes remain one-way, start-to-finish courses without a generated return leg. The workout library filters immediately by course name or displayed difficulty, and every card keeps an up/down-arrow drag handle in the top-right corner; dragging moves the complete workout card strictly vertically, accepts a drop anywhere over another workout, and animates the surrounding cards out of the way to open a full-card-sized insertion space before saving the preferred order across browser reloads. The terrain tray remembers both that it was open and its workout-list scroll position across page reloads. Import, rename, and reorder feedback stays in a fixed bottom status area beside the selected-workout clearing action, preventing the workout list from shifting. Imported workout names can be clicked and renamed without changing the route's stable duplicate-detection identifier. Their top-down geometry is derived from latitude and longitude, terrain resistance is derived from elevation, and a route without its own description uses its first coordinate to label the starting city through a cached OpenStreetMap lookup, then saves that location directly with the workout so restoring or re-importing a Ride Control GPX does not repeat the request. Missing Ride Control metadata receives safe defaults. Stable workout ids—or a route fingerprint for third-party GPX—prevent built-in or previously imported workouts from being uploaded again. Imported entries can be removed, large tracks are sampled for efficient riding, and the geographic source model is ready for a future workout editor. +- Offers original terrain workouts built as repeatable courses, with gentle, rolling, and climbing options and distinctive winding top-down route shapes. Courses explicitly support loops, point-to-point routes, and out-and-back routes; an out-and-back follows the supplied path to its turnaround, then reverses the same location and elevation data back to the start before repeating. Prairie Roll adds a non-intersecting, curving 15-mile loop of long, gradual rollers centered around 20% resistance and ranging from roughly 15–25%. Granite Switchbacks adds a sustained four-mile ascent whose hairpin corners briefly get steeper before immediately returning to the steady climbing grade, followed by a ridge and a descending sequence of five recovery rollers. Ridgeline Time Trial is a ten-mile out-and-back with a gradual five-mile, roughly 300-foot hillclimb to the turnaround and the identical terrain in reverse on the return. Every course begins flat without giving nearly level routes an unnecessarily long rollout: low-climb courses use about 0.4 km, moderate rollers use about 0.8 km, and climbing-focused courses retain a 1.5 km rollout. The course then automatically adjusts trainer resistance from the current grade, tracks the rider in compact, vertically aligned top-down and elevation views with a clearly labelled ridden-this-lap, ridden-this-trip, or ridden-this-route path and pulsing position markers while pedaling, and uses clear mid-contrast preview lines with a shared elevation scale so gentle rollers remain visibly low beside genuinely mountainous routes. It shows course distance progress to two decimal places alongside course percentage, current grade, and effective trainer resistance directly on the map, with grade and resistance values matching their graph colors, and derives cumulative ride climbing and downhill from course distance so those totals remain aligned with the advertised full-course climb. Elevation appears in feet with MPH or meters with KM/H, and terrain totals and progress are recorded with the session and preserved in saved history and TCX import/export. Currently open in-progress sessions resolve bundled workout IDs to the latest course definition, preventing stale geometry from lingering before a ride is saved; saved history keeps the exact workout snapshot used by that ride. A workout can be selected before riding or planned while viewing a completed session; a newly planned workout immediately replaces the prior course on the dashboard at 0% progress without changing the completed ride's recorded data. It then remains locked from the moment riding begins until that session ends; definition refreshes for that same workout remain allowed without opening a path to switch courses. Workout terrain remains the base load when Zwift Click is paired, allowing virtual gears to scale that resistance without losing the grade-driven course behavior. +- Downloads terrain workouts as standard GPX 1.1 files containing geographic track points and elevation data, with names and descriptions readable by ordinary GPX tools and Ride Control extensions for stable ids, difficulty, baseline resistance, exact workout distance, saved starting location, and point-to-point, loop, or out-and-back course type. Valid GPX tracks or routes from other tools can be imported through the file picker or by dropping a GPX anywhere in the workout tray, then saved into a custom library on the current device; each newly imported workout appears immediately at the top and keeps that position after reloading. A map-first BikeGPX browser is built directly into the terrain tray: it searches more than six thousand public routes by name, place, distance in kilometers or miles, or difficulty; filters by country, minimum and maximum distance in the rider's current units, and terrain-based difficulty; continuously scrolls an efficiently virtualized list; previews the complete GPX over OpenStreetMap; and imports the selected route into Ride Control in one click. The separate Cloudflare Worker backend refreshes the public catalog once per day, stores it in Workers KV, downloads GPX files directly from BikeGPX without a third-party proxy, calculates route geometry and terrain difficulty, and caches each processed route in KV. The frontend receives ready-to-use courses and validated analyses through `/api`; visible routes are requested with bounded concurrency so their server-calculated ratings appear progressively. The same route fingerprint used for uploaded files prevents duplicate imports. An imported route's linked “Starts in” description opens an in-app map dialog beside the workout tray, fits its complete path with start and finish markers over an attributed OpenStreetMap base map, and continuously animates a standard bicycle marker along the route. Routes whose start and finish are genuinely near each other become loops automatically; other GPX routes remain one-way, start-to-finish courses without a generated return leg. The workout library filters immediately by course name or displayed difficulty, and every card keeps an up/down-arrow drag handle in the top-right corner; dragging moves the complete workout card strictly vertically, accepts a drop anywhere over another workout, and animates the surrounding cards out of the way to open a full-card-sized insertion space before saving the preferred order across browser reloads. The terrain tray remembers both that it was open and its workout-list scroll position across page reloads. Import, rename, and reorder feedback stays in a fixed bottom status area beside the selected-workout clearing action, preventing the workout list from shifting. Imported workout names can be clicked and renamed without changing the route's stable duplicate-detection identifier. Their top-down geometry is derived from latitude and longitude, terrain resistance is derived from elevation, and a route without its own description uses its first coordinate to label the starting city through a cached OpenStreetMap lookup, then saves that location directly with the workout so restoring or re-importing a Ride Control GPX does not repeat the request. Missing Ride Control metadata receives safe defaults. Stable workout ids—or a route fingerprint for third-party GPX—prevent built-in or previously imported workouts from being uploaded again. Imported entries can be removed, large tracks are sampled for efficient riding, and the geographic source model is ready for a future workout editor. - Replaces direct resistance controls with a focused 1–24 virtual shifting interface whenever Zwift Click V2 is paired, including during terrain workouts, and restores the standard resistance control as soon as both controllers are forgotten. Shifting becomes available once the trainer and both controllers are connected, and the Click minus/plus buttons, on-screen controls, and keyboard down/up arrows step through the 24 physical combinations of 39/53-tooth chainrings and a 12-speed 12–24-tooth cassette, sorted by actual drivetrain ratio rather than equal percentage intervals. This gives gear 24 the full 53/12 top end for pushing on descents while retaining 39/24 as gear 1 for climbing. Holding a shift control continues shifting, terrain changes remain smoothly automated underneath the selected gear, and sessions record both the selected gear and applied trainer resistance. - Automatically records while pedaling, auto-pauses during inactivity, supports manual pause and resume, and allows a session to end at any time—even before trainer data arrives. Finishing a ride smoothly returns a connected trainer to 10% resistance; if it is disconnected, 10% is remembered and applied when it reconnects. -- Tracks complete time-series data plus averages and maximums for power, cadence, heart rate, speed, resistance, and virtual gear, with large, high-visibility numbers in space-efficient live metric and ride-summary cards, oversized numeric ride totals with subdued unit labels, and focused or combined chart views with subtle separator bands between stacked metrics. Workout grade and elevation are graphed in their own distinct colors, resistance remains visible alongside gear during virtual shifting, and the gear graph stays hidden outside gear mode unless the session contains recorded gear data. The larger chart tabs distribute across the complete chart width. Workout elevation is recorded across the entire ride, so the course profile repeats in the graph for every completed loop. +- Tracks complete time-series data plus averages and maximums for power, cadence, heart rate, speed, resistance, and virtual gear, with large, high-visibility numbers in space-efficient live metric and ride-summary cards, oversized numeric ride totals with subdued unit labels, and focused or combined chart views with subtle separator bands between stacked metrics. Workout grade and elevation are graphed in their own distinct colors, resistance remains visible alongside gear during virtual shifting, and the gear graph stays hidden outside gear mode unless the session contains recorded gear data. The larger chart tabs distribute across the complete chart width. Workout elevation is recorded across the entire ride, so the course profile repeats in the graph for every completed loop. Saved sessions reference immutable, content-addressed workout snapshots in a separate IndexedDB store: identical course definitions share one snapshot, edited definitions retain their historical versions, and deleting a workout from the selectable library cannot break an older session's maps or terrain details. - Lets riders explicitly save a completed session or end it without saving, while keeping start-new and continue-session choices to two clear, context-aware actions; saved sessions use browser-managed IndexedDB storage with optional comments and ride feeling, and persistent browser storage is requested when supported. - Opens saved rides from the dashboard's Sessions button and organizes them by local date and time in a slide-out Sessions tray with a compact inline session count, clear date ranges for rides that span midnight, paginated loading, detailed metrics and charts, keyboard navigation with grouped shortcut help, and permanent deletion. The tray restores the selected session, the session-list scroll position, and each session's independent detail-pane scroll position after a page reload, falling back to the newest available session when a remembered ride no longer exists. - Downloads saved rides as Strava-compatible TCX files, including timestamps, distance, speed, power, cadence, heart rate, resistance or virtual gear, terrain workout metadata and elevation samples, calories, ride feeling, comments, and a unique Ride Control session identifier for reliable duplicate detection. @@ -28,7 +28,7 @@ Bike trainer control web app using Web Bluetooth. Tested with Wahoo KICKR Core 2 - Protects recorded active rides with a browser confirmation before refresh or close, and presents the save workflow before starting or continuing another session. - Includes contextual keyboard help for dashboard and history actions, including pausing, ending, starting, navigating, viewing history, and deleting sessions. - Displays connection and application notices with a visible 15-second countdown and automatic dismissal. -- Keeps ride and session data local to the current browser profile; no account is required. When an imported GPX route has no description, only its first coordinate is sent to OpenStreetMap's Nominatim service to find a starting-city label, and that result is cached in the browser and stored with the workout. The resulting location sentence links to OpenStreetMap in a new tab, frames the complete route area, and marks the starting coordinate. +- Keeps ride and session data local to the current browser profile; no account is required. When an imported GPX route has no description, only its first coordinate is sent to OpenStreetMap's Nominatim service to find a starting-city label, and that result is cached in the browser and stored with the workout. The resulting location sentence links to OpenStreetMap in a new tab, frames the complete route area, and marks the starting coordinate. The frontend sends only public BikeGPX route ids to the Ride Control backend; it does not send ride history, paired-device details, or locally saved workouts. ## Run @@ -39,6 +39,10 @@ bun run dev Open in current Chrome. +The app calls `/api` by default. For local development with the separate Worker on port 8787, +start Vite with `VITE_RIDECONTROL_API_URL=http://localhost:8787/api`. Set the same variable to the +deployed Worker API origin in the frontend deployment environment. + ## Architecture Ride session data is held in a per-app TanStack Store and changed through atomic domain actions. diff --git a/bun.lock b/bun.lock index 09f5768..303c4f0 100644 --- a/bun.lock +++ b/bun.lock @@ -10,6 +10,7 @@ "@dnd-kit/sortable": "10.0.0", "@tailwindcss/vite": "^4.3.3", "@tanstack/react-store": "^0.11.0", + "@tanstack/react-virtual": "^3.14.7", "@vitejs/plugin-react": "^6.0.3", "fflate": "^0.8.3", "leaflet": "^1.9.4", @@ -175,8 +176,12 @@ "@tanstack/react-store": ["@tanstack/react-store@0.11.0", "", { "dependencies": { "@tanstack/store": "0.11.0", "use-sync-external-store": "^1.6.0" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-tX4YXh3PDkmpvGQWkWqKpzs/MSqbtuwY9dWdWhtV9Q50PmO+jOkUKIWIX4G85dwt7lxdHLXsiaEKPdKmC8F41w=="], + "@tanstack/react-virtual": ["@tanstack/react-virtual@3.14.7", "", { "dependencies": { "@tanstack/virtual-core": "3.17.5" }, "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-11uSrj77IDijNBqizD4lY4y1laMyRrqMLSxjnWy5CvWkCjyRDW+gGmxYq0lwQKVas/sq7zyzYWXbL/BvBzR32g=="], + "@tanstack/store": ["@tanstack/store@0.11.0", "", {}, "sha512-WlzzCt3xi0G6pCAJu1U+2jiECwabETDpQDi3hfkFZvJii9AuZqEKbOiVarX1/bWhTNjU486yQtJCCasi/0q+Cw=="], + "@tanstack/virtual-core": ["@tanstack/virtual-core@3.17.5", "", {}, "sha512-AXfBC3sq6PuYSwyxYORqqgHCNjPGAvKJvZuBBJ1klhztWBB5cgqgwsq8+fNfaQJG7/K4xYBja9S90QFn2zmQAg=="], + "@tybys/wasm-util": ["@tybys/wasm-util@0.10.3", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg=="], "@types/bun": ["@types/bun@1.3.14", "", { "dependencies": { "bun-types": "1.3.14" } }, "sha512-h1hFqFVcvAvD9j9K7ZW7vd82aSA+rTdznZa+5bwvCwqSB1jmmfLcbIWhOLx1/+boy/xmjgCs/OMUL8hRJSmnPw=="], diff --git a/package.json b/package.json index 8090ba9..a64225c 100644 --- a/package.json +++ b/package.json @@ -19,6 +19,7 @@ "@dnd-kit/sortable": "10.0.0", "@tailwindcss/vite": "^4.3.3", "@tanstack/react-store": "^0.11.0", + "@tanstack/react-virtual": "^3.14.7", "@vitejs/plugin-react": "^6.0.3", "fflate": "^0.8.3", "leaflet": "^1.9.4", diff --git a/src/app.tsx b/src/app.tsx index 58fa2fa..fed4711 100644 --- a/src/app.tsx +++ b/src/app.tsx @@ -416,6 +416,7 @@ export function App() { courses={workoutLibrary.courses} customCourseIds={workoutLibrary.customCourseIds} onClose={() => setActiveOverlay(undefined)} + onImportCourse={async (course) => workoutLibrary.importCourse(course)} onImportFile={workoutLibrary.importFile} onRemoveCourse={removeWorkout} onRenameCourse={workoutLibrary.renameCourse} diff --git a/src/build-env.d.ts b/src/build-env.d.ts index c2dea93..6143f68 100644 --- a/src/build-env.d.ts +++ b/src/build-env.d.ts @@ -1,6 +1,7 @@ interface ImportMetaEnv { readonly RIDE_CONTROL_BUILD_PR_URL: string; readonly RIDE_CONTROL_BUILD_TIMESTAMP_UTC: string; + readonly VITE_RIDECONTROL_API_URL?: string; } interface ImportMeta { diff --git a/src/components/bikegpx-browser-dialog.tsx b/src/components/bikegpx-browser-dialog.tsx new file mode 100644 index 0000000..1841a53 --- /dev/null +++ b/src/components/bikegpx-browser-dialog.tsx @@ -0,0 +1,827 @@ +import { useVirtualizer } from '@tanstack/react-virtual'; +import { useCallback, useDeferredValue, useEffect, useMemo, useRef, useState } from 'react'; +import { useCloseOnEscape } from '../hooks/use-dialog-behavior'; +import { + BIKEGPX_ROUTES_URL, + type BikeGpxCatalog, + type BikeGpxRouteAnalysis, + type BikeGpxRouteResult, + type BikeGpxRouteSummary, + bikeGpxRouteMatchesQuery, + bikeGpxRouteUrl, + fetchBikeGpxRoute, +} from '../lib/bikegpx'; +import { errorMessage } from '../lib/errors'; +import { convertDistance, distanceUnitLabel, formatDistance, formatElevation } from '../lib/units'; +import { + isWorkoutDifficulty, + WORKOUT_DIFFICULTY, + type WorkoutDifficulty, +} from '../lib/workout-schema'; +import { workoutDifficultyLabel } from '../lib/workouts'; +import type { SpeedUnit, WorkoutCourse } from '../types'; +import { WorkoutRouteMap } from './workout-route-map'; + +const ESTIMATED_ROUTE_ROW_HEIGHT = 88; +const ROUTE_LIST_OVERSCAN = 6; +const ROUTE_ANALYSIS_CONCURRENCY = 2; +const EMPTY_ROUTE_ANALYSES: Record = {}; +const CATALOG_DATE_FORMATTER = new Intl.DateTimeFormat(undefined, { + dateStyle: 'medium', + timeStyle: 'short', +}); +const routeResultCache = new Map(); +const routeResultRequests = new Map>(); + +function requestRouteCourse( + route: BikeGpxRouteSummary, + useCache = true +): Promise { + if (!useCache) { + routeResultCache.delete(route.id); + } + const cached = useCache ? routeResultCache.get(route.id) : undefined; + if (cached) { + return Promise.resolve(cached); + } + const pending = routeResultRequests.get(route.id); + if (pending) { + return pending; + } + const request = fetchBikeGpxRoute(route) + .then((result) => { + routeResultCache.set(route.id, result); + return result; + }) + .finally(() => { + routeResultRequests.delete(route.id); + }); + routeResultRequests.set(route.id, request); + return request; +} + +function matchingRoutes( + routes: BikeGpxRouteSummary[], + query: string, + country: string, + difficulty: WorkoutDifficulty | undefined, + minimumDistance: string, + maximumDistance: string, + speedUnit: SpeedUnit, + analyses: Record +): BikeGpxRouteSummary[] { + const minimum = optionalDistance(minimumDistance); + const maximum = optionalDistance(maximumDistance); + return routes.filter((route) => { + const displayedDistance = convertDistance(route.distanceKm, speedUnit); + const analysis = analyses[route.id]; + return ( + (!country || route.country === country) && + (!(difficulty && analysis) || analysis.difficulty === difficulty) && + (minimum === undefined || displayedDistance >= minimum) && + (maximum === undefined || displayedDistance <= maximum) && + bikeGpxRouteMatchesQuery(route, query, analysis) + ); + }); +} + +function optionalDistance(value: string): number | undefined { + const normalized = value.trim(); + if (!normalized) { + return; + } + const distance = Number(normalized); + return Number.isFinite(distance) && distance >= 0 ? distance : undefined; +} + +function useRouteAnalyzer( + analyses: Record, + onAnalyzeRoute: (routeId: string, analysis: BikeGpxRouteAnalysis) => void +) { + const activeCount = useRef(0); + const alive = useRef(true); + const failedRouteIds = useRef(new Set()); + const onAnalyzeRouteRef = useRef(onAnalyzeRoute); + const pumpRef = useRef<() => void>(() => undefined); + const queuedRouteIds = useRef(new Set()); + const routesToAnalyze = useRef([]); + onAnalyzeRouteRef.current = onAnalyzeRoute; + + useEffect(() => { + alive.current = true; + return () => { + alive.current = false; + }; + }, []); + + const pump = useCallback(() => { + while ( + alive.current && + activeCount.current < ROUTE_ANALYSIS_CONCURRENCY && + routesToAnalyze.current.length > 0 + ) { + const route = routesToAnalyze.current.shift(); + if (!route) { + break; + } + activeCount.current += 1; + requestRouteCourse(route) + .then(({ analysis }) => { + if (alive.current) { + onAnalyzeRouteRef.current(route.id, analysis); + } + }) + .catch(() => { + failedRouteIds.current.add(route.id); + }) + .finally(() => { + activeCount.current -= 1; + queuedRouteIds.current.delete(route.id); + pumpRef.current(); + }); + } + }, []); + pumpRef.current = pump; + + return useCallback( + (routes: BikeGpxRouteSummary[]) => { + for (const route of routes) { + if ( + analyses[route.id] || + queuedRouteIds.current.has(route.id) || + failedRouteIds.current.has(route.id) + ) { + continue; + } + queuedRouteIds.current.add(route.id); + routesToAnalyze.current.push(route); + } + pump(); + }, + [analyses, pump] + ); +} + +function RouteListItem({ + analysis, + onSelect, + route, + selected, + speedUnit, +}: { + analysis?: BikeGpxRouteAnalysis; + onSelect: () => void; + route: BikeGpxRouteSummary; + selected: boolean; + speedUnit: SpeedUnit; +}) { + const difficulty = analysis ? workoutDifficultyLabel(analysis.difficulty) : 'Analyzing'; + return ( + + ); +} + +function RouteSidebar({ + analyses, + catalog, + catalogError, + catalogLoading, + countries, + country, + difficulty, + maximumDistance, + minimumDistance, + onCountryChange, + onDifficultyChange, + onMaximumDistanceChange, + onMinimumDistanceChange, + onQueryChange, + onAnalyzeRoutes, + onRefreshCatalog, + onSelectRoute, + query, + routes, + selectedRouteId, + speedUnit, +}: { + analyses: Record; + catalog?: BikeGpxCatalog; + catalogError: string; + catalogLoading: boolean; + countries: string[]; + country: string; + difficulty?: WorkoutDifficulty; + maximumDistance: string; + minimumDistance: string; + onCountryChange: (country: string) => void; + onDifficultyChange: (difficulty: WorkoutDifficulty | undefined) => void; + onMaximumDistanceChange: (distance: string) => void; + onMinimumDistanceChange: (distance: string) => void; + onQueryChange: (query: string) => void; + onAnalyzeRoutes: (routes: BikeGpxRouteSummary[]) => void; + onRefreshCatalog: () => Promise; + onSelectRoute: (route: BikeGpxRouteSummary) => void; + query: string; + routes: BikeGpxRouteSummary[]; + selectedRouteId: string; + speedUnit: SpeedUnit; +}) { + const routeListRef = useRef(null); + const routeKey = useCallback((index: number) => routes[index]?.id ?? index, [routes]); + const routeVirtualizer = useVirtualizer({ + count: routes.length, + estimateSize: () => ESTIMATED_ROUTE_ROW_HEIGHT, + getItemKey: routeKey, + getScrollElement: () => routeListRef.current, + overscan: ROUTE_LIST_OVERSCAN, + useFlushSync: false, + }); + const selectedIndex = routes.findIndex((route) => route.id === selectedRouteId); + const virtualRoutes = routeVirtualizer + .getVirtualItems() + .flatMap((item) => routes[item.index] ?? []); + + useEffect(() => { + onAnalyzeRoutes(virtualRoutes); + }); + + useEffect(() => { + if (selectedIndex >= 0) { + routeVirtualizer.scrollToIndex(selectedIndex, { align: 'auto' }); + } + }, [routeVirtualizer, selectedIndex]); + + const distanceUnit = distanceUnitLabel(speedUnit); + + return ( + + ); +} + +function useRoutePreview( + route: BikeGpxRouteSummary | undefined, + onAnalyzeRoute: (routeId: string, analysis: BikeGpxRouteAnalysis) => void +) { + const activeRequest = useRef(0); + const [analysis, setAnalysis] = useState(); + const [course, setCourse] = useState(); + const [error, setError] = useState(''); + const [loading, setLoading] = useState(false); + const load = useCallback( + (nextRoute: BikeGpxRouteSummary | undefined, useCache = true) => { + const requestId = activeRequest.current + 1; + activeRequest.current = requestId; + if (!nextRoute) { + setAnalysis(undefined); + setCourse(undefined); + return; + } + setAnalysis(undefined); + setCourse(undefined); + setError(''); + setLoading(true); + requestRouteCourse(nextRoute, useCache) + .then((result) => { + onAnalyzeRoute(nextRoute.id, result.analysis); + if (activeRequest.current === requestId) { + setAnalysis(result.analysis); + setCourse(result.course); + } + }) + .catch((nextError) => { + if (activeRequest.current === requestId) { + setError(errorMessage(nextError)); + } + }) + .finally(() => { + if (activeRequest.current === requestId) { + setLoading(false); + } + }); + }, + [onAnalyzeRoute] + ); + + useEffect(() => { + activeRequest.current += 1; + setAnalysis(undefined); + setCourse(undefined); + setError(''); + setLoading(Boolean(route)); + const previewDelay = window.setTimeout(() => load(route), 250); + return () => { + window.clearTimeout(previewDelay); + activeRequest.current += 1; + }; + }, [load, route]); + + return { analysis, course, error, loading, retry: () => load(route, false) }; +} + +function importButtonLabel(alreadyImported: boolean, importing: boolean): string { + if (alreadyImported) { + return 'Already imported'; + } + return importing ? 'Importing…' : 'Import route'; +} + +function RoutePreviewDetails({ + alreadyImported, + analysis, + course, + importError, + importing, + onImport, + route, + speedUnit, + status, +}: { + alreadyImported: boolean; + analysis?: BikeGpxRouteAnalysis; + course?: WorkoutCourse; + importError: string; + importing: boolean; + onImport: () => void; + route: BikeGpxRouteSummary; + speedUnit: SpeedUnit; + status: string; +}) { + return ( +
+
+
+

{route.name}

+

+ {route.country} + {route.summary ? ` · ${route.summary}` : ''} +

+ {course && analysis ? ( +

+ {formatDistance(course.distance, speedUnit, 1)} ·{' '} + {formatElevation(course.elevationGain, speedUnit)} climbing · Up to + + {analysis.maximumGrade.toFixed(1)}% +

+ ) : null} +
+ + View source route + + {importError || status ? ( + + {importError || status} + + ) : null} +
+
+ +
+
+ ); +} + +function RoutePreview({ + customCourseIds, + onAnalyzeRoute, + onImportCourse, + route, + speedUnit, +}: { + customCourseIds: ReadonlySet; + onAnalyzeRoute: (routeId: string, analysis: BikeGpxRouteAnalysis) => void; + onImportCourse: (course: WorkoutCourse) => Promise; + route?: BikeGpxRouteSummary; + speedUnit: SpeedUnit; +}) { + const preview = useRoutePreview(route, onAnalyzeRoute); + const [feedback, setFeedback] = useState({ error: '', routeId: '', status: '' }); + const [importing, setImporting] = useState(false); + const alreadyImported = preview.course ? customCourseIds.has(preview.course.id) : false; + const visibleFeedback = route?.id === feedback.routeId ? feedback : undefined; + + const importRoute = async () => { + if (!(preview.course && route)) { + return; + } + setFeedback({ error: '', routeId: route.id, status: '' }); + setImporting(true); + try { + const imported = await onImportCourse(preview.course); + setFeedback({ + error: '', + routeId: route.id, + status: `${imported.name} imported and saved on this device.`, + }); + } catch (error) { + setFeedback({ error: errorMessage(error), routeId: route.id, status: '' }); + } finally { + setImporting(false); + } + }; + + return ( +
+ {preview.course ? : null} + {preview.loading ? ( +
+ Loading route map… +
+ ) : null} + {preview.error ? ( +
+
+

{preview.error}

+ +
+
+ ) : null} + {route ? ( + + ) : null} +
+ ); +} + +export function BikeGpxBrowserDialog({ + catalog, + catalogError, + catalogLoading, + customCourseIds, + onAnalyzeRoute, + onClose, + onImportCourse, + onRefreshCatalog, + speedUnit, +}: { + catalog?: BikeGpxCatalog; + catalogError: string; + catalogLoading: boolean; + customCourseIds: ReadonlySet; + onAnalyzeRoute: (routeId: string, analysis: BikeGpxRouteAnalysis) => void; + onClose: () => void; + onImportCourse: (course: WorkoutCourse) => Promise; + onRefreshCatalog: () => Promise; + speedUnit: SpeedUnit; +}) { + useCloseOnEscape(true, onClose); + const [country, setCountry] = useState(''); + const [difficulty, setDifficulty] = useState(); + const [maximumDistance, setMaximumDistance] = useState(''); + const [minimumDistance, setMinimumDistance] = useState(''); + const [query, setQuery] = useState(''); + const [selectedRouteId, setSelectedRouteId] = useState(''); + const deferredQuery = useDeferredValue(query); + const routes = catalog?.routes ?? []; + const analyses = catalog?.analyses ?? EMPTY_ROUTE_ANALYSES; + const analyzeRoutes = useRouteAnalyzer(analyses, onAnalyzeRoute); + const countries = useMemo( + () => [...new Set(routes.map((route) => route.country))].sort(), + [routes] + ); + const filteredRoutes = useMemo( + () => + matchingRoutes( + routes, + deferredQuery, + country, + difficulty, + minimumDistance, + maximumDistance, + speedUnit, + analyses + ), + [ + analyses, + country, + deferredQuery, + difficulty, + maximumDistance, + minimumDistance, + routes, + speedUnit, + ] + ); + const selectedRoute = filteredRoutes.find((route) => route.id === selectedRouteId); + + useEffect(() => { + if (!selectedRoute && filteredRoutes[0]) { + setSelectedRouteId(filteredRoutes[0].id); + } + }, [filteredRoutes, selectedRoute]); + + const selectRoute = (route: BikeGpxRouteSummary) => { + setSelectedRouteId(route.id); + }; + + return ( +
+ + +
+ { + setCountry(nextCountry); + setSelectedRouteId(''); + }} + onDifficultyChange={(nextDifficulty) => { + setDifficulty(nextDifficulty); + setSelectedRouteId(''); + }} + onMaximumDistanceChange={(nextDistance) => { + setMaximumDistance(nextDistance); + setSelectedRouteId(''); + }} + onMinimumDistanceChange={(nextDistance) => { + setMinimumDistance(nextDistance); + setSelectedRouteId(''); + }} + onQueryChange={(nextQuery) => { + setQuery(nextQuery); + setSelectedRouteId(''); + }} + onRefreshCatalog={onRefreshCatalog} + onSelectRoute={selectRoute} + query={query} + routes={filteredRoutes} + selectedRouteId={selectedRouteId} + speedUnit={speedUnit} + /> + +
+ +
+ ); +} diff --git a/src/components/workout-map-dialog.tsx b/src/components/workout-map-dialog.tsx index 809a6f9..1391fd5 100644 --- a/src/components/workout-map-dialog.tsx +++ b/src/components/workout-map-dialog.tsx @@ -1,166 +1,7 @@ -import { - circleMarker, - map as createLeafletMap, - divIcon, - type LatLngExpression, - marker, - polyline, - tileLayer, -} from 'leaflet'; import 'leaflet/dist/leaflet.css'; -import { useEffect, useRef } from 'react'; import { useCloseOnEscape } from '../hooks/use-dialog-behavior'; -import { workoutRouteCoordinateAtProgress } from '../lib/workout-map'; import type { WorkoutCourse } from '../types'; - -const MAP_TILE_URL = 'https://tile.openstreetmap.org/{z}/{x}/{y}.png'; -const MAP_ATTRIBUTION = - '© OpenStreetMap contributors'; -const ROUTE_COLOR = '#67e8f9'; -const ROUTE_OUTLINE_COLOR = '#071018'; -const START_COLOR = '#adf5bd'; -const FINISH_COLOR = '#fbbf24'; -const ENDPOINT_EPSILON = 0.000_001; -const BIKE_ROUTE_DURATION_MS = 30_000; -const BIKE_MARKER_HTML = - ''; - -function routeCoordinates(course: WorkoutCourse): LatLngExpression[] { - return course.points.map((point) => [point.latitude, point.longitude]); -} - -function endpointsOverlap(course: WorkoutCourse): boolean { - const [start] = course.points; - const finish = course.points.at(-1); - return Boolean( - start && - finish && - Math.abs(start.latitude - finish.latitude) < ENDPOINT_EPSILON && - Math.abs(start.longitude - finish.longitude) < ENDPOINT_EPSILON - ); -} - -function WorkoutRouteMap({ course }: { course: WorkoutCourse }) { - const mapContainer = useRef(null); - - useEffect(() => { - const container = mapContainer.current; - if (!container) { - return; - } - const coordinates = routeCoordinates(course); - const [start] = coordinates; - const finish = coordinates.at(-1); - if (!start) { - return; - } - - const routeMap = createLeafletMap(container, { - attributionControl: true, - zoomControl: true, - }); - tileLayer(MAP_TILE_URL, { - attribution: MAP_ATTRIBUTION, - className: 'ride-control-map-tiles', - maxZoom: 19, - }).addTo(routeMap); - - const routeOutline = polyline(coordinates, { - color: ROUTE_OUTLINE_COLOR, - opacity: 0.75, - weight: 9, - }).addTo(routeMap); - polyline(coordinates, { - color: ROUTE_COLOR, - lineCap: 'round', - lineJoin: 'round', - opacity: 0.95, - weight: 5, - }).addTo(routeMap); - - const sharedEndpoint = endpointsOverlap(course); - circleMarker(start, { - color: ROUTE_OUTLINE_COLOR, - fillColor: START_COLOR, - fillOpacity: 1, - radius: 7, - weight: 3, - }) - .bindTooltip(sharedEndpoint ? 'Start and finish' : 'Start') - .addTo(routeMap); - if (finish && !sharedEndpoint) { - circleMarker(finish, { - color: ROUTE_OUTLINE_COLOR, - fillColor: FINISH_COLOR, - fillOpacity: 1, - radius: 7, - weight: 3, - }) - .bindTooltip('Finish') - .addTo(routeMap); - } - - const bikePosition = workoutRouteCoordinateAtProgress(course.points, 0); - let animationFrame = 0; - if (bikePosition) { - const bike = marker([bikePosition.latitude, bikePosition.longitude], { - icon: divIcon({ - className: 'ride-control-bike-marker', - html: BIKE_MARKER_HTML, - iconAnchor: [17, 17], - iconSize: [34, 34], - }), - interactive: false, - keyboard: false, - title: 'Bike riding the route', - zIndexOffset: 1000, - }).addTo(routeMap); - let animationStart: number | undefined; - const animateBike = (timestamp: number) => { - animationStart ??= timestamp; - const progress = - ((timestamp - animationStart) % BIKE_ROUTE_DURATION_MS) / - BIKE_ROUTE_DURATION_MS; - const position = workoutRouteCoordinateAtProgress(course.points, progress); - if (position) { - bike.setLatLng([position.latitude, position.longitude]); - } - animationFrame = window.requestAnimationFrame(animateBike); - }; - animationFrame = window.requestAnimationFrame(animateBike); - } - - const bounds = routeOutline.getBounds(); - if (bounds.isValid()) { - routeMap.fitBounds(bounds, { maxZoom: 16, padding: [48, 48] }); - } else { - routeMap.setView(start, 14); - } - - return () => { - window.cancelAnimationFrame(animationFrame); - routeMap.remove(); - }; - }, [course]); - - return ( -
-
-
-
- - {endpointsOverlap(course) ? 'Start and finish' : 'Start'} -
- {endpointsOverlap(course) ? null : ( -
- - Finish -
- )} -
-
- ); -} +import { WorkoutRouteMap } from './workout-route-map'; export function WorkoutMapDialog({ course, diff --git a/src/components/workout-panel.tsx b/src/components/workout-panel.tsx index d059b15..ae5f6cc 100644 --- a/src/components/workout-panel.tsx +++ b/src/components/workout-panel.tsx @@ -23,6 +23,7 @@ import { useRef, useState, } from 'react'; +import { useBikeGpxCatalog } from '../hooks/use-bikegpx-catalog'; import { useFileDrop } from '../hooks/use-file-drop'; import { usePersistentScrollPosition } from '../hooks/use-persistent-scroll-position'; import { errorMessage } from '../lib/errors'; @@ -32,8 +33,9 @@ import { WORKOUT_DESCRIPTION_ATTRIBUTION, } from '../lib/workout-description'; import { canMoveWorkoutCourse, downloadWorkoutFile } from '../lib/workout-file'; +import { workoutMaximumGrade } from '../lib/workout-metrics'; import { WORKOUT_VIEW, workoutRouteLabel } from '../lib/workout-schema'; -import { workoutDifficultyLabel, workoutMatchesSearch, workoutMaximumGrade } from '../lib/workouts'; +import { workoutDifficultyLabel, workoutMatchesSearch } from '../lib/workouts'; import type { SpeedUnit, WorkoutCourse } from '../types'; import { Icon } from './icon'; import { RenameWorkoutDialog } from './rename-workout-dialog'; @@ -49,6 +51,10 @@ const WorkoutMapDialog = lazy(async () => { const module = await import('./workout-map-dialog'); return { default: module.WorkoutMapDialog }; }); +const BikeGpxBrowserDialog = lazy(async () => { + const module = await import('./bikegpx-browser-dialog'); + return { default: module.BikeGpxBrowserDialog }; +}); const workoutCollisionDetection: CollisionDetection = (args) => { const pointerCollisions = pointerWithin(args); @@ -285,6 +291,7 @@ export function WorkoutPanel({ courses, customCourseIds, onClose, + onImportCourse, onImportFile, onRemoveCourse, onRenameCourse, @@ -298,6 +305,7 @@ export function WorkoutPanel({ courses: WorkoutCourse[]; customCourseIds: ReadonlySet; onClose: () => void; + onImportCourse: (course: WorkoutCourse) => Promise; onImportFile: (file: File) => Promise; onRemoveCourse: (courseId: string) => void; onRenameCourse: (courseId: string, name: string) => WorkoutCourse; @@ -308,12 +316,14 @@ export function WorkoutPanel({ speedUnit: SpeedUnit; }) { const importInput = useRef(null); + const [bikeGpxBrowserOpen, setBikeGpxBrowserOpen] = useState(false); const [importing, setImporting] = useState(false); const [libraryStatus, setLibraryStatus] = useState(''); const [importError, setImportError] = useState(''); const [renamingCourse, setRenamingCourse] = useState(); const [mappedCourse, setMappedCourse] = useState(); const [searchQuery, setSearchQuery] = useState(''); + const bikeGpxCatalog = useBikeGpxCatalog(open); const sensors = useSensors( useSensor(PointerSensor, { activationConstraint: { distance: 6 }, @@ -358,6 +368,7 @@ export function WorkoutPanel({ const closePanel = () => { setRenamingCourse(undefined); setMappedCourse(undefined); + setBikeGpxBrowserOpen(false); setSearchQuery(''); onClose(); }; @@ -414,7 +425,7 @@ export function WorkoutPanel({ <> ) : null} -
-
+
+

Terrain workouts

-

+

Resistance follows the climbs and descents while your position moves along the route.

-

- +

-
- { - const file = event.currentTarget.files?.[0]; - event.currentTarget.value = ''; - if (file) { - importWorkout(file); - } - }} - ref={importInput} - type="file" - /> - - -
@@ -598,6 +611,36 @@ export function WorkoutPanel({
+ {bikeGpxBrowserOpen ? ( + + Loading BikeGPX browser… +
+ } + > + setBikeGpxBrowserOpen(false)} + onImportCourse={async (course) => { + const imported = await onImportCourse(course); + setSearchQuery(''); + workoutListScroll.scrollToTop(); + setLibraryStatus(`${imported.name} imported and saved on this device.`); + return imported; + }} + onRefreshCatalog={bikeGpxCatalog.refresh} + speedUnit={speedUnit} + /> + + ) : null} {mappedCourse ? ( OpenStreetMap contributors'; +const ROUTE_COLOR = '#67e8f9'; +const ROUTE_OUTLINE_COLOR = '#071018'; +const START_COLOR = '#adf5bd'; +const FINISH_COLOR = '#fbbf24'; +const ENDPOINT_EPSILON = 0.000_001; +const BIKE_ROUTE_DURATION_MS = 30_000; +const BIKE_MARKER_HTML = + ''; + +function routeCoordinates(course: WorkoutCourse): LatLngExpression[] { + return course.points.map((point) => [point.latitude, point.longitude]); +} + +function endpointsOverlap(course: WorkoutCourse): boolean { + const [start] = course.points; + const finish = course.points.at(-1); + return Boolean( + start && + finish && + Math.abs(start.latitude - finish.latitude) < ENDPOINT_EPSILON && + Math.abs(start.longitude - finish.longitude) < ENDPOINT_EPSILON + ); +} + +export function WorkoutRouteMap({ course }: { course: WorkoutCourse }) { + const mapContainer = useRef(null); + + useEffect(() => { + const container = mapContainer.current; + if (!container) { + return; + } + const coordinates = routeCoordinates(course); + const [start] = coordinates; + const finish = coordinates.at(-1); + if (!start) { + return; + } + + const routeMap = createLeafletMap(container, { + attributionControl: true, + zoomControl: true, + }); + tileLayer(MAP_TILE_URL, { + attribution: MAP_ATTRIBUTION, + className: 'ride-control-map-tiles', + maxZoom: 19, + }).addTo(routeMap); + + const routeOutline = polyline(coordinates, { + color: ROUTE_OUTLINE_COLOR, + opacity: 0.75, + weight: 9, + }).addTo(routeMap); + polyline(coordinates, { + color: ROUTE_COLOR, + lineCap: 'round', + lineJoin: 'round', + opacity: 0.95, + weight: 5, + }).addTo(routeMap); + + const sharedEndpoint = endpointsOverlap(course); + circleMarker(start, { + color: ROUTE_OUTLINE_COLOR, + fillColor: START_COLOR, + fillOpacity: 1, + radius: 7, + weight: 3, + }) + .bindTooltip(sharedEndpoint ? 'Start and finish' : 'Start') + .addTo(routeMap); + if (finish && !sharedEndpoint) { + circleMarker(finish, { + color: ROUTE_OUTLINE_COLOR, + fillColor: FINISH_COLOR, + fillOpacity: 1, + radius: 7, + weight: 3, + }) + .bindTooltip('Finish') + .addTo(routeMap); + } + + const bikePosition = workoutRouteCoordinateAtProgress(course.points, 0); + let animationFrame = 0; + if (bikePosition) { + const bike = marker([bikePosition.latitude, bikePosition.longitude], { + icon: divIcon({ + className: 'ride-control-bike-marker', + html: BIKE_MARKER_HTML, + iconAnchor: [17, 17], + iconSize: [34, 34], + }), + interactive: false, + keyboard: false, + title: 'Bike riding the route', + zIndexOffset: 1000, + }).addTo(routeMap); + let animationStart: number | undefined; + const animateBike = (timestamp: number) => { + animationStart ??= timestamp; + const progress = + ((timestamp - animationStart) % BIKE_ROUTE_DURATION_MS) / + BIKE_ROUTE_DURATION_MS; + const position = workoutRouteCoordinateAtProgress(course.points, progress); + if (position) { + bike.setLatLng([position.latitude, position.longitude]); + } + animationFrame = window.requestAnimationFrame(animateBike); + }; + animationFrame = window.requestAnimationFrame(animateBike); + } + + const bounds = routeOutline.getBounds(); + if (bounds.isValid()) { + routeMap.fitBounds(bounds, { maxZoom: 16, padding: [48, 48] }); + } else { + routeMap.setView(start, 14); + } + + return () => { + window.cancelAnimationFrame(animationFrame); + routeMap.remove(); + }; + }, [course]); + + return ( +
+
+
+
+ + {endpointsOverlap(course) ? 'Start and finish' : 'Start'} +
+ {endpointsOverlap(course) ? null : ( +
+ + Finish +
+ )} +
+
+ ); +} diff --git a/src/hooks/use-bikegpx-catalog.ts b/src/hooks/use-bikegpx-catalog.ts new file mode 100644 index 0000000..1b75883 --- /dev/null +++ b/src/hooks/use-bikegpx-catalog.ts @@ -0,0 +1,77 @@ +import { useCallback, useEffect, useState } from 'react'; +import { + type BikeGpxCatalog, + type BikeGpxRouteAnalysis, + fetchBikeGpxCatalog, +} from '../lib/bikegpx'; +import { errorMessage } from '../lib/errors'; + +let catalogRequest: Promise | undefined; + +function requestCatalog(): Promise { + catalogRequest ??= fetchBikeGpxCatalog().finally(() => { + catalogRequest = undefined; + }); + return catalogRequest; +} + +export function useBikeGpxCatalog(active: boolean) { + const [catalog, setCatalog] = useState(); + const [error, setError] = useState(''); + const [initialized, setInitialized] = useState(false); + const [loading, setLoading] = useState(false); + + useEffect(() => { + if (!(active && !initialized)) { + return; + } + let cancelled = false; + setError(''); + setLoading(true); + requestCatalog() + .then((initialCatalog) => { + if (!cancelled) { + setCatalog(initialCatalog); + } + }) + .catch((initialError) => { + if (!cancelled) { + setError(errorMessage(initialError)); + } + }) + .finally(() => { + if (!cancelled) { + setInitialized(true); + setLoading(false); + } + }); + return () => { + cancelled = true; + }; + }, [active, initialized]); + + const refresh = useCallback(async () => { + setError(''); + setLoading(true); + try { + setCatalog(await requestCatalog()); + } catch (nextError) { + setError(errorMessage(nextError)); + } finally { + setLoading(false); + } + }, []); + + const updateRouteAnalysis = useCallback((routeId: string, analysis: BikeGpxRouteAnalysis) => { + setCatalog((currentCatalog) => + currentCatalog + ? { + ...currentCatalog, + analyses: { ...currentCatalog.analyses, [routeId]: analysis }, + } + : currentCatalog + ); + }, []); + + return { catalog, error, loading, refresh, updateRouteAnalysis }; +} diff --git a/src/hooks/use-workout-library.ts b/src/hooks/use-workout-library.ts index 5188dca..c608215 100644 --- a/src/hooks/use-workout-library.ts +++ b/src/hooks/use-workout-library.ts @@ -39,10 +39,8 @@ export function useWorkoutLibrary() { saveWorkoutOrder(next); setCourseOrder(next); }, []); - - const importFile = useCallback( - async (file: File) => { - const course = await readWorkoutFile(file); + const importCourse = useCallback( + (course: WorkoutCourse) => { const result = addCustomWorkout(customCoursesRef.current, course); const nextCourses = prioritizeWorkoutCourse( [...WORKOUT_COURSES, ...result.courses], @@ -56,6 +54,14 @@ export function useWorkoutLibrary() { [replaceCourseOrder, replaceCustomCourses] ); + const importFile = useCallback( + async (file: File) => { + const course = await readWorkoutFile(file); + return importCourse(course); + }, + [importCourse] + ); + const removeCourse = useCallback( (courseId: string) => { replaceCustomCourses(withoutCustomWorkout(customCoursesRef.current, courseId)); @@ -88,6 +94,7 @@ export function useWorkoutLibrary() { return { courses, customCourseIds, + importCourse, importFile, removeCourse, renameCourse, diff --git a/src/lib/bikegpx.ts b/src/lib/bikegpx.ts new file mode 100644 index 0000000..ca9f7b8 --- /dev/null +++ b/src/lib/bikegpx.ts @@ -0,0 +1,221 @@ +import type { WorkoutCourse, WorkoutRoutePoint } from '../types'; +import { isFiniteNumber, isRecord, isString } from './type-guards'; +import { KILOMETERS_PER_MILE } from './units'; +import { isWorkoutDifficulty, type WorkoutDifficulty } from './workout-schema'; + +export const BIKEGPX_ROUTES_URL = 'https://bikegpx.com/bike_routes/'; +const SEARCH_WHITESPACE = /\s+/u; +const NUMERIC_ROUTE_ID = /^\d+$/; +const API_ROOT = (import.meta.env.VITE_RIDECONTROL_API_URL || '/api').replace(/\/$/u, ''); + +export interface BikeGpxRouteSummary { + country: string; + distanceKm: number; + id: string; + name: string; + summary: string; +} + +export interface BikeGpxCatalog { + analyses: Record; + fetchedAt: number; + routes: BikeGpxRouteSummary[]; +} + +export interface BikeGpxRouteAnalysis { + difficulty: WorkoutDifficulty; + elevationGain: number; + maximumGrade: number; +} + +export interface BikeGpxRouteResult { + analysis: BikeGpxRouteAnalysis; + course: WorkoutCourse; +} + +export function bikeGpxRouteMatchesQuery( + route: BikeGpxRouteSummary, + query: string, + analysis?: BikeGpxRouteAnalysis +): boolean { + const terms = query.trim().toLocaleLowerCase().split(SEARCH_WHITESPACE).filter(Boolean); + if (terms.length === 0) { + return true; + } + const miles = route.distanceKm / KILOMETERS_PER_MILE; + const difficulty = analysis?.difficulty ?? 'uncategorized'; + const searchable = + `${route.name} ${route.country} ${route.summary} ${difficulty} ${route.distanceKm.toFixed(1)} ${route.distanceKm.toFixed(0)} ${route.distanceKm.toFixed(1)}km ${route.distanceKm.toFixed(0)}km km kilometer kilometers ${miles.toFixed(1)} ${miles.toFixed(0)} ${miles.toFixed(1)}mi ${miles.toFixed(0)}mi mi mile miles`.toLocaleLowerCase(); + return terms.every((term) => searchable.includes(term)); +} + +function routeAnalysis(value: unknown): BikeGpxRouteAnalysis | undefined { + if ( + !( + isRecord(value) && + isWorkoutDifficulty(value.difficulty) && + isFiniteNumber(value.elevationGain) && + value.elevationGain >= 0 && + isFiniteNumber(value.maximumGrade) && + value.maximumGrade >= 0 + ) + ) { + return; + } + return { + difficulty: value.difficulty, + elevationGain: value.elevationGain, + maximumGrade: value.maximumGrade, + }; +} + +function routeSummary(value: unknown): BikeGpxRouteSummary | undefined { + if ( + !( + isRecord(value) && + isString(value.country) && + isFiniteNumber(value.distanceKm) && + value.distanceKm > 0 && + isString(value.id) && + NUMERIC_ROUTE_ID.test(value.id) && + isString(value.name) && + isString(value.summary) + ) + ) { + return; + } + return { + country: value.country, + distanceKm: value.distanceKm, + id: value.id, + name: value.name, + summary: value.summary, + }; +} + +function routePoint(value: unknown): WorkoutRoutePoint | undefined { + if ( + !( + isRecord(value) && + isFiniteNumber(value.distance) && + isFiniteNumber(value.elevation) && + isFiniteNumber(value.latitude) && + isFiniteNumber(value.longitude) && + isFiniteNumber(value.x) && + isFiniteNumber(value.y) + ) + ) { + return; + } + return { + distance: value.distance, + elevation: value.elevation, + latitude: value.latitude, + longitude: value.longitude, + x: value.x, + y: value.y, + }; +} + +function routeCourse(value: unknown): WorkoutCourse | undefined { + if ( + !( + isRecord(value) && + isFiniteNumber(value.baseResistance) && + isString(value.description) && + isWorkoutDifficulty(value.difficulty) && + isFiniteNumber(value.distance) && + value.distance > 0 && + isFiniteNumber(value.elevationGain) && + value.elevationGain >= 0 && + isString(value.id) && + value.id.length > 0 && + isString(value.name) && + value.name.length > 0 && + Array.isArray(value.points) && + (value.routeType === 'loop' || value.routeType === 'point-to-point') + ) + ) { + return; + } + const points = value.points.flatMap((point) => routePoint(point) ?? []); + if (points.length !== value.points.length || points.length < 3) { + return; + } + return { + baseResistance: value.baseResistance, + description: value.description, + difficulty: value.difficulty, + distance: value.distance, + elevationGain: value.elevationGain, + id: value.id, + name: value.name, + points, + routeType: value.routeType, + }; +} + +export function restoreBikeGpxCatalog(value: unknown): BikeGpxCatalog | undefined { + if (!(isRecord(value) && isFiniteNumber(value.fetchedAt) && Array.isArray(value.routes))) { + return; + } + const routes = value.routes.flatMap((route) => routeSummary(route) ?? []); + if (routes.length !== value.routes.length || routes.length === 0) { + return; + } + const routeIds = new Set(routes.map((route) => route.id)); + const analyses = isRecord(value.analyses) + ? Object.fromEntries( + Object.entries(value.analyses).flatMap(([routeId, analysis]) => { + const restored = routeIds.has(routeId) ? routeAnalysis(analysis) : undefined; + return restored ? [[routeId, restored]] : []; + }) + ) + : {}; + return { analyses, fetchedAt: value.fetchedAt, routes }; +} + +function restoreBikeGpxRouteResult(value: unknown): BikeGpxRouteResult | undefined { + if (!isRecord(value)) { + return; + } + const analysis = routeAnalysis(value.analysis); + const course = routeCourse(value.course); + return analysis && course ? { analysis, course } : undefined; +} + +async function apiJson(path: string, signal?: AbortSignal): Promise { + const response = await fetch(`${API_ROOT}${path}`, { signal }); + const value: unknown = await response.json(); + if (!response.ok) { + const message = + isRecord(value) && isString(value.error) ? value.error : 'Backend request failed.'; + throw new Error(message); + } + return value; +} + +export async function fetchBikeGpxCatalog(signal?: AbortSignal): Promise { + const catalog = restoreBikeGpxCatalog(await apiJson('/bikegpx/routes', signal)); + if (!catalog) { + throw new Error('The Ride Control backend returned an invalid BikeGPX catalog.'); + } + return catalog; +} + +export async function fetchBikeGpxRoute( + route: BikeGpxRouteSummary, + signal?: AbortSignal +): Promise { + const result = restoreBikeGpxRouteResult( + await apiJson(`/bikegpx/routes/${encodeURIComponent(route.id)}`, signal) + ); + if (!result) { + throw new Error('The Ride Control backend returned an invalid BikeGPX route.'); + } + return result; +} + +export function bikeGpxRouteUrl(routeId: string): string { + return `${BIKEGPX_ROUTES_URL}${routeId}`; +} diff --git a/src/lib/workout-metrics.ts b/src/lib/workout-metrics.ts new file mode 100644 index 0000000..16bd05d --- /dev/null +++ b/src/lib/workout-metrics.ts @@ -0,0 +1,15 @@ +import type { WorkoutCourse } from '../types'; + +export function workoutMaximumGrade(course: Pick): number { + return course.points.reduce((maximum, point, index) => { + const previous = course.points[index - 1]; + if (!previous || point.distance <= previous.distance) { + return maximum; + } + const grade = + ((point.elevation - previous.elevation) / + ((point.distance - previous.distance) * 1000)) * + 100; + return Math.max(maximum, grade); + }, 0); +} diff --git a/src/lib/workouts.ts b/src/lib/workouts.ts index dbabe7f..a0c9cac 100644 --- a/src/lib/workouts.ts +++ b/src/lib/workouts.ts @@ -438,20 +438,6 @@ export function workoutElevationTotalsAtDistance( }; } -export function workoutMaximumGrade(course: WorkoutCourse): number { - return course.points.reduce((maximum, point, index) => { - const previous = course.points[index - 1]; - if (!previous || point.distance <= previous.distance) { - return maximum; - } - const grade = - ((point.elevation - previous.elevation) / - ((point.distance - previous.distance) * 1000)) * - 100; - return Math.max(maximum, grade); - }, 0); -} - export function workoutTerrainAtDistance( course: WorkoutCourse, totalDistance: number diff --git a/tests/bikegpx.test.ts b/tests/bikegpx.test.ts new file mode 100644 index 0000000..76a952c --- /dev/null +++ b/tests/bikegpx.test.ts @@ -0,0 +1,105 @@ +import { afterEach, describe, expect, mock, test } from 'bun:test'; +import { + type BikeGpxCatalog, + bikeGpxRouteMatchesQuery, + bikeGpxRouteUrl, + fetchBikeGpxCatalog, + fetchBikeGpxRoute, + restoreBikeGpxCatalog, +} from '../src/lib/bikegpx'; +import type { WorkoutCourse } from '../src/types'; + +const route = { + country: 'Aland Islands', + distanceKm: 12, + id: '2635', + name: 'Cykelbana Godby - Finby', + summary: 'Near Finström → Near Sund — 12 km', +}; + +const catalog: BikeGpxCatalog = { + analyses: { + '2635': { difficulty: 'moderate', elevationGain: 100, maximumGrade: 5 }, + }, + fetchedAt: 1000, + routes: [route], +}; + +const course: WorkoutCourse = { + baseResistance: 12, + description: 'Aland Islands · Near Finström → Near Sund — 12 km', + difficulty: 'moderate', + distance: 0.25, + elevationGain: 10, + id: 'gpx-12345678', + name: route.name, + points: [ + { distance: 0, elevation: 11.4, latitude: 60.230_04, longitude: 19.987_38, x: 8, y: 92 }, + { + distance: 0.125, + elevation: 21.4, + latitude: 60.231_04, + longitude: 19.988_38, + x: 50, + y: 50, + }, + { + distance: 0.25, + elevation: 16.4, + latitude: 60.232_04, + longitude: 19.989_38, + x: 92, + y: 8, + }, + ], + routeType: 'point-to-point', +}; + +const originalFetch = globalThis.fetch; + +afterEach(() => { + globalThis.fetch = originalFetch; +}); + +describe('BikeGPX backend client', () => { + test('restores a validated backend catalog', () => { + expect(restoreBikeGpxCatalog(catalog)).toEqual(catalog); + expect( + restoreBikeGpxCatalog({ ...catalog, routes: [{ ...route, id: 'not-numeric' }] }) + ).toBe(undefined); + }); + + test('searches route distances in metric and imperial units', () => { + expect(bikeGpxRouteMatchesQuery(route, '12 km')).toBeTrue(); + expect(bikeGpxRouteMatchesQuery(route, '12km')).toBeTrue(); + expect(bikeGpxRouteMatchesQuery(route, '7.5 mi')).toBeTrue(); + expect(bikeGpxRouteMatchesQuery(route, 'moderate', catalog.analyses[route.id])).toBeTrue(); + expect(bikeGpxRouteMatchesQuery(route, '50 km')).toBeFalse(); + expect(bikeGpxRouteUrl(route.id)).toBe('https://bikegpx.com/bike_routes/2635'); + }); + + test('loads the catalog from the Ride Control backend API', async () => { + const fetchMock = mock(async () => Response.json(catalog)); + globalThis.fetch = fetchMock as unknown as typeof fetch; + expect(await fetchBikeGpxCatalog()).toEqual(catalog); + expect(fetchMock).toHaveBeenCalledWith('/api/bikegpx/routes', { signal: undefined }); + }); + + test('loads an already processed route and analysis from the backend API', async () => { + const result = { + analysis: catalog.analyses[route.id], + course, + }; + const fetchMock = mock(async () => Response.json(result)); + globalThis.fetch = fetchMock as unknown as typeof fetch; + expect(await fetchBikeGpxRoute(route)).toEqual(result); + expect(fetchMock).toHaveBeenCalledWith('/api/bikegpx/routes/2635', { signal: undefined }); + }); + + test('surfaces backend errors', async () => { + globalThis.fetch = mock(async () => + Response.json({ error: 'BikeGPX is unavailable.' }, { status: 502 }) + ) as unknown as typeof fetch; + await expect(fetchBikeGpxCatalog()).rejects.toThrow('BikeGPX is unavailable.'); + }); +}); diff --git a/tests/components.test.tsx b/tests/components.test.tsx index 8e81888..cf370ec 100644 --- a/tests/components.test.tsx +++ b/tests/components.test.tsx @@ -508,6 +508,7 @@ describe('view components', () => { courses={WORKOUT_COURSES} customCourseIds={noCustomWorkoutIds} onClose={() => undefined} + onImportCourse={() => Promise.reject(new Error('Not used in this render test'))} onImportFile={() => Promise.reject(new Error('Not used in this render test'))} onRemoveCourse={() => undefined} onRenameCourse={() => course} @@ -528,8 +529,8 @@ describe('view components', () => { expect(panel).toContain('Harbor Ring course map'); expect(panel).toContain('Harbor Ring elevation profile'); expect(panel).toContain('Import GPX'); - expect(panel).toContain('href="https://bikegpx.com/bike_routes/"'); - expect(panel).toContain('BikeGPX has thousands of GPX files'); + expect(panel).toContain('Browse BikeGPX'); + expect(panel).toContain('Browse thousands of public BikeGPX routes'); expect(panel).toContain('data-gpx-drop-target="true"'); expect(panel).toContain('data-testid="workout-list"'); expect(panel).toContain('placeholder="Search by name or difficulty"'); @@ -575,6 +576,7 @@ describe('view components', () => { courses={[...WORKOUT_COURSES, importedCourse]} customCourseIds={new Set([importedCourse.id])} onClose={() => undefined} + onImportCourse={() => Promise.reject(new Error('Not used in this render test'))} onImportFile={() => Promise.reject(new Error('Not used in this render test'))} onRemoveCourse={() => undefined} onRenameCourse={() => importedCourse} @@ -621,6 +623,7 @@ describe('view components', () => { courses={WORKOUT_COURSES} customCourseIds={noCustomWorkoutIds} onClose={() => undefined} + onImportCourse={() => Promise.reject(new Error('Not used in this render test'))} onImportFile={() => Promise.reject(new Error('Not used in this render test'))} onRemoveCourse={() => undefined} onRenameCourse={() => course} @@ -640,6 +643,7 @@ describe('view components', () => { courses={WORKOUT_COURSES} customCourseIds={noCustomWorkoutIds} onClose={() => undefined} + onImportCourse={() => Promise.reject(new Error('Not used in this render test'))} onImportFile={() => Promise.reject(new Error('Not used in this render test'))} onRemoveCourse={() => undefined} onRenameCourse={() => course} diff --git a/tests/workouts.test.ts b/tests/workouts.test.ts index cb902bb..487475d 100644 --- a/tests/workouts.test.ts +++ b/tests/workouts.test.ts @@ -1,4 +1,5 @@ import { describe, expect, test } from 'bun:test'; +import { workoutMaximumGrade } from '../src/lib/workout-metrics'; import { WORKOUT_ROUTE_TYPE } from '../src/lib/workout-schema'; import { outAndBackRoutePoints, @@ -16,7 +17,6 @@ import { workoutMapPath, workoutMapProgressPath, workoutMatchesSearch, - workoutMaximumGrade, workoutProfilePath, workoutProfilePosition, workoutProgress, From b935ddf2b21c09e96e976c2230f8dfa384a95689 Mon Sep 17 00:00:00 2001 From: Ride Control Date: Tue, 21 Jul 2026 11:43:51 -0700 Subject: [PATCH 3/7] docs: keep frontend README product-focused --- README.md | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 1212f94..17bfad5 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ Bike trainer control web app using Web Bluetooth. Tested with Wahoo KICKR Core 2 - Shows live speed, power, cadence, heart rate, elapsed time, distance, and estimated calories, with MPH and KM/H display modes. - Provides direct resistance control with buttons, a slider, and keyboard shortcuts with matching button feedback, shows smoothing progress inside the slider thumb, and records resistance changes alongside the other ride metrics. - Offers original terrain workouts built as repeatable courses, with gentle, rolling, and climbing options and distinctive winding top-down route shapes. Courses explicitly support loops, point-to-point routes, and out-and-back routes; an out-and-back follows the supplied path to its turnaround, then reverses the same location and elevation data back to the start before repeating. Prairie Roll adds a non-intersecting, curving 15-mile loop of long, gradual rollers centered around 20% resistance and ranging from roughly 15–25%. Granite Switchbacks adds a sustained four-mile ascent whose hairpin corners briefly get steeper before immediately returning to the steady climbing grade, followed by a ridge and a descending sequence of five recovery rollers. Ridgeline Time Trial is a ten-mile out-and-back with a gradual five-mile, roughly 300-foot hillclimb to the turnaround and the identical terrain in reverse on the return. Every course begins flat without giving nearly level routes an unnecessarily long rollout: low-climb courses use about 0.4 km, moderate rollers use about 0.8 km, and climbing-focused courses retain a 1.5 km rollout. The course then automatically adjusts trainer resistance from the current grade, tracks the rider in compact, vertically aligned top-down and elevation views with a clearly labelled ridden-this-lap, ridden-this-trip, or ridden-this-route path and pulsing position markers while pedaling, and uses clear mid-contrast preview lines with a shared elevation scale so gentle rollers remain visibly low beside genuinely mountainous routes. It shows course distance progress to two decimal places alongside course percentage, current grade, and effective trainer resistance directly on the map, with grade and resistance values matching their graph colors, and derives cumulative ride climbing and downhill from course distance so those totals remain aligned with the advertised full-course climb. Elevation appears in feet with MPH or meters with KM/H, and terrain totals and progress are recorded with the session and preserved in saved history and TCX import/export. Currently open in-progress sessions resolve bundled workout IDs to the latest course definition, preventing stale geometry from lingering before a ride is saved; saved history keeps the exact workout snapshot used by that ride. A workout can be selected before riding or planned while viewing a completed session; a newly planned workout immediately replaces the prior course on the dashboard at 0% progress without changing the completed ride's recorded data. It then remains locked from the moment riding begins until that session ends; definition refreshes for that same workout remain allowed without opening a path to switch courses. Workout terrain remains the base load when Zwift Click is paired, allowing virtual gears to scale that resistance without losing the grade-driven course behavior. -- Downloads terrain workouts as standard GPX 1.1 files containing geographic track points and elevation data, with names and descriptions readable by ordinary GPX tools and Ride Control extensions for stable ids, difficulty, baseline resistance, exact workout distance, saved starting location, and point-to-point, loop, or out-and-back course type. Valid GPX tracks or routes from other tools can be imported through the file picker or by dropping a GPX anywhere in the workout tray, then saved into a custom library on the current device; each newly imported workout appears immediately at the top and keeps that position after reloading. A map-first BikeGPX browser is built directly into the terrain tray: it searches more than six thousand public routes by name, place, distance in kilometers or miles, or difficulty; filters by country, minimum and maximum distance in the rider's current units, and terrain-based difficulty; continuously scrolls an efficiently virtualized list; previews the complete GPX over OpenStreetMap; and imports the selected route into Ride Control in one click. The separate Cloudflare Worker backend refreshes the public catalog once per day, stores it in Workers KV, downloads GPX files directly from BikeGPX without a third-party proxy, calculates route geometry and terrain difficulty, and caches each processed route in KV. The frontend receives ready-to-use courses and validated analyses through `/api`; visible routes are requested with bounded concurrency so their server-calculated ratings appear progressively. The same route fingerprint used for uploaded files prevents duplicate imports. An imported route's linked “Starts in” description opens an in-app map dialog beside the workout tray, fits its complete path with start and finish markers over an attributed OpenStreetMap base map, and continuously animates a standard bicycle marker along the route. Routes whose start and finish are genuinely near each other become loops automatically; other GPX routes remain one-way, start-to-finish courses without a generated return leg. The workout library filters immediately by course name or displayed difficulty, and every card keeps an up/down-arrow drag handle in the top-right corner; dragging moves the complete workout card strictly vertically, accepts a drop anywhere over another workout, and animates the surrounding cards out of the way to open a full-card-sized insertion space before saving the preferred order across browser reloads. The terrain tray remembers both that it was open and its workout-list scroll position across page reloads. Import, rename, and reorder feedback stays in a fixed bottom status area beside the selected-workout clearing action, preventing the workout list from shifting. Imported workout names can be clicked and renamed without changing the route's stable duplicate-detection identifier. Their top-down geometry is derived from latitude and longitude, terrain resistance is derived from elevation, and a route without its own description uses its first coordinate to label the starting city through a cached OpenStreetMap lookup, then saves that location directly with the workout so restoring or re-importing a Ride Control GPX does not repeat the request. Missing Ride Control metadata receives safe defaults. Stable workout ids—or a route fingerprint for third-party GPX—prevent built-in or previously imported workouts from being uploaded again. Imported entries can be removed, large tracks are sampled for efficient riding, and the geographic source model is ready for a future workout editor. +- Downloads terrain workouts as standard GPX 1.1 files containing geographic track points and elevation data, with names and descriptions readable by ordinary GPX tools and Ride Control extensions for stable ids, difficulty, baseline resistance, exact workout distance, saved starting location, and point-to-point, loop, or out-and-back course type. Valid GPX tracks or routes from other tools can be imported through the file picker or by dropping a GPX anywhere in the workout tray, then saved into a custom library on the current device; each newly imported workout appears immediately at the top and keeps that position after reloading. A map-first BikeGPX browser is built directly into the terrain tray: it searches more than six thousand public routes by name, place, distance in kilometers or miles, or difficulty; filters by country, minimum and maximum distance in the rider's current units, and terrain-based difficulty; continuously scrolls an efficiently virtualized list; previews the complete GPX over OpenStreetMap; and imports the selected route into Ride Control in one click. Difficulty is calculated from distance, total climbing, climbing density, and maximum grade, with route ratings appearing progressively as routes load. The same route fingerprint used for uploaded files prevents duplicate imports. An imported route's linked “Starts in” description opens an in-app map dialog beside the workout tray, fits its complete path with start and finish markers over an attributed OpenStreetMap base map, and continuously animates a standard bicycle marker along the route. Routes whose start and finish are genuinely near each other become loops automatically; other GPX routes remain one-way, start-to-finish courses without a generated return leg. The workout library filters immediately by course name or displayed difficulty, and every card keeps an up/down-arrow drag handle in the top-right corner; dragging moves the complete workout card strictly vertically, accepts a drop anywhere over another workout, and animates the surrounding cards out of the way to open a full-card-sized insertion space before saving the preferred order across browser reloads. The terrain tray remembers both that it was open and its workout-list scroll position across page reloads. Import, rename, and reorder feedback stays in a fixed bottom status area beside the selected-workout clearing action, preventing the workout list from shifting. Imported workout names can be clicked and renamed without changing the route's stable duplicate-detection identifier. Their top-down geometry is derived from latitude and longitude, terrain resistance is derived from elevation, and a route without its own description uses its first coordinate to label the starting city through a cached OpenStreetMap lookup, then saves that location directly with the workout so restoring or re-importing a Ride Control GPX does not repeat the request. Missing Ride Control metadata receives safe defaults. Stable workout ids—or a route fingerprint for third-party GPX—prevent built-in or previously imported workouts from being uploaded again. Imported entries can be removed, large tracks are sampled for efficient riding, and the geographic source model is ready for a future workout editor. - Replaces direct resistance controls with a focused 1–24 virtual shifting interface whenever Zwift Click V2 is paired, including during terrain workouts, and restores the standard resistance control as soon as both controllers are forgotten. Shifting becomes available once the trainer and both controllers are connected, and the Click minus/plus buttons, on-screen controls, and keyboard down/up arrows step through the 24 physical combinations of 39/53-tooth chainrings and a 12-speed 12–24-tooth cassette, sorted by actual drivetrain ratio rather than equal percentage intervals. This gives gear 24 the full 53/12 top end for pushing on descents while retaining 39/24 as gear 1 for climbing. Holding a shift control continues shifting, terrain changes remain smoothly automated underneath the selected gear, and sessions record both the selected gear and applied trainer resistance. - Automatically records while pedaling, auto-pauses during inactivity, supports manual pause and resume, and allows a session to end at any time—even before trainer data arrives. Finishing a ride smoothly returns a connected trainer to 10% resistance; if it is disconnected, 10% is remembered and applied when it reconnects. - Tracks complete time-series data plus averages and maximums for power, cadence, heart rate, speed, resistance, and virtual gear, with large, high-visibility numbers in space-efficient live metric and ride-summary cards, oversized numeric ride totals with subdued unit labels, and focused or combined chart views with subtle separator bands between stacked metrics. Workout grade and elevation are graphed in their own distinct colors, resistance remains visible alongside gear during virtual shifting, and the gear graph stays hidden outside gear mode unless the session contains recorded gear data. The larger chart tabs distribute across the complete chart width. Workout elevation is recorded across the entire ride, so the course profile repeats in the graph for every completed loop. Saved sessions reference immutable, content-addressed workout snapshots in a separate IndexedDB store: identical course definitions share one snapshot, edited definitions retain their historical versions, and deleting a workout from the selectable library cannot break an older session's maps or terrain details. @@ -28,7 +28,7 @@ Bike trainer control web app using Web Bluetooth. Tested with Wahoo KICKR Core 2 - Protects recorded active rides with a browser confirmation before refresh or close, and presents the save workflow before starting or continuing another session. - Includes contextual keyboard help for dashboard and history actions, including pausing, ending, starting, navigating, viewing history, and deleting sessions. - Displays connection and application notices with a visible 15-second countdown and automatic dismissal. -- Keeps ride and session data local to the current browser profile; no account is required. When an imported GPX route has no description, only its first coordinate is sent to OpenStreetMap's Nominatim service to find a starting-city label, and that result is cached in the browser and stored with the workout. The resulting location sentence links to OpenStreetMap in a new tab, frames the complete route area, and marks the starting coordinate. The frontend sends only public BikeGPX route ids to the Ride Control backend; it does not send ride history, paired-device details, or locally saved workouts. +- Keeps ride and session data local to the current browser profile; no account is required. When an imported GPX route has no description, only its first coordinate is sent to OpenStreetMap's Nominatim service to find a starting-city label, and that result is cached in the browser and stored with the workout. The resulting location sentence links to OpenStreetMap in a new tab, frames the complete route area, and marks the starting coordinate. ## Run @@ -39,10 +39,6 @@ bun run dev Open in current Chrome. -The app calls `/api` by default. For local development with the separate Worker on port 8787, -start Vite with `VITE_RIDECONTROL_API_URL=http://localhost:8787/api`. Set the same variable to the -deployed Worker API origin in the frontend deployment environment. - ## Architecture Ride session data is held in a per-app TanStack Store and changed through atomic domain actions. From 7413b2d4bd3b20976a4071cd20bb30ba99a2c190 Mon Sep 17 00:00:00 2001 From: Ride Control Date: Tue, 21 Jul 2026 11:57:17 -0700 Subject: [PATCH 4/7] Migrate frontend hosting to Cloudflare Workers --- .../{deploy-pages.yml => deploy-worker.yml} | 38 ++-- .gitignore | 4 + README.md | 2 +- bun.lock | 170 +++++++++++++++++- package.json | 5 +- vite.config.ts | 3 +- wrangler.jsonc | 16 ++ 7 files changed, 209 insertions(+), 29 deletions(-) rename .github/workflows/{deploy-pages.yml => deploy-worker.yml} (71%) create mode 100644 wrangler.jsonc diff --git a/.github/workflows/deploy-pages.yml b/.github/workflows/deploy-worker.yml similarity index 71% rename from .github/workflows/deploy-pages.yml rename to .github/workflows/deploy-worker.yml index 5a002b1..e1d2f0e 100644 --- a/.github/workflows/deploy-pages.yml +++ b/.github/workflows/deploy-worker.yml @@ -1,4 +1,4 @@ -name: Deploy GitHub Pages +name: Deploy Worker on: workflow_run: @@ -12,20 +12,20 @@ on: permissions: contents: read - pages: write pull-requests: read - id-token: write concurrency: - group: pages + group: production-worker cancel-in-progress: false jobs: - - build: - name: Build site + deploy: + name: Deploy Worker if: github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' runs-on: ubuntu-latest + environment: + name: production + url: https://ridecontrol.xyz steps: - name: Check out verified revision uses: actions/checkout@v7 @@ -35,8 +35,6 @@ jobs: uses: oven-sh/setup-bun@v2 with: bun-version: latest - - name: Set up GitHub Pages - uses: actions/configure-pages@v6 - name: Install dependencies run: bun install --frozen-lockfile - name: Resolve build metadata @@ -50,21 +48,11 @@ jobs: build_pr_url="https://github.com/${GITHUB_REPOSITORY}/pulls?q=is%3Apr+is%3Aclosed" fi echo "VITE_BUILD_PR_URL=${build_pr_url}" >> "$GITHUB_ENV" - - name: Build site + - name: Build Worker run: bun run build - - name: Upload site artifact - uses: actions/upload-pages-artifact@v5 + - name: Deploy Worker + uses: cloudflare/wrangler-action@v3 with: - path: dist - - deploy: - name: Deploy site - needs: build - runs-on: ubuntu-latest - environment: - name: github-pages - url: ${{ steps.deployment.outputs.page_url }} - steps: - - name: Deploy to GitHub Pages - id: deployment - uses: actions/deploy-pages@v5 + accountId: c1e6e1378d9461aa07039950b1bf8b89 + apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }} + command: deploy diff --git a/.gitignore b/.gitignore index 3bdd52e..8ac3fc4 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,7 @@ node_modules/ dist/ +.wrangler/ +.dev.vars +.dev.vars.* +!.dev.vars.example .DS_Store diff --git a/README.md b/README.md index 17bfad5..3820e90 100644 --- a/README.md +++ b/README.md @@ -75,7 +75,7 @@ and repeated dialog and keyboard behavior so those rules stay consistent across Pull requests and pushes to `main` run the complete `bun run ci` suite in GitHub Actions. After CI succeeds on `main`, a separate workflow runs `bun run build` and deploys the generated `dist` -directory to GitHub Pages at [ridecontrol.xyz](https://ridecontrol.xyz). +assets to a Cloudflare Worker at [ridecontrol.xyz](https://ridecontrol.xyz). ## Automatic reconnect diff --git a/bun.lock b/bun.lock index 303c4f0..10cafc9 100644 --- a/bun.lock +++ b/bun.lock @@ -20,6 +20,7 @@ }, "devDependencies": { "@biomejs/biome": "^2.5.4", + "@cloudflare/vite-plugin": "^1.45.1", "@tailwindcss/language-server": "^0.16.0", "@types/bun": "^1.3.14", "@types/leaflet": "^1.9.21", @@ -30,6 +31,7 @@ "typescript": "^7.0.2", "ultracite": "^7.9.4", "vite": "^8.1.5", + "wrangler": "^4.112.0", }, }, }, @@ -56,6 +58,24 @@ "@clack/prompts": ["@clack/prompts@1.7.0", "", { "dependencies": { "@clack/core": "1.4.3", "fast-string-width": "^3.0.2", "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-y7/yvZ2TPAnR9+jnc00klvNNLkJiXFFrQA/hlLCcxA9a2A4zQIOimyFQ9XfwYKiGD1fb5GY8vbKIIgO8d5Tb2A=="], + "@cloudflare/kv-asset-handler": ["@cloudflare/kv-asset-handler@0.5.0", "", {}, "sha512-jxQYkj8dSIzc0cD6cMMNdOc1UVjqSqu8BZdor5s8cGjW2I8BjODt/kWPVdY+u9zj3ms75Q5qaZgnxUad83+eAg=="], + + "@cloudflare/unenv-preset": ["@cloudflare/unenv-preset@2.16.1", "", { "peerDependencies": { "unenv": "2.0.0-rc.24", "workerd": ">1.20260305.0 <2.0.0-0" }, "optionalPeers": ["workerd"] }, "sha512-ECxObrMfyTl5bhQf/lZCXwo5G6xX9IAUo+nDMKK4SZ8m4Jvvxp52vilxyySSWh2YTZz8+HQ07qGH/2rEom1vDw=="], + + "@cloudflare/vite-plugin": ["@cloudflare/vite-plugin@1.45.1", "", { "dependencies": { "@cloudflare/unenv-preset": "2.16.1", "miniflare": "4.20260714.0", "unenv": "2.0.0-rc.24", "workerd": "1.20260714.1", "wrangler": "4.112.0", "ws": "8.21.0" }, "peerDependencies": { "vite": "^6.1.0 || ^7.0.0 || ^8.0.0" }, "bin": { "cf-vite": "bin/cf-vite" } }, "sha512-C+iDpO9pVH7IqrjdYtUV+obcTAdpiNk0OSinGEZZyd2ZWyGVjGk7iJ2p3xpMBpZuTa1I4hfAECNp0yN/8f3PIQ=="], + + "@cloudflare/workerd-darwin-64": ["@cloudflare/workerd-darwin-64@1.20260714.1", "", { "os": "darwin", "cpu": "x64" }, "sha512-ZWXqAN8G7Cx9hMRQuk+59ziJhR3j1F4iO+Qs8aHdfKZ3Dq5Yi/57xvkJTgCGBnW1YU/L78r8f6HEy51bwbTpNw=="], + + "@cloudflare/workerd-darwin-arm64": ["@cloudflare/workerd-darwin-arm64@1.20260714.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-tueWxWC3wyCbMG6zRAxsMXX0YLgrRWbiAPYFQ2uJ7dUH8G+5E7UTWaQS9B1HdJ0bpKFW1NWxhs1o2noKVFSUYg=="], + + "@cloudflare/workerd-linux-64": ["@cloudflare/workerd-linux-64@1.20260714.1", "", { "os": "linux", "cpu": "x64" }, "sha512-1VChTZRb0l0F7R4e1G5RtLKV4oFi6x+rQgxh2+yu887j3l/3TLgatuv1L8/5zhc9gKEhATTxOh0e52Rtd9dDWQ=="], + + "@cloudflare/workerd-linux-arm64": ["@cloudflare/workerd-linux-arm64@1.20260714.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-rMm3G+NirG2UdgHIRDdF1asNC6FqgIzZzkRG+VDhhDGcVxAQwvrMT1E38BivEvHr3G04MB4AfhcOczX0+GtRkQ=="], + + "@cloudflare/workerd-windows-64": ["@cloudflare/workerd-windows-64@1.20260714.1", "", { "os": "win32", "cpu": "x64" }, "sha512-cGqnU3Hg2YZS/k3SAqrMp1DjpdsyFde72tWltdl6ZT9+SFz/Zrk/8gyTU1TcxC4YApXeNVH5TyU5cOGPgUJ0pg=="], + + "@cspotcode/source-map-support": ["@cspotcode/source-map-support@0.8.1", "", { "dependencies": { "@jridgewell/trace-mapping": "0.3.9" } }, "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw=="], + "@dnd-kit/accessibility": ["@dnd-kit/accessibility@3.1.1", "", { "dependencies": { "tslib": "^2.0.0" }, "peerDependencies": { "react": ">=16.8.0" } }, "sha512-2P+YgaXF+gRsIihwwY1gCsQSYnu9Zyj2py8kY5fFvUM1qm2WA2u639R6YNVfU4GWr+ZM5mqEsfHZZLoRONbemw=="], "@dnd-kit/core": ["@dnd-kit/core@6.3.1", "", { "dependencies": { "@dnd-kit/accessibility": "^3.1.1", "@dnd-kit/utilities": "^3.2.2", "tslib": "^2.0.0" }, "peerDependencies": { "react": ">=16.8.0", "react-dom": ">=16.8.0" } }, "sha512-xkGBRQQab4RLwgXxoqETICr6S5JlogafbhNsidmrkVv2YRs5MLwpjoF2qpiGjQt8S9AoxtIV603s0GIUpY5eYQ=="], @@ -72,6 +92,58 @@ "@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.2", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA=="], + "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.28.1", "", { "os": "aix", "cpu": "ppc64" }, "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ=="], + + "@esbuild/android-arm": ["@esbuild/android-arm@0.28.1", "", { "os": "android", "cpu": "arm" }, "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ=="], + + "@esbuild/android-arm64": ["@esbuild/android-arm64@0.28.1", "", { "os": "android", "cpu": "arm64" }, "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg=="], + + "@esbuild/android-x64": ["@esbuild/android-x64@0.28.1", "", { "os": "android", "cpu": "x64" }, "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng=="], + + "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.28.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q=="], + + "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.28.1", "", { "os": "darwin", "cpu": "x64" }, "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ=="], + + "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.28.1", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw=="], + + "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.28.1", "", { "os": "freebsd", "cpu": "x64" }, "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ=="], + + "@esbuild/linux-arm": ["@esbuild/linux-arm@0.28.1", "", { "os": "linux", "cpu": "arm" }, "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ=="], + + "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.28.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g=="], + + "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.28.1", "", { "os": "linux", "cpu": "ia32" }, "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w=="], + + "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.28.1", "", { "os": "linux", "cpu": "none" }, "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg=="], + + "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.28.1", "", { "os": "linux", "cpu": "none" }, "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ=="], + + "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.28.1", "", { "os": "linux", "cpu": "ppc64" }, "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ=="], + + "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.28.1", "", { "os": "linux", "cpu": "none" }, "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ=="], + + "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.28.1", "", { "os": "linux", "cpu": "s390x" }, "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag=="], + + "@esbuild/linux-x64": ["@esbuild/linux-x64@0.28.1", "", { "os": "linux", "cpu": "x64" }, "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA=="], + + "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.28.1", "", { "os": "none", "cpu": "arm64" }, "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw=="], + + "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.28.1", "", { "os": "none", "cpu": "x64" }, "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg=="], + + "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.28.1", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q=="], + + "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.28.1", "", { "os": "openbsd", "cpu": "x64" }, "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw=="], + + "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.28.1", "", { "os": "none", "cpu": "arm64" }, "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg=="], + + "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.28.1", "", { "os": "sunos", "cpu": "x64" }, "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ=="], + + "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.28.1", "", { "os": "win32", "cpu": "arm64" }, "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA=="], + + "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.28.1", "", { "os": "win32", "cpu": "ia32" }, "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg=="], + + "@esbuild/win32-x64": ["@esbuild/win32-x64@0.28.1", "", { "os": "win32", "cpu": "x64" }, "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A=="], + "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.9.1", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ=="], "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.2", "", {}, "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew=="], @@ -96,6 +168,56 @@ "@humanwhocodes/retry": ["@humanwhocodes/retry@0.4.3", "", {}, "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ=="], + "@img/colour": ["@img/colour@1.1.0", "", {}, "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ=="], + + "@img/sharp-darwin-arm64": ["@img/sharp-darwin-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-arm64": "1.2.4" }, "os": "darwin", "cpu": "arm64" }, "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w=="], + + "@img/sharp-darwin-x64": ["@img/sharp-darwin-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-darwin-x64": "1.2.4" }, "os": "darwin", "cpu": "x64" }, "sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw=="], + + "@img/sharp-libvips-darwin-arm64": ["@img/sharp-libvips-darwin-arm64@1.2.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g=="], + + "@img/sharp-libvips-darwin-x64": ["@img/sharp-libvips-darwin-x64@1.2.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg=="], + + "@img/sharp-libvips-linux-arm": ["@img/sharp-libvips-linux-arm@1.2.4", "", { "os": "linux", "cpu": "arm" }, "sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A=="], + + "@img/sharp-libvips-linux-arm64": ["@img/sharp-libvips-linux-arm64@1.2.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw=="], + + "@img/sharp-libvips-linux-ppc64": ["@img/sharp-libvips-linux-ppc64@1.2.4", "", { "os": "linux", "cpu": "ppc64" }, "sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA=="], + + "@img/sharp-libvips-linux-riscv64": ["@img/sharp-libvips-linux-riscv64@1.2.4", "", { "os": "linux", "cpu": "none" }, "sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA=="], + + "@img/sharp-libvips-linux-s390x": ["@img/sharp-libvips-linux-s390x@1.2.4", "", { "os": "linux", "cpu": "s390x" }, "sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ=="], + + "@img/sharp-libvips-linux-x64": ["@img/sharp-libvips-linux-x64@1.2.4", "", { "os": "linux", "cpu": "x64" }, "sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw=="], + + "@img/sharp-libvips-linuxmusl-arm64": ["@img/sharp-libvips-linuxmusl-arm64@1.2.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw=="], + + "@img/sharp-libvips-linuxmusl-x64": ["@img/sharp-libvips-linuxmusl-x64@1.2.4", "", { "os": "linux", "cpu": "x64" }, "sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg=="], + + "@img/sharp-linux-arm": ["@img/sharp-linux-arm@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm": "1.2.4" }, "os": "linux", "cpu": "arm" }, "sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw=="], + + "@img/sharp-linux-arm64": ["@img/sharp-linux-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-arm64": "1.2.4" }, "os": "linux", "cpu": "arm64" }, "sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg=="], + + "@img/sharp-linux-ppc64": ["@img/sharp-linux-ppc64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-ppc64": "1.2.4" }, "os": "linux", "cpu": "ppc64" }, "sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA=="], + + "@img/sharp-linux-riscv64": ["@img/sharp-linux-riscv64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-riscv64": "1.2.4" }, "os": "linux", "cpu": "none" }, "sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw=="], + + "@img/sharp-linux-s390x": ["@img/sharp-linux-s390x@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-s390x": "1.2.4" }, "os": "linux", "cpu": "s390x" }, "sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg=="], + + "@img/sharp-linux-x64": ["@img/sharp-linux-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linux-x64": "1.2.4" }, "os": "linux", "cpu": "x64" }, "sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ=="], + + "@img/sharp-linuxmusl-arm64": ["@img/sharp-linuxmusl-arm64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-arm64": "1.2.4" }, "os": "linux", "cpu": "arm64" }, "sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg=="], + + "@img/sharp-linuxmusl-x64": ["@img/sharp-linuxmusl-x64@0.34.5", "", { "optionalDependencies": { "@img/sharp-libvips-linuxmusl-x64": "1.2.4" }, "os": "linux", "cpu": "x64" }, "sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q=="], + + "@img/sharp-wasm32": ["@img/sharp-wasm32@0.34.5", "", { "dependencies": { "@emnapi/runtime": "^1.7.0" }, "cpu": "none" }, "sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw=="], + + "@img/sharp-win32-arm64": ["@img/sharp-win32-arm64@0.34.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g=="], + + "@img/sharp-win32-ia32": ["@img/sharp-win32-ia32@0.34.5", "", { "os": "win32", "cpu": "ia32" }, "sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg=="], + + "@img/sharp-win32-x64": ["@img/sharp-win32-x64@0.34.5", "", { "os": "win32", "cpu": "x64" }, "sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw=="], + "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="], "@jridgewell/remapping": ["@jridgewell/remapping@2.3.5", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ=="], @@ -104,12 +226,18 @@ "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="], - "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="], + "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.9", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.0.3", "@jridgewell/sourcemap-codec": "^1.4.10" } }, "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ=="], "@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@1.1.6", "", { "dependencies": { "@tybys/wasm-util": "^0.10.3" }, "peerDependencies": { "@emnapi/core": "^1.7.1", "@emnapi/runtime": "^1.7.1" } }, "sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg=="], "@oxc-project/types": ["@oxc-project/types@0.139.0", "", {}, "sha512-r9gHphtCs+1M7J0pw6Sn/hh/Wpa/iQrOOkrNAlVLF/gHq+/CJmHIWKKUUhdWjcD6CIa8idarspCsASiXCXvFUw=="], + "@poppinss/colors": ["@poppinss/colors@4.1.6", "", { "dependencies": { "kleur": "^4.1.5" } }, "sha512-H9xkIdFswbS8n1d6vmRd8+c10t2Qe+rZITbbDHHkQixH5+2x1FDGmi/0K+WgWiqQFKPSlIYB7jlH6Kpfn6Fleg=="], + + "@poppinss/dumper": ["@poppinss/dumper@0.6.5", "", { "dependencies": { "@poppinss/colors": "^4.1.5", "@sindresorhus/is": "^7.0.2", "supports-color": "^10.0.0" } }, "sha512-NBdYIb90J7LfOI32dOewKI1r7wnkiH6m920puQ3qHUeZkxNkQiFnXVWoE6YtFSv6QOiPPf7ys6i+HWWecDz7sw=="], + + "@poppinss/exception": ["@poppinss/exception@1.2.3", "", {}, "sha512-dCED+QRChTVatE9ibtoaxc+WkdzOSjYTKi/+uacHWIsfodVfpsueo3+DKpgU5Px8qXjgmXkSvhXvSCz3fnP9lw=="], + "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.1.5", "", { "os": "android", "cpu": "arm64" }, "sha512-lZg8fqIv2v7FF237bwMgzGZEJvGL79/s5knJ/i6FmsGF4XXlzccZ4jb+TrFIxtSSxFtIpdsgrPZeMk1I9AFcyQ=="], "@rolldown/binding-darwin-arm64": ["@rolldown/binding-darwin-arm64@1.1.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-51Bnx9pNiMRKSUNtBfySkNJ9vMU9Hh3I1ozDd6gyPPYzaXCfnptUcEZxXGYFn+ul2dtcMUiqGR1Yai2K10uoTw=="], @@ -142,6 +270,10 @@ "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.1", "", {}, "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="], + "@sindresorhus/is": ["@sindresorhus/is@7.2.0", "", {}, "sha512-P1Cz1dWaFfR4IR+U13mqqiGsLFf1KbayybWwdd2vfctdV6hDpUkgCY0nKOLLTMSoRd/jJNjtbqzf13K8DCCXQw=="], + + "@speed-highlight/core": ["@speed-highlight/core@1.2.17", "", {}, "sha512-Z92FwKpCtfaW1V0jTU/fh3QzYEZN8wDwrzRIBoADCJfn4mJCNcJN/XegifX7BDrQ8/h9Xh/JnbyMchL0FqXrkg=="], + "@tailwindcss/language-server": ["@tailwindcss/language-server@0.16.0", "", { "bin": { "css-language-server": "bin/css-language-server", "tailwindcss-language-server": "bin/tailwindcss-language-server" } }, "sha512-ko2xr4nlFIkqwJFnnw7hfdpjbsnK0DOk+QEEI51tvKOCF97OG0RU59iGfadoaOoY6I9xkSMbTW+AAwgnGnLH3w=="], "@tailwindcss/node": ["@tailwindcss/node@4.3.3", "", { "dependencies": { "@jridgewell/remapping": "^2.3.5", "enhanced-resolve": "^5.24.1", "jiti": "^2.7.0", "lightningcss": "1.32.0", "magic-string": "^0.30.21", "source-map-js": "^1.2.1", "tailwindcss": "4.3.3" } }, "sha512-/T8IKEsf9VTU6tLjgC7+sv2mOPtQxzE2jMw7u4Tt40Tx+QSZxpzh95/H6cMKoja9XuW7iMdLJYBB0o9G1CaAgg=="], @@ -270,6 +402,8 @@ "balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="], + "blake3-wasm": ["blake3-wasm@2.1.5", "", {}, "sha512-F1+K8EbfOZE49dtoPtmxUQrpXaBIl3ICvasLh+nJta0xkz+9kF/7uet9fLnwKqhDrmj6g+6K3Tw9yQPUg2ka5g=="], + "brace-expansion": ["brace-expansion@5.0.7", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA=="], "bun-types": ["bun-types@1.3.14", "", { "dependencies": { "@types/node": "*" } }, "sha512-4N0ig0fEomHt5R0KCFWjovxow98rIoRwKolrYdCcknNwMekCXRnWEUvgu5soYV8QXtVsrUD8B95MBOZGPvr6KQ=="], @@ -278,6 +412,8 @@ "commander": ["commander@15.0.0", "", {}, "sha512-z67u4ZhzCL/Tydu1lJARtEZYWbWaN7oYLHbsuzocr6y4N6WZAagG3RQ4FW61V1/0+jImpj293XfrcYnd1qxtPg=="], + "cookie": ["cookie@1.1.1", "", {}, "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ=="], + "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="], "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="], @@ -292,6 +428,10 @@ "enhanced-resolve": ["enhanced-resolve@5.24.2", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-rpsZEGT1jFuve6QlpyRp9ckQ+kN61hvF9BzCPyMdaKTm8UJce96KBn3sorXOFXlzjPrs3Vc4T1NsSroZ3PxlFw=="], + "error-stack-parser-es": ["error-stack-parser-es@1.0.5", "", {}, "sha512-5qucVt2XcuGMcEGgWI7i+yZpmpByQ8J1lHhcL7PwqCwu9FPP3VUXzT4ltHe5i2z9dePwEHcDVOAfSnHsOlCXRA=="], + + "esbuild": ["esbuild@0.28.1", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.28.1", "@esbuild/android-arm": "0.28.1", "@esbuild/android-arm64": "0.28.1", "@esbuild/android-x64": "0.28.1", "@esbuild/darwin-arm64": "0.28.1", "@esbuild/darwin-x64": "0.28.1", "@esbuild/freebsd-arm64": "0.28.1", "@esbuild/freebsd-x64": "0.28.1", "@esbuild/linux-arm": "0.28.1", "@esbuild/linux-arm64": "0.28.1", "@esbuild/linux-ia32": "0.28.1", "@esbuild/linux-loong64": "0.28.1", "@esbuild/linux-mips64el": "0.28.1", "@esbuild/linux-ppc64": "0.28.1", "@esbuild/linux-riscv64": "0.28.1", "@esbuild/linux-s390x": "0.28.1", "@esbuild/linux-x64": "0.28.1", "@esbuild/netbsd-arm64": "0.28.1", "@esbuild/netbsd-x64": "0.28.1", "@esbuild/openbsd-arm64": "0.28.1", "@esbuild/openbsd-x64": "0.28.1", "@esbuild/openharmony-arm64": "0.28.1", "@esbuild/sunos-x64": "0.28.1", "@esbuild/win32-arm64": "0.28.1", "@esbuild/win32-ia32": "0.28.1", "@esbuild/win32-x64": "0.28.1" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw=="], + "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="], "eslint": ["eslint@10.7.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.2", "@eslint/config-array": "^0.23.5", "@eslint/config-helpers": "^0.6.0", "@eslint/core": "^1.2.1", "@eslint/plugin-kit": "^0.7.2", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", "@types/estree": "^1.0.6", "ajv": "^6.14.0", "cross-spawn": "^7.0.6", "debug": "^4.3.2", "escape-string-regexp": "^4.0.0", "eslint-scope": "^9.1.2", "eslint-visitor-keys": "^5.0.1", "espree": "^11.2.0", "esquery": "^1.7.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^8.0.0", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "json-stable-stringify-without-jsonify": "^1.0.1", "minimatch": "^10.2.4", "natural-compare": "^1.4.0", "optionator": "^0.9.3" }, "peerDependencies": { "jiti": "*" }, "optionalPeers": ["jiti"], "bin": { "eslint": "bin/eslint.js" } }, "sha512-GVTD7s1vdIl6UYvAfriOPeY1Df8LIZjfofLvHwde+erDHGGuHyuM6xoxRxmHiebhYuD2p1vN4wWh0XzPARSGDQ=="], @@ -364,6 +504,8 @@ "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="], + "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="], + "leaflet": ["leaflet@1.9.4", "", {}, "sha512-nxS1ynzJOmOlHp+iL3FyWqK89GtNL8U8rvlMOsQdTTssxZwCXh8N2NB3GDQOL+YR3XnWyZAxwQixURb+FA74PA=="], "levn": ["levn@0.4.1", "", { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="], @@ -398,6 +540,8 @@ "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="], + "miniflare": ["miniflare@4.20260714.0", "", { "dependencies": { "@cspotcode/source-map-support": "0.8.1", "sharp": "0.34.5", "undici": "7.28.0", "workerd": "1.20260714.1", "ws": "8.21.0", "youch": "4.1.0-beta.10" }, "bin": { "miniflare": "bootstrap.js" } }, "sha512-MYlTCLdWCPqvrYY2uLwOjXwmglXuiHE3TGGkbOW4BwjUPa1r07E0iuHwrNDIs/sxK21r+o90Jx58AV2KeNdJZw=="], + "minimatch": ["minimatch@10.2.5", "", { "dependencies": { "brace-expansion": "^5.0.5" } }, "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg=="], "minipass": ["minipass@7.1.3", "", {}, "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A=="], @@ -422,6 +566,8 @@ "path-scurry": ["path-scurry@2.0.2", "", { "dependencies": { "lru-cache": "^11.0.0", "minipass": "^7.1.2" } }, "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg=="], + "path-to-regexp": ["path-to-regexp@6.3.0", "", {}, "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ=="], + "pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="], "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="], @@ -444,6 +590,8 @@ "semver": ["semver@7.8.5", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA=="], + "sharp": ["sharp@0.34.5", "", { "dependencies": { "@img/colour": "^1.0.0", "detect-libc": "^2.1.2", "semver": "^7.7.3" }, "optionalDependencies": { "@img/sharp-darwin-arm64": "0.34.5", "@img/sharp-darwin-x64": "0.34.5", "@img/sharp-libvips-darwin-arm64": "1.2.4", "@img/sharp-libvips-darwin-x64": "1.2.4", "@img/sharp-libvips-linux-arm": "1.2.4", "@img/sharp-libvips-linux-arm64": "1.2.4", "@img/sharp-libvips-linux-ppc64": "1.2.4", "@img/sharp-libvips-linux-riscv64": "1.2.4", "@img/sharp-libvips-linux-s390x": "1.2.4", "@img/sharp-libvips-linux-x64": "1.2.4", "@img/sharp-libvips-linuxmusl-arm64": "1.2.4", "@img/sharp-libvips-linuxmusl-x64": "1.2.4", "@img/sharp-linux-arm": "0.34.5", "@img/sharp-linux-arm64": "0.34.5", "@img/sharp-linux-ppc64": "0.34.5", "@img/sharp-linux-riscv64": "0.34.5", "@img/sharp-linux-s390x": "0.34.5", "@img/sharp-linux-x64": "0.34.5", "@img/sharp-linuxmusl-arm64": "0.34.5", "@img/sharp-linuxmusl-x64": "0.34.5", "@img/sharp-wasm32": "0.34.5", "@img/sharp-win32-arm64": "0.34.5", "@img/sharp-win32-ia32": "0.34.5", "@img/sharp-win32-x64": "0.34.5" } }, "sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg=="], + "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="], "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="], @@ -452,6 +600,8 @@ "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="], + "supports-color": ["supports-color@10.2.2", "", {}, "sha512-SS+jx45GF1QjgEXQx4NJZV9ImqmO2NPz5FNsIHrsDjh2YsHnawpan7SNQ1o8NuhrbHZy9AZhIoCUiCeaW/C80g=="], + "tailwindcss": ["tailwindcss@4.3.3", "", {}, "sha512-gOhV3P7ufE62QDGg1zVaTgCR+EtPv92k2nIhVcVKcLmxT1sUBsQGhnZj175j+MqRt4zLF7ic+sCYjfhxMxj7YQ=="], "tapable": ["tapable@2.3.3", "", {}, "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A=="], @@ -470,8 +620,12 @@ "ultracite": ["ultracite@7.9.4", "", { "dependencies": { "@clack/prompts": "^1.5.1", "@typescript-eslint/utils": "^8.62.1", "commander": "^15.0.0", "cross-spawn": "^7.0.6", "deepmerge": "^4.3.1", "glob": "^13.0.6", "jsonc-parser": "^3.3.1", "nypm": "^0.6.6", "yaml": "^2.9.0", "zod": "^4.4.3" }, "peerDependencies": { "oxfmt": ">=0.1.0", "oxlint": "^1.0.0" }, "optionalPeers": ["oxfmt", "oxlint"], "bin": { "ultracite": "dist/index.js" } }, "sha512-efAEbQJoii3wH0aZ+jwbcGXQYBwC1E6TvC4//EIV3ei84RDGHDo9fSB6h/TBTNk/+/psQVGm56trVvA+2VwRbg=="], + "undici": ["undici@7.28.0", "", {}, "sha512-cRZYrTDwWznlnRiPjggAGxZXanty6M8RV1ff8Wm4LWXBp7/IG8v5DnOm74DtUBp9OONpK75YlPnIjQqX0dBDtA=="], + "undici-types": ["undici-types@8.3.0", "", {}, "sha512-j375ScV60dom+YkPFIfTLcOiPxkN/buHz5GobjLhixFuANaNs3C9l4GmrWqejgXWJ7BbJcFYpTEUkS1Ge8bpZQ=="], + "unenv": ["unenv@2.0.0-rc.24", "", { "dependencies": { "pathe": "^2.0.3" } }, "sha512-i7qRCmY42zmCwnYlh9H2SvLEypEFGye5iRmEMKjcGi7zk9UquigRjFtTLz0TYqr0ZGLZhaMHl/foy1bZR+Cwlw=="], + "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="], "use-sync-external-store": ["use-sync-external-store@1.6.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w=="], @@ -482,12 +636,26 @@ "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="], + "workerd": ["workerd@1.20260714.1", "", { "optionalDependencies": { "@cloudflare/workerd-darwin-64": "1.20260714.1", "@cloudflare/workerd-darwin-arm64": "1.20260714.1", "@cloudflare/workerd-linux-64": "1.20260714.1", "@cloudflare/workerd-linux-arm64": "1.20260714.1", "@cloudflare/workerd-windows-64": "1.20260714.1" }, "bin": { "workerd": "bin/workerd" } }, "sha512-oIbQzfdyl9UQUnG6XLegcSq0Mgt/7WKDbFOoqGgOWCS+/fhyGB460uKEgdAQQ9RHCO/ttcNCX/KiMIQzdoeu3Q=="], + + "wrangler": ["wrangler@4.112.0", "", { "dependencies": { "@cloudflare/kv-asset-handler": "0.5.0", "@cloudflare/unenv-preset": "2.16.1", "blake3-wasm": "2.1.5", "esbuild": "0.28.1", "miniflare": "4.20260714.0", "path-to-regexp": "6.3.0", "unenv": "2.0.0-rc.24", "workerd": "1.20260714.1" }, "optionalDependencies": { "fsevents": "2.3.3" }, "peerDependencies": { "@cloudflare/workers-types": "^5.20260714.1" }, "optionalPeers": ["@cloudflare/workers-types"], "bin": { "cf-wrangler": "bin/cf-wrangler.js", "wrangler": "bin/wrangler.js", "wrangler2": "bin/wrangler.js" } }, "sha512-5H+XUD0TySCv1LuktFHDIEOkboH2nTfQs+35L+USt3MtntjDTMVIJprLgQcL2WBjulOyjxpd1vyTiSTJVW5MjQ=="], + + "ws": ["ws@8.21.0", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g=="], + "yaml": ["yaml@2.9.0", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA=="], "yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="], + "youch": ["youch@4.1.0-beta.10", "", { "dependencies": { "@poppinss/colors": "^4.1.5", "@poppinss/dumper": "^0.6.4", "@speed-highlight/core": "^1.2.7", "cookie": "^1.0.2", "youch-core": "^0.3.3" } }, "sha512-rLfVLB4FgQneDr0dv1oddCVZmKjcJ6yX6mS4pU82Mq/Dt9a3cLZQ62pDBL4AUO+uVrCvtWz3ZFUL2HFAFJ/BXQ=="], + + "youch-core": ["youch-core@0.3.3", "", { "dependencies": { "@poppinss/exception": "^1.2.2", "error-stack-parser-es": "^1.0.5" } }, "sha512-ho7XuGjLaJ2hWHoK8yFnsUGy2Y5uDpqSTq1FkHLK4/oqKtyUU1AFbOOxY4IpC9f0fTLjwYbslUz0Po5BpD1wrA=="], + "zod": ["zod@4.4.3", "", {}, "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ=="], + "@jridgewell/gen-mapping/@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="], + + "@jridgewell/remapping/@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="], + "@tailwindcss/oxide-wasm32-wasi/@emnapi/core": ["@emnapi/core@1.11.1", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.2", "tslib": "^2.4.0" }, "bundled": true }, "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ=="], "@tailwindcss/oxide-wasm32-wasi/@emnapi/runtime": ["@emnapi/runtime@1.11.1", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw=="], diff --git a/package.json b/package.json index a64225c..a4aa7ff 100644 --- a/package.json +++ b/package.json @@ -11,6 +11,7 @@ "test": "bun test", "tailwind:check": "bun scripts/check-tailwind.ts", "ci": "biome check . && bun run tailwind:check && bun test && tsc --noEmit && vite build", + "deploy": "bun run build && wrangler deploy", "preview": "vite preview --host localhost --port 4200" }, "dependencies": { @@ -29,6 +30,7 @@ }, "devDependencies": { "@biomejs/biome": "^2.5.4", + "@cloudflare/vite-plugin": "^1.45.1", "@tailwindcss/language-server": "^0.16.0", "@types/bun": "^1.3.14", "@types/leaflet": "^1.9.21", @@ -38,6 +40,7 @@ "@xmldom/xmldom": "^0.9.10", "typescript": "^7.0.2", "ultracite": "^7.9.4", - "vite": "^8.1.5" + "vite": "^8.1.5", + "wrangler": "^4.112.0" } } diff --git a/vite.config.ts b/vite.config.ts index 76fd282..1c0292c 100644 --- a/vite.config.ts +++ b/vite.config.ts @@ -1,3 +1,4 @@ +import { cloudflare } from '@cloudflare/vite-plugin'; import tailwindcss from '@tailwindcss/vite'; import react from '@vitejs/plugin-react'; import { defineConfig } from 'vite'; @@ -12,5 +13,5 @@ export default defineConfig({ 'import.meta.env.RIDE_CONTROL_BUILD_PR_URL': JSON.stringify(buildPrUrl), 'import.meta.env.RIDE_CONTROL_BUILD_TIMESTAMP_UTC': JSON.stringify(buildTimestampUtc), }, - plugins: [react(), tailwindcss()], + plugins: [react(), tailwindcss(), cloudflare()], }); diff --git a/wrangler.jsonc b/wrangler.jsonc new file mode 100644 index 0000000..a9da7e9 --- /dev/null +++ b/wrangler.jsonc @@ -0,0 +1,16 @@ +{ + "$schema": "./node_modules/wrangler/config-schema.json", + "name": "ridecontrol-frontend", + "account_id": "c1e6e1378d9461aa07039950b1bf8b89", + "compatibility_date": "2026-07-21", + "workers_dev": false, + "routes": [ + { + "pattern": "ridecontrol.xyz", + "custom_domain": true + } + ], + "assets": { + "not_found_handling": "single-page-application" + } +} From cd78c90a84404dc37decc1a44538b7df3336a977 Mon Sep 17 00:00:00 2001 From: Ride Control Date: Tue, 21 Jul 2026 13:13:18 -0700 Subject: [PATCH 5/7] chore: update repository links --- src/components/app-footer.tsx | 2 +- src/components/welcome-dialog.tsx | 2 +- src/lib/build-info.ts | 2 +- src/lib/tcx-import.ts | 6 +++--- src/lib/tcx-schema.ts | 20 ++++++++++++++++++-- src/lib/workout-file.ts | 2 +- tests/build-info.test.ts | 8 ++++---- tests/components.test.tsx | 8 ++++---- tests/tcx-import.test.ts | 6 ++++++ vite.config.ts | 2 +- 10 files changed, 40 insertions(+), 18 deletions(-) diff --git a/src/components/app-footer.tsx b/src/components/app-footer.tsx index 9bb72e6..5fe343b 100644 --- a/src/components/app-footer.tsx +++ b/src/components/app-footer.tsx @@ -13,7 +13,7 @@ export function AppFooter({ onOpenWelcome }: { onOpenWelcome: () => void }) { diff --git a/src/components/welcome-dialog.tsx b/src/components/welcome-dialog.tsx index 0ecbd25..d7eaca9 100644 --- a/src/components/welcome-dialog.tsx +++ b/src/components/welcome-dialog.tsx @@ -62,7 +62,7 @@ export function WelcomeDialog({ Ride Control is a freely available, open-source GPLv3 application. View the{' '} diff --git a/src/lib/build-info.ts b/src/lib/build-info.ts index 6702f43..a34d9b3 100644 --- a/src/lib/build-info.ts +++ b/src/lib/build-info.ts @@ -1,4 +1,4 @@ -const DEFAULT_BUILD_PR_URL = 'https://github.com/lookfirst/RideControl/pulls'; +const DEFAULT_BUILD_PR_URL = 'https://github.com/RideControlOrg/RideControl/pulls'; export function buildPullRequestUrl(url: string) { return url.endsWith('/pulls') ? `${url}?q=is%3Apr+is%3Aclosed` : url; diff --git a/src/lib/tcx-import.ts b/src/lib/tcx-import.ts index 9fbdbba..9c45ca7 100644 --- a/src/lib/tcx-import.ts +++ b/src/lib/tcx-import.ts @@ -17,7 +17,7 @@ import { nonNegativeNumber } from './numbers'; import { clampResistance } from './resistance'; import { listAllSavedSessions, saveSession } from './saved-sessions'; import { addMetricAggregates } from './session'; -import { IMPORTED_TCX_ID_PREFIX, RIDECONTROL_TCX_EXTENSION_NAMESPACE } from './tcx-schema'; +import { IMPORTED_TCX_ID_PREFIX, isRideControlTcxExtensionNamespace } from './tcx-schema'; import { KILOMETERS_PER_HOUR_PER_METER_PER_SECOND, kilometersForMeters, @@ -286,8 +286,8 @@ function parseActivity(activity: Element): SavedSession { ); const distanceMeters = lapDistanceMeters || trackpointDistanceMeters; const calories = positiveSum(laps.map((lap) => numberValue(child(lap, 'Calories')))); - const exportedSessionId = descendants(activity, 'SessionId').find( - (element) => element.namespaceURI === RIDECONTROL_TCX_EXTENSION_NAMESPACE + const exportedSessionId = descendants(activity, 'SessionId').find((element) => + isRideControlTcxExtensionNamespace(element.namespaceURI) ); const hasGear = allSamples.some((sample) => sample.gear !== undefined) || diff --git a/src/lib/tcx-schema.ts b/src/lib/tcx-schema.ts index 3573e67..59747fe 100644 --- a/src/lib/tcx-schema.ts +++ b/src/lib/tcx-schema.ts @@ -1,6 +1,22 @@ export const TCX_NAMESPACE = 'http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2'; export const TCX_ACTIVITY_EXTENSION_NAMESPACE = 'http://www.garmin.com/xmlschemas/ActivityExtension/v2'; -export const RIDECONTROL_TCX_EXTENSION_NAMESPACE = - 'https://github.com/lookfirst/RideControl/xmlschemas/ActivityExtension/v1'; +const RIDECONTROL_TCX_EXTENSION_NAMESPACE_PATH = '/RideControl/xmlschemas/ActivityExtension/v1'; +export const RIDECONTROL_TCX_EXTENSION_NAMESPACE = `https://github.com/RideControlOrg${RIDECONTROL_TCX_EXTENSION_NAMESPACE_PATH}`; export const IMPORTED_TCX_ID_PREFIX = 'tcx:'; + +export function isRideControlTcxExtensionNamespace(namespace: string | null) { + if (!namespace) { + return false; + } + try { + const url = new URL(namespace); + return ( + url.protocol === 'https:' && + url.hostname === 'github.com' && + url.pathname.endsWith(RIDECONTROL_TCX_EXTENSION_NAMESPACE_PATH) + ); + } catch { + return false; + } +} diff --git a/src/lib/workout-file.ts b/src/lib/workout-file.ts index 8f1cf8d..83d94b2 100644 --- a/src/lib/workout-file.ts +++ b/src/lib/workout-file.ts @@ -27,7 +27,7 @@ import { xmlDescendant, xmlEscape, xmlNumber, xmlText } from './xml'; export const CUSTOM_WORKOUTS_STORAGE_KEY = 'ride-control-custom-workouts'; export const WORKOUT_ORDER_STORAGE_KEY = 'ride-control-workout-order'; export const WORKOUT_GPX_EXTENSION_NAMESPACE = - 'https://github.com/lookfirst/RideControl/xmlschemas/WorkoutExtension/v1'; + 'https://github.com/RideControlOrg/RideControl/xmlschemas/WorkoutExtension/v1'; export const WORKOUT_GPX_FORMAT_VERSION = 2; export const MAX_WORKOUT_NAME_LENGTH = 100; diff --git a/tests/build-info.test.ts b/tests/build-info.test.ts index 35b6915..3e75a2c 100644 --- a/tests/build-info.test.ts +++ b/tests/build-info.test.ts @@ -3,11 +3,11 @@ import { BUILD_PR_URL, buildPullRequestUrl, formatBuildTimestamp } from '../src/ describe('build information', () => { test('links exact builds to their PR and defaults PR lists to closed', () => { - expect(buildPullRequestUrl('https://github.com/lookfirst/RideControl/pull/12')).toBe( - 'https://github.com/lookfirst/RideControl/pull/12' + expect(buildPullRequestUrl('https://github.com/RideControlOrg/RideControl/pull/12')).toBe( + 'https://github.com/RideControlOrg/RideControl/pull/12' ); - expect(buildPullRequestUrl('https://github.com/lookfirst/RideControl/pulls')).toBe( - 'https://github.com/lookfirst/RideControl/pulls?q=is%3Apr+is%3Aclosed' + expect(buildPullRequestUrl('https://github.com/RideControlOrg/RideControl/pulls')).toBe( + 'https://github.com/RideControlOrg/RideControl/pulls?q=is%3Apr+is%3Aclosed' ); expect(BUILD_PR_URL).toContain('q=is%3Apr+is%3Aclosed'); }); diff --git a/tests/components.test.tsx b/tests/components.test.tsx index cf370ec..504b82c 100644 --- a/tests/components.test.tsx +++ b/tests/components.test.tsx @@ -349,7 +349,7 @@ describe('view components', () => { expect(panel).toContain('Copy Chrome Bluetooth settings address'); expect(panel).toContain('Use the new permissions backend for Web Bluetooth'); expect(panel).toContain('Relaunch Chrome, then pair each device once more.'); - expect(panel).not.toContain('github.com/lookfirst/RideControl#automatic-reconnect'); + expect(panel).not.toContain('github.com/RideControlOrg/RideControl#automatic-reconnect'); expect(panel).toContain('+ Controller'); expect(panel.indexOf('+ Controller')).toBeLessThan(panel.indexOf('− Controller')); expect(panel).toContain('connection-status-pulse'); @@ -770,10 +770,10 @@ describe('view components', () => { expect(html).toContain('Ride Control'); expect(html).toContain('Build:'); expect(html).toContain( - 'href="https://github.com/lookfirst/RideControl/pulls?q=is%3Apr+is%3Aclosed"' + 'href="https://github.com/RideControlOrg/RideControl/pulls?q=is%3Apr+is%3Aclosed"' ); expect(html).toContain('
) : null} {preview.error ? ( @@ -656,7 +563,11 @@ function RoutePreview({ speedUnit={speedUnit} status={visibleFeedback?.status ?? ''} /> - ) : null} + ) : ( +
+ Select a route to prepare its map and terrain analysis. +
+ )} ); } @@ -692,7 +603,6 @@ export function BikeGpxBrowserDialog({ const deferredQuery = useDeferredValue(query); const routes = catalog?.routes ?? []; const analyses = catalog?.analyses ?? EMPTY_ROUTE_ANALYSES; - const analyzeRoutes = useRouteAnalyzer(analyses, onAnalyzeRoute); const countries = useMemo( () => [...new Set(routes.map((route) => route.country))].sort(), [routes] @@ -722,12 +632,6 @@ export function BikeGpxBrowserDialog({ ); const selectedRoute = filteredRoutes.find((route) => route.id === selectedRouteId); - useEffect(() => { - if (!selectedRoute && filteredRoutes[0]) { - setSelectedRouteId(filteredRoutes[0].id); - } - }, [filteredRoutes, selectedRoute]); - const selectRoute = (route: BikeGpxRouteSummary) => { setSelectedRouteId(route.id); }; @@ -748,16 +652,23 @@ export function BikeGpxBrowserDialog({ >
-

- - Browse BikeGPX routes - -

+
+

+ + Browse BikeGPX routes + +

+ {catalog ? ( + + {filteredRoutes.length.toLocaleString()} routes + + ) : null} +

Search thousands of public routes, preview the complete course, then import it directly into Ride Control. Thanks to BikeGPX for making this @@ -785,7 +696,6 @@ export function BikeGpxBrowserDialog({ difficulty={difficulty} maximumDistance={maximumDistance} minimumDistance={minimumDistance} - onAnalyzeRoutes={analyzeRoutes} onCountryChange={(nextCountry) => { setCountry(nextCountry); setSelectedRouteId(''); diff --git a/src/components/workout-map-dialog.tsx b/src/components/workout-map-dialog.tsx index 1391fd5..967ce11 100644 --- a/src/components/workout-map-dialog.tsx +++ b/src/components/workout-map-dialog.tsx @@ -1,14 +1,17 @@ import 'leaflet/dist/leaflet.css'; import { useCloseOnEscape } from '../hooks/use-dialog-behavior'; -import type { WorkoutCourse } from '../types'; +import { formatDescriptionDistance } from '../lib/units'; +import type { SpeedUnit, WorkoutCourse } from '../types'; import { WorkoutRouteMap } from './workout-route-map'; export function WorkoutMapDialog({ course, onClose, + speedUnit, }: { course: WorkoutCourse; onClose: () => void; + speedUnit: SpeedUnit; }) { useCloseOnEscape(true, onClose); @@ -32,7 +35,11 @@ export function WorkoutMapDialog({ {course.name}

- {course.description} + {formatDescriptionDistance( + course.description, + course.distance, + speedUnit + )}

) : ( - course.description + formatDescriptionDistance( + course.description, + course.distance, + speedUnit + ) )}

@@ -655,6 +663,7 @@ export function WorkoutPanel({ setMappedCourse(undefined)} + speedUnit={speedUnit} /> ) : null} diff --git a/src/lib/bikegpx.ts b/src/lib/bikegpx.ts index ca9f7b8..6829cc3 100644 --- a/src/lib/bikegpx.ts +++ b/src/lib/bikegpx.ts @@ -7,6 +7,7 @@ export const BIKEGPX_ROUTES_URL = 'https://bikegpx.com/bike_routes/'; const SEARCH_WHITESPACE = /\s+/u; const NUMERIC_ROUTE_ID = /^\d+$/; const API_ROOT = (import.meta.env.VITE_RIDECONTROL_API_URL || '/api').replace(/\/$/u, ''); +const ROUTE_QUEUE_STATUS = 'queued'; export interface BikeGpxRouteSummary { country: string; @@ -33,6 +34,12 @@ export interface BikeGpxRouteResult { course: WorkoutCourse; } +interface BikeGpxRouteQueued { + position: number; + retryAfterSeconds: number; + status: typeof ROUTE_QUEUE_STATUS; +} + export function bikeGpxRouteMatchesQuery( route: BikeGpxRouteSummary, query: string, @@ -184,17 +191,66 @@ function restoreBikeGpxRouteResult(value: unknown): BikeGpxRouteResult | undefin return analysis && course ? { analysis, course } : undefined; } -async function apiJson(path: string, signal?: AbortSignal): Promise { +function restoreQueuedRoute(value: unknown): BikeGpxRouteQueued | undefined { + if ( + !( + isRecord(value) && + value.status === ROUTE_QUEUE_STATUS && + isFiniteNumber(value.position) && + value.position >= 1 && + isFiniteNumber(value.retryAfterSeconds) && + value.retryAfterSeconds >= 0 + ) + ) { + return; + } + return { + position: value.position, + retryAfterSeconds: value.retryAfterSeconds, + status: value.status, + }; +} + +async function apiResponse( + path: string, + signal?: AbortSignal +): Promise<{ response: Response; value: unknown }> { const response = await fetch(`${API_ROOT}${path}`, { signal }); const value: unknown = await response.json(); + return { response, value }; +} + +function backendError(value: unknown): Error { + const message = + isRecord(value) && isString(value.error) ? value.error : 'Backend request failed.'; + return new Error(message); +} + +async function apiJson(path: string, signal?: AbortSignal): Promise { + const { response, value } = await apiResponse(path, signal); if (!response.ok) { - const message = - isRecord(value) && isString(value.error) ? value.error : 'Backend request failed.'; - throw new Error(message); + throw backendError(value); } return value; } +function waitForRoute(retryAfterSeconds: number, signal?: AbortSignal): Promise { + if (signal?.aborted) { + return Promise.reject(signal.reason); + } + return new Promise((resolve, reject) => { + const onAbort = () => { + clearTimeout(timeout); + reject(signal?.reason); + }; + const timeout = setTimeout(() => { + signal?.removeEventListener('abort', onAbort); + resolve(); + }, retryAfterSeconds * 1000); + signal?.addEventListener('abort', onAbort, { once: true }); + }); +} + export async function fetchBikeGpxCatalog(signal?: AbortSignal): Promise { const catalog = restoreBikeGpxCatalog(await apiJson('/bikegpx/routes', signal)); if (!catalog) { @@ -207,13 +263,22 @@ export async function fetchBikeGpxRoute( route: BikeGpxRouteSummary, signal?: AbortSignal ): Promise { - const result = restoreBikeGpxRouteResult( - await apiJson(`/bikegpx/routes/${encodeURIComponent(route.id)}`, signal) - ); - if (!result) { - throw new Error('The Ride Control backend returned an invalid BikeGPX route.'); + const path = `/bikegpx/routes/${encodeURIComponent(route.id)}`; + for (;;) { + const { response, value } = await apiResponse(path, signal); + if (!response.ok) { + throw backendError(value); + } + const result = restoreBikeGpxRouteResult(value); + if (result) { + return result; + } + const queued = restoreQueuedRoute(value); + if (!queued) { + throw new Error('The Ride Control backend returned an invalid BikeGPX route.'); + } + await waitForRoute(queued.retryAfterSeconds, signal); } - return result; } export function bikeGpxRouteUrl(routeId: string): string { diff --git a/src/lib/units.ts b/src/lib/units.ts index 359e136..23c1f61 100644 --- a/src/lib/units.ts +++ b/src/lib/units.ts @@ -8,6 +8,7 @@ export const METERS_PER_FOOT = 0.3048; export const KILOMETERS_PER_MILE = 1.609_344; export const KILOMETERS_PER_HOUR_PER_METER_PER_SECOND = 3.6; export const SPEED_UNIT_STORAGE_KEY = 'speed-unit'; +const DESCRIPTION_DISTANCE_SUFFIX = /(?:—|-)\s*\d+(?:[.,]\d+)?\s*(?:km|mi)\s*$/iu; export const SPEED_UNIT_OPTIONS: { label: string; value: SpeedUnit }[] = [ { label: 'KM/H', value: 'kmh' }, @@ -54,6 +55,17 @@ export function formatDistance(kilometers: number, unit: SpeedUnit, decimals = 2 return `${formatDistanceValue(kilometers, unit, decimals)} ${distanceUnitLabel(unit)}`; } +export function formatDescriptionDistance( + description: string, + kilometers: number, + unit: SpeedUnit +): string { + return description.replace( + DESCRIPTION_DISTANCE_SUFFIX, + `— ${formatDistance(kilometers, unit, 0)}` + ); +} + export function formatDistanceProgress( currentKilometers: number, totalKilometers: number, diff --git a/tests/bikegpx.test.ts b/tests/bikegpx.test.ts index 76a952c..5e04212 100644 --- a/tests/bikegpx.test.ts +++ b/tests/bikegpx.test.ts @@ -96,6 +96,24 @@ describe('BikeGPX backend client', () => { expect(fetchMock).toHaveBeenCalledWith('/api/bikegpx/routes/2635', { signal: undefined }); }); + test('waits for an explicitly queued route to finish processing', async () => { + const result = { + analysis: catalog.analyses[route.id], + course, + }; + const fetchMock = mock(async () => + fetchMock.mock.calls.length === 1 + ? Response.json( + { position: 1, retryAfterSeconds: 0, status: 'queued' }, + { status: 202 } + ) + : Response.json(result) + ); + globalThis.fetch = fetchMock as unknown as typeof fetch; + expect(await fetchBikeGpxRoute(route)).toEqual(result); + expect(fetchMock).toHaveBeenCalledTimes(2); + }); + test('surfaces backend errors', async () => { globalThis.fetch = mock(async () => Response.json({ error: 'BikeGPX is unavailable.' }, { status: 502 }) diff --git a/tests/units.test.ts b/tests/units.test.ts index 5951217..904bf7a 100644 --- a/tests/units.test.ts +++ b/tests/units.test.ts @@ -4,6 +4,7 @@ import { convertDistance, convertElevation, convertSpeed, + formatDescriptionDistance, formatDistance, formatDistanceProgress, formatDistanceValue, @@ -31,6 +32,18 @@ describe('unit conversions', () => { expect(formatElevation(304.8, 'kmh')).toBe('305 m'); }); + test('formats a route description distance in the selected dashboard unit', () => { + expect(formatDescriptionDistance('Near Saltvik → Near Finström — 11 km', 11, 'mph')).toBe( + 'Near Saltvik → Near Finström — 7 mi' + ); + expect(formatDescriptionDistance('Near Saltvik → Near Finström — 11 km', 11, 'kmh')).toBe( + 'Near Saltvik → Near Finström — 11 km' + ); + expect(formatDescriptionDistance('Original terrain workout', 11, 'mph')).toBe( + 'Original terrain workout' + ); + }); + test('converts stored SI and ride timing values consistently', () => { expect(metersForKilometers(2.5)).toBe(2500); expect(kilometersForMeters(2500)).toBe(2.5); From 6775bf10bce52d909ee02ab10c5d78167ebb216f Mon Sep 17 00:00:00 2001 From: Ride Control Date: Tue, 21 Jul 2026 14:52:07 -0700 Subject: [PATCH 7/7] Add FIT activity import and export --- README.md | 11 +- bun.lock | 3 + package.json | 1 + src/components/session-detail.tsx | 14 ++ src/components/session-history-list.tsx | 6 +- src/components/session-history.tsx | 35 +++- src/components/welcome-dialog.tsx | 5 +- src/hooks/use-session-history.ts | 25 ++- src/lib/activity-file.ts | 63 +++++++ src/lib/activity-import.ts | 191 +++++++++++++++++++++ src/lib/fit-archive.ts | 59 +++++++ src/lib/fit-import.ts | 191 +++++++++++++++++++++ src/lib/fit.ts | 216 ++++++++++++++++++++++++ src/lib/saved-sessions.ts | 7 +- src/lib/tcx-import.ts | 156 +---------------- src/lib/tcx.ts | 34 +--- tests/components.test.tsx | 16 +- tests/fit-archive.test.ts | 49 ++++++ tests/fit.test.ts | 96 +++++++++++ tests/saved-sessions.test.ts | 1 + tests/tcx-import.test.ts | 43 +++-- 21 files changed, 999 insertions(+), 223 deletions(-) create mode 100644 src/lib/activity-file.ts create mode 100644 src/lib/activity-import.ts create mode 100644 src/lib/fit-archive.ts create mode 100644 src/lib/fit-import.ts create mode 100644 src/lib/fit.ts create mode 100644 tests/fit-archive.test.ts create mode 100644 tests/fit.test.ts diff --git a/README.md b/README.md index 3820e90..ced1e6d 100644 --- a/README.md +++ b/README.md @@ -15,15 +15,15 @@ Bike trainer control web app using Web Bluetooth. Tested with Wahoo KICKR Core 2 - Shows live speed, power, cadence, heart rate, elapsed time, distance, and estimated calories, with MPH and KM/H display modes. - Provides direct resistance control with buttons, a slider, and keyboard shortcuts with matching button feedback, shows smoothing progress inside the slider thumb, and records resistance changes alongside the other ride metrics. - Offers original terrain workouts built as repeatable courses, with gentle, rolling, and climbing options and distinctive winding top-down route shapes. Courses explicitly support loops, point-to-point routes, and out-and-back routes; an out-and-back follows the supplied path to its turnaround, then reverses the same location and elevation data back to the start before repeating. Prairie Roll adds a non-intersecting, curving 15-mile loop of long, gradual rollers centered around 20% resistance and ranging from roughly 15–25%. Granite Switchbacks adds a sustained four-mile ascent whose hairpin corners briefly get steeper before immediately returning to the steady climbing grade, followed by a ridge and a descending sequence of five recovery rollers. Ridgeline Time Trial is a ten-mile out-and-back with a gradual five-mile, roughly 300-foot hillclimb to the turnaround and the identical terrain in reverse on the return. Every course begins flat without giving nearly level routes an unnecessarily long rollout: low-climb courses use about 0.4 km, moderate rollers use about 0.8 km, and climbing-focused courses retain a 1.5 km rollout. The course then automatically adjusts trainer resistance from the current grade, tracks the rider in compact, vertically aligned top-down and elevation views with a clearly labelled ridden-this-lap, ridden-this-trip, or ridden-this-route path and pulsing position markers while pedaling, and uses clear mid-contrast preview lines with a shared elevation scale so gentle rollers remain visibly low beside genuinely mountainous routes. It shows course distance progress to two decimal places alongside course percentage, current grade, and effective trainer resistance directly on the map, with grade and resistance values matching their graph colors, and derives cumulative ride climbing and downhill from course distance so those totals remain aligned with the advertised full-course climb. Elevation appears in feet with MPH or meters with KM/H, and terrain totals and progress are recorded with the session and preserved in saved history and TCX import/export. Currently open in-progress sessions resolve bundled workout IDs to the latest course definition, preventing stale geometry from lingering before a ride is saved; saved history keeps the exact workout snapshot used by that ride. A workout can be selected before riding or planned while viewing a completed session; a newly planned workout immediately replaces the prior course on the dashboard at 0% progress without changing the completed ride's recorded data. It then remains locked from the moment riding begins until that session ends; definition refreshes for that same workout remain allowed without opening a path to switch courses. Workout terrain remains the base load when Zwift Click is paired, allowing virtual gears to scale that resistance without losing the grade-driven course behavior. -- Downloads terrain workouts as standard GPX 1.1 files containing geographic track points and elevation data, with names and descriptions readable by ordinary GPX tools and Ride Control extensions for stable ids, difficulty, baseline resistance, exact workout distance, saved starting location, and point-to-point, loop, or out-and-back course type. Valid GPX tracks or routes from other tools can be imported through the file picker or by dropping a GPX anywhere in the workout tray, then saved into a custom library on the current device; each newly imported workout appears immediately at the top and keeps that position after reloading. A map-first BikeGPX browser is built directly into the terrain tray: it searches more than six thousand public routes by name, place, distance in kilometers or miles, or difficulty; filters by country, minimum and maximum distance in the rider's current units, and terrain-based difficulty; continuously scrolls an efficiently virtualized list; previews the complete GPX over OpenStreetMap; and imports the selected route into Ride Control in one click. Difficulty is calculated from distance, total climbing, climbing density, and maximum grade, with route ratings appearing progressively as routes load. The same route fingerprint used for uploaded files prevents duplicate imports. An imported route's linked “Starts in” description opens an in-app map dialog beside the workout tray, fits its complete path with start and finish markers over an attributed OpenStreetMap base map, and continuously animates a standard bicycle marker along the route. Routes whose start and finish are genuinely near each other become loops automatically; other GPX routes remain one-way, start-to-finish courses without a generated return leg. The workout library filters immediately by course name or displayed difficulty, and every card keeps an up/down-arrow drag handle in the top-right corner; dragging moves the complete workout card strictly vertically, accepts a drop anywhere over another workout, and animates the surrounding cards out of the way to open a full-card-sized insertion space before saving the preferred order across browser reloads. The terrain tray remembers both that it was open and its workout-list scroll position across page reloads. Import, rename, and reorder feedback stays in a fixed bottom status area beside the selected-workout clearing action, preventing the workout list from shifting. Imported workout names can be clicked and renamed without changing the route's stable duplicate-detection identifier. Their top-down geometry is derived from latitude and longitude, terrain resistance is derived from elevation, and a route without its own description uses its first coordinate to label the starting city through a cached OpenStreetMap lookup, then saves that location directly with the workout so restoring or re-importing a Ride Control GPX does not repeat the request. Missing Ride Control metadata receives safe defaults. Stable workout ids—or a route fingerprint for third-party GPX—prevent built-in or previously imported workouts from being uploaded again. Imported entries can be removed, large tracks are sampled for efficient riding, and the geographic source model is ready for a future workout editor. +- Downloads terrain workouts as standard GPX 1.1 files containing geographic track points and elevation data, with names and descriptions readable by ordinary GPX tools and Ride Control extensions for stable ids, difficulty, baseline resistance, exact workout distance, saved starting location, and point-to-point, loop, or out-and-back course type. Valid GPX tracks or routes from other tools can be imported through the file picker or by dropping a GPX anywhere in the workout tray, then saved into a custom library on the current device; each newly imported workout appears immediately at the top and keeps that position after reloading. A map-first BikeGPX browser is built directly into the terrain tray: it searches more than six thousand public routes by name, place, distance in kilometers or miles, or difficulty; filters by country, minimum and maximum distance in the rider's current units, and terrain-based difficulty; continuously scrolls an efficiently virtualized list; previews the complete GPX over OpenStreetMap; and imports the selected route into Ride Control in one click. Routes are prepared only when explicitly selected, then their cached difficulty rating is calculated from distance, total climbing, climbing density, and maximum grade. Route distance badges and descriptions always follow the dashboard's MPH or KM/H selection. The same route fingerprint used for uploaded files prevents duplicate imports. An imported route's linked “Starts in” description opens an in-app map dialog beside the workout tray, fits its complete path with start and finish markers over an attributed OpenStreetMap base map, and continuously animates a standard bicycle marker along the route. Routes whose start and finish are genuinely near each other become loops automatically; other GPX routes remain one-way, start-to-finish courses without a generated return leg. The workout library filters immediately by course name or displayed difficulty, and every card keeps an up/down-arrow drag handle in the top-right corner; dragging moves the complete workout card strictly vertically, accepts a drop anywhere over another workout, and animates the surrounding cards out of the way to open a full-card-sized insertion space before saving the preferred order across browser reloads. The terrain tray remembers both that it was open and its workout-list scroll position across page reloads. Import, rename, and reorder feedback stays in a fixed bottom status area beside the selected-workout clearing action, preventing the workout list from shifting. Imported workout names can be clicked and renamed without changing the route's stable duplicate-detection identifier. Their top-down geometry is derived from latitude and longitude, terrain resistance is derived from elevation, and a route without its own description uses its first coordinate to label the starting city through a cached OpenStreetMap lookup, then saves that location directly with the workout so restoring or re-importing a Ride Control GPX does not repeat the request. Missing Ride Control metadata receives safe defaults. Stable workout ids—or a route fingerprint for third-party GPX—prevent built-in or previously imported workouts from being uploaded again. Imported entries can be removed, large tracks are sampled for efficient riding, and the geographic source model is ready for a future workout editor. - Replaces direct resistance controls with a focused 1–24 virtual shifting interface whenever Zwift Click V2 is paired, including during terrain workouts, and restores the standard resistance control as soon as both controllers are forgotten. Shifting becomes available once the trainer and both controllers are connected, and the Click minus/plus buttons, on-screen controls, and keyboard down/up arrows step through the 24 physical combinations of 39/53-tooth chainrings and a 12-speed 12–24-tooth cassette, sorted by actual drivetrain ratio rather than equal percentage intervals. This gives gear 24 the full 53/12 top end for pushing on descents while retaining 39/24 as gear 1 for climbing. Holding a shift control continues shifting, terrain changes remain smoothly automated underneath the selected gear, and sessions record both the selected gear and applied trainer resistance. - Automatically records while pedaling, auto-pauses during inactivity, supports manual pause and resume, and allows a session to end at any time—even before trainer data arrives. Finishing a ride smoothly returns a connected trainer to 10% resistance; if it is disconnected, 10% is remembered and applied when it reconnects. - Tracks complete time-series data plus averages and maximums for power, cadence, heart rate, speed, resistance, and virtual gear, with large, high-visibility numbers in space-efficient live metric and ride-summary cards, oversized numeric ride totals with subdued unit labels, and focused or combined chart views with subtle separator bands between stacked metrics. Workout grade and elevation are graphed in their own distinct colors, resistance remains visible alongside gear during virtual shifting, and the gear graph stays hidden outside gear mode unless the session contains recorded gear data. The larger chart tabs distribute across the complete chart width. Workout elevation is recorded across the entire ride, so the course profile repeats in the graph for every completed loop. Saved sessions reference immutable, content-addressed workout snapshots in a separate IndexedDB store: identical course definitions share one snapshot, edited definitions retain their historical versions, and deleting a workout from the selectable library cannot break an older session's maps or terrain details. - Lets riders explicitly save a completed session or end it without saving, while keeping start-new and continue-session choices to two clear, context-aware actions; saved sessions use browser-managed IndexedDB storage with optional comments and ride feeling, and persistent browser storage is requested when supported. - Opens saved rides from the dashboard's Sessions button and organizes them by local date and time in a slide-out Sessions tray with a compact inline session count, clear date ranges for rides that span midnight, paginated loading, detailed metrics and charts, keyboard navigation with grouped shortcut help, and permanent deletion. The tray restores the selected session, the session-list scroll position, and each session's independent detail-pane scroll position after a page reload, falling back to the newest available session when a remembered ride no longer exists. -- Downloads saved rides as Strava-compatible TCX files, including timestamps, distance, speed, power, cadence, heart rate, resistance or virtual gear, terrain workout metadata and elevation samples, calories, ride feeling, comments, and a unique Ride Control session identifier for reliable duplicate detection. -- Imports an individual TCX file or every TCX file inside nested folders in a ZIP directly into local session history, preserves compatible ride data and Ride Control session identifiers, detects duplicates by identifier or stable ride data for legacy exports, and continues past individual invalid files in a batch; imported rides permanently retain their import timestamp and a subtle import icon, while only the latest batch remains highlighted until the history tray closes. -- Downloads every locally saved ride at once as a compressed ZIP containing a folder of individual TCX files, with collision-safe filenames when sessions share the same start time. +- Downloads saved rides as standards-compliant FIT activities for direct upload to Strava and other fitness services, including indoor-cycling and creator metadata, UTC and local timestamps, distance, speed, power, cadence, estimated crank revolutions and work, heart rate, resistance, elevation, calories, and ride totals. Each FIT filename includes a stable session token for reliable upload identity. TCX export remains available for the richer Ride Control round trip, including virtual gear, terrain workout metadata, ride feeling, comments, and the original session identifier. +- Imports individual FIT or TCX activities, or every supported activity inside nested folders in a mixed-format ZIP, directly into local session history. Compatible ride data is preserved, duplicates are detected across formats by identifier or stable activity data, and invalid files do not stop the rest of a batch; imported rides permanently retain their import timestamp and a subtle import icon, while only the latest batch remains highlighted until the history tray closes. +- Downloads every locally saved ride at once as a compressed ZIP of individual FIT or TCX files, with FIT selected by default and collision-safe filenames when sessions share the same start time. - Continues any saved session in a new unsaved copy while preserving its recorded time, distance, calories, samples, averages, maximums, and original start time. - Protects recorded active rides with a browser confirmation before refresh or close, and presents the save workflow before starting or continuing another session. - Includes contextual keyboard help for dashboard and history actions, including pausing, ending, starting, navigating, viewing history, and deleting sessions. @@ -67,7 +67,8 @@ target. Virtual gearing applies the ordered ratios of the modeled 2×12 drivetra changes ramp smoothly while button-driven gear changes remain immediate. Recorded grade, resistance, and elevation appear alongside the other session graphs for the full ride, and the course profile repeats on every loop or out-and-back trip while point-to-point routes stop at their finish; route -progress, selected gear, and applied resistance stay portable in saved sessions and TCX files. +progress, selected gear, and applied resistance stay portable in saved sessions and TCX files; +standard ride metrics also stay portable through FIT files. Shared domain utilities own unit conversions, numeric bounds, storage keys, metric presentation, and repeated dialog and keyboard behavior so those rules stay consistent across views and exports. diff --git a/bun.lock b/bun.lock index 10cafc9..776b42f 100644 --- a/bun.lock +++ b/bun.lock @@ -8,6 +8,7 @@ "@dnd-kit/core": "^6.3.1", "@dnd-kit/modifiers": "^9.0.0", "@dnd-kit/sortable": "10.0.0", + "@garmin/fitsdk": "^21.208.0", "@tailwindcss/vite": "^4.3.3", "@tanstack/react-store": "^0.11.0", "@tanstack/react-virtual": "^3.14.7", @@ -158,6 +159,8 @@ "@eslint/plugin-kit": ["@eslint/plugin-kit@0.7.2", "", { "dependencies": { "@eslint/core": "^1.2.1", "levn": "^0.4.1" } }, "sha512-+CNAzxglkrpNf/kKywqQfk74QjtceuOE7Qm+AF8miRvPF/wmmK5+OJOgVh3AVTT3RP2mH3+FOaxlE5v72owk0A=="], + "@garmin/fitsdk": ["@garmin/fitsdk@21.208.0", "", {}, "sha512-mEmPHyzqaS3bb8n+yaOmgmBo/0CUrsLsN5J4viAUN5Kh6+YiwdvPh5OAzb2Jgy2IaI23q7mGtNr/8WRJC1+HoA=="], + "@humanfs/core": ["@humanfs/core@0.19.2", "", { "dependencies": { "@humanfs/types": "^0.15.0" } }, "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA=="], "@humanfs/node": ["@humanfs/node@0.16.8", "", { "dependencies": { "@humanfs/core": "^0.19.2", "@humanfs/types": "^0.15.0", "@humanwhocodes/retry": "^0.4.0" } }, "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ=="], diff --git a/package.json b/package.json index a4aa7ff..2805b57 100644 --- a/package.json +++ b/package.json @@ -18,6 +18,7 @@ "@dnd-kit/core": "^6.3.1", "@dnd-kit/modifiers": "^9.0.0", "@dnd-kit/sortable": "10.0.0", + "@garmin/fitsdk": "^21.208.0", "@tailwindcss/vite": "^4.3.3", "@tanstack/react-store": "^0.11.0", "@tanstack/react-virtual": "^3.14.7", diff --git a/src/components/session-detail.tsx b/src/components/session-detail.tsx index a61d753..ee0a4f6 100644 --- a/src/components/session-detail.tsx +++ b/src/components/session-detail.tsx @@ -2,6 +2,7 @@ import { useEffect, useRef } from 'react'; import { EMPTY_ROUTE } from '../constants'; import { usePersistentScrollPosition } from '../hooks/use-persistent-scroll-position'; import { CONTROL_MODE } from '../lib/control-mode'; +import { downloadSessionFit } from '../lib/fit'; import { aggregateMaximum, formatAggregateAverage, formatWholeNumber } from '../lib/format'; import { resistanceForVirtualGear } from '../lib/gears'; import { METRIC_PRESENTATION, STANDARD_METRIC_KEYS } from '../lib/metric-presentation'; @@ -170,6 +171,19 @@ export function SessionDetail({

{formatSessionTimeRange(session)}

+
) : null} @@ -92,14 +92,14 @@ export function SessionHistoryList({

{imported ? ( ) : null} diff --git a/src/components/session-history.tsx b/src/components/session-history.tsx index 6254309..0b3a76e 100644 --- a/src/components/session-history.tsx +++ b/src/components/session-history.tsx @@ -1,6 +1,11 @@ import type { ReactNode } from 'react'; import { useCallback, useEffect, useRef, useState } from 'react'; import { useSessionHistory } from '../hooks/use-session-history'; +import { + ACTIVITY_FILE_FORMAT, + type ActivityFileFormat, + isActivityFileFormat, +} from '../lib/activity-file'; import { eventTargetsEditableControl, eventTargetsInteractiveControl, @@ -40,12 +45,12 @@ export function SessionHistory({ const { deleteSelectedSession: deleteHistorySession, deleting, - downloadAllTcx, + downloadAllActivityFiles, error, exporting, historyStatus, highlightedSessionIds, - importTcxFile, + importActivityFile, importing, loading, loadMore, @@ -57,6 +62,9 @@ export function SessionHistory({ } = useSessionHistory(open); const [deleteConfirmationOpen, setDeleteConfirmationOpen] = useState(false); const [historyHelpOpen, setHistoryHelpOpen] = useState(false); + const [downloadFormat, setDownloadFormat] = useState( + ACTIVITY_FILE_FORMAT.FIT + ); const importInput = useRef(null); const transferring = exporting || importing; @@ -210,13 +218,13 @@ export function SessionHistory({
{ const file = event.currentTarget.files?.[0]; event.currentTarget.value = ''; if (file) { - importTcxFile(file); + importActivityFile(file); } }} ref={importInput} @@ -228,12 +236,27 @@ export function SessionHistory({ onClick={() => importInput.current?.click()} type="button" > - {importing ? 'Importing…' : 'Import TCX'} + {importing ? 'Importing…' : 'Import FIT/TCX'} +