endurance-coach 0.1.0

package/dist/viewer/lib/UpdatePlan.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Client-side Plan Update & Regeneration
+ *
+ * This module applies local changes (from localStorage) to the plan JSON
+ * and generates downloadable updated files (JSON + HTML).
+ *
+ * This is the browser equivalent of the CLI `modify` + `render` commands.
+ */
+import type { TrainingPlan, Workout } from "../../schema/training-plan.js";
+export interface PlanChanges {
+    moved: Record<string, string>;
+    edited: Record<string, Partial<Workout>>;
+    deleted: string[];
+    added: Record<string, {
+        date: string;
+        workout: Workout;
+    }>;
+}
+export interface UpdateResult {
+    success: boolean;
+    planFilename?: string;
+    changesSummary?: {
+        deleted: number;
+        edited: number;
+        moved: number;
+        added: number;
+        completed: number;
+    };
+    error?: string;
+}
+/**
+ * Main function: Update plan and generate downloadable JSON
+ *
+ * This applies changes from localStorage and downloads the updated plan JSON.
+ * To get the HTML, use: endurance-coach render updated.json -o updated.html
+ */
+export declare function updatePlanAndRegenerate(plan: TrainingPlan, changes: PlanChanges, completed: Record<string, boolean>): UpdateResult;
+/**
+ * Get changes from localStorage
+ */
+export declare function getChangesFromLocalStorage(planId: string): {
+    changes: PlanChanges;
+    completed: Record<string, boolean>;
+};
+/**
+ * Check if there are any pending changes
+ */
+export declare function hasPendingChanges(planId: string): boolean;

package/dist/viewer/lib/UpdatePlan.js

@@ -0,0 +1,209 @@
+/**
+ * Client-side Plan Update & Regeneration
+ *
+ * This module applies local changes (from localStorage) to the plan JSON
+ * and generates downloadable updated files (JSON + HTML).
+ *
+ * This is the browser equivalent of the CLI `modify` + `render` commands.
+ */
+/**
+ * Apply all local changes to the plan (browser version of modify.ts)
+ */
+function applyLocalChangesToPlan(plan, changes, completed) {
+    // Deep clone to avoid mutating original
+    const modifiedPlan = JSON.parse(JSON.stringify(plan));
+    // Track all workouts by ID for easy lookup
+    const workoutMap = new Map();
+    modifiedPlan.weeks?.forEach((week, weekIdx) => {
+        week.days?.forEach((day, dayIdx) => {
+            day.workouts?.forEach((workout, workoutIdx) => {
+                workoutMap.set(workout.id, { weekIdx, dayIdx, workoutIdx });
+            });
+        });
+    });
+    // 1. Apply deleted workouts
+    changes.deleted.forEach((workoutId) => {
+        const location = workoutMap.get(workoutId);
+        if (location) {
+            const { weekIdx, dayIdx, workoutIdx } = location;
+            modifiedPlan.weeks[weekIdx].days[dayIdx].workouts.splice(workoutIdx, 1);
+        }
+    });
+    // Rebuild workout map after deletions
+    workoutMap.clear();
+    modifiedPlan.weeks?.forEach((week, weekIdx) => {
+        week.days?.forEach((day, dayIdx) => {
+            day.workouts?.forEach((workout, workoutIdx) => {
+                workoutMap.set(workout.id, { weekIdx, dayIdx, workoutIdx });
+            });
+        });
+    });
+    // 2. Apply edits to existing workouts
+    Object.entries(changes.edited).forEach(([workoutId, edits]) => {
+        const location = workoutMap.get(workoutId);
+        if (location) {
+            const { weekIdx, dayIdx, workoutIdx } = location;
+            const workout = modifiedPlan.weeks[weekIdx].days[dayIdx].workouts[workoutIdx];
+            Object.assign(workout, edits);
+        }
+    });
+    // 3. Apply moved workouts
+    Object.entries(changes.moved).forEach(([workoutId, newDate]) => {
+        const location = workoutMap.get(workoutId);
+        if (!location)
+            return;
+        const { weekIdx, dayIdx, workoutIdx } = location;
+        // Remove workout from original location
+        const [workout] = modifiedPlan.weeks[weekIdx].days[dayIdx].workouts.splice(workoutIdx, 1);
+        // Find the target day
+        let targetDay = null;
+        for (const week of modifiedPlan.weeks || []) {
+            for (const day of week.days || []) {
+                if (day.date === newDate) {
+                    targetDay = day;
+                    break;
+                }
+            }
+            if (targetDay)
+                break;
+        }
+        if (targetDay) {
+            if (!targetDay.workouts) {
+                targetDay.workouts = [];
+            }
+            targetDay.workouts.push(workout);
+        }
+    });
+    // 4. Add new workouts
+    Object.entries(changes.added).forEach(([workoutId, { date, workout }]) => {
+        let targetDay = null;
+        for (const week of modifiedPlan.weeks || []) {
+            for (const day of week.days || []) {
+                if (day.date === date) {
+                    targetDay = day;
+                    break;
+                }
+            }
+            if (targetDay)
+                break;
+        }
+        if (targetDay) {
+            if (!targetDay.workouts) {
+                targetDay.workouts = [];
+            }
+            targetDay.workouts.push(workout);
+        }
+    });
+    // 5. Apply completed status
+    modifiedPlan.weeks?.forEach((week) => {
+        week.days?.forEach((day) => {
+            day.workouts?.forEach((workout) => {
+                workout.completed = completed[workout.id] || false;
+            });
+        });
+    });
+    // Update metadata
+    modifiedPlan.meta.updatedAt = new Date().toISOString();
+    return modifiedPlan;
+}
+/**
+ * Download a file to the user's computer
+ */
+function downloadFile(content, filename, mimeType) {
+    const blob = new Blob([content], { type: mimeType });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+}
+/**
+ * Generate a safe filename from the plan
+ */
+function generateFilename(plan, extension) {
+    const safeName = plan.meta.event
+        .replace(/[<>:"/\\|?*]/g, "")
+        .replace(/\s+/g, "-")
+        .toLowerCase()
+        .substring(0, 50);
+    const date = new Date().toISOString().split("T")[0];
+    return `${safeName}-updated-${date}.${extension}`;
+}
+/**
+ * Count total changes
+ */
+function countChanges(changes, completed) {
+    return (changes.deleted.length +
+        Object.keys(changes.edited).length +
+        Object.keys(changes.moved).length +
+        Object.keys(changes.added).length +
+        Object.keys(completed).filter((id) => completed[id]).length);
+}
+/**
+ * Main function: Update plan and generate downloadable JSON
+ *
+ * This applies changes from localStorage and downloads the updated plan JSON.
+ * To get the HTML, use: endurance-coach render updated.json -o updated.html
+ */
+export function updatePlanAndRegenerate(plan, changes, completed) {
+    try {
+        // Check if there are any changes to apply
+        const totalChanges = countChanges(changes, completed);
+        if (totalChanges === 0) {
+            return {
+                success: false,
+                error: "No changes to apply",
+            };
+        }
+        // 1. Apply all changes to the plan
+        const updatedPlan = applyLocalChangesToPlan(plan, changes, completed);
+        // 2. Generate and download new plan JSON
+        const planJson = JSON.stringify(updatedPlan, null, 2);
+        const planFilename = generateFilename(updatedPlan, "json");
+        downloadFile(planJson, planFilename, "application/json");
+        // 3. Calculate summary
+        const completedCount = Object.keys(completed).filter((id) => completed[id]).length;
+        return {
+            success: true,
+            planFilename,
+            changesSummary: {
+                deleted: changes.deleted.length,
+                edited: Object.keys(changes.edited).length,
+                moved: Object.keys(changes.moved).length,
+                added: Object.keys(changes.added).length,
+                completed: completedCount,
+            },
+        };
+    }
+    catch (error) {
+        console.error("Error updating plan:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+/**
+ * Get changes from localStorage
+ */
+export function getChangesFromLocalStorage(planId) {
+    const changesKey = `plan-${planId}-changes`;
+    const completedKey = `plan-${planId}-completed`;
+    const changesJson = localStorage.getItem(changesKey);
+    const completedJson = localStorage.getItem(completedKey);
+    const changes = changesJson
+        ? JSON.parse(changesJson)
+        : { moved: {}, edited: {}, deleted: [], added: {} };
+    const completed = completedJson ? JSON.parse(completedJson) : {};
+    return { changes, completed };
+}
+/**
+ * Check if there are any pending changes
+ */
+export function hasPendingChanges(planId) {
+    const { changes, completed } = getChangesFromLocalStorage(planId);
+    return countChanges(changes, completed) > 0;
+}

package/dist/viewer/lib/export/erg.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ERG/MRC Export
+ *
+ * Generates ERG/MRC workout files for indoor cycling trainers.
+ * Widely supported by TrainerRoad, Zwift, PerfPRO, Golden Cheetah, and others.
+ *
+ * - ERG format: Uses absolute watts
+ * - MRC format: Uses percentage of FTP (more portable)
+ *
+ * We generate MRC format since it scales to each user's FTP.
+ */
+import type { Workout, Sport } from "../../../schema/training-plan.js";
+import type { Settings } from "../../stores/settings.js";
+/**
+ * Check if a sport is supported by ERG/MRC export
+ * Only cycling workouts make sense for trainer files
+ */
+export declare function isErgSupported(sport: Sport): boolean;
+/**
+ * Generate a complete MRC file for a workout
+ */
+export declare function generateMrc(workout: Workout, _settings: Settings): string;
+/**
+ * Generate ERG file (absolute watts) - requires FTP
+ */
+export declare function generateErg(workout: Workout, settings: Settings): string;

package/dist/viewer/lib/export/erg.js

@@ -0,0 +1,208 @@
+/**
+ * ERG/MRC Export
+ *
+ * Generates ERG/MRC workout files for indoor cycling trainers.
+ * Widely supported by TrainerRoad, Zwift, PerfPRO, Golden Cheetah, and others.
+ *
+ * - ERG format: Uses absolute watts
+ * - MRC format: Uses percentage of FTP (more portable)
+ *
+ * We generate MRC format since it scales to each user's FTP.
+ */
+/**
+ * Check if a sport is supported by ERG/MRC export
+ * Only cycling workouts make sense for trainer files
+ */
+export function isErgSupported(sport) {
+    return sport === "bike";
+}
+/**
+ * Convert intensity to percentage of FTP
+ */
+function intensityToPercent(intensity) {
+    // Intensity is stored as percentage (e.g., 75 for 75%)
+    return intensity;
+}
+/**
+ * Generate data points from structured workout
+ * Returns array of [minutes, percent] tuples
+ */
+function generateDataPoints(structure) {
+    const points = [];
+    let currentMinute = 0;
+    const addStep = (step) => {
+        const percent = intensityToPercent(step.intensity?.value ?? 50);
+        const durationMinutes = getDurationMinutes(step);
+        // Add start point
+        points.push([currentMinute, percent]);
+        // For ramps, add intermediate points
+        if (step.intensity?.valueLow !== undefined && step.intensity?.valueHigh !== undefined) {
+            const startPercent = intensityToPercent(step.intensity.valueLow);
+            const endPercent = intensityToPercent(step.intensity.valueHigh);
+            points[points.length - 1] = [currentMinute, startPercent];
+            currentMinute += durationMinutes;
+            points.push([currentMinute, endPercent]);
+        }
+        else {
+            currentMinute += durationMinutes;
+            // Add end point at same intensity (creates flat segment)
+            points.push([currentMinute, percent]);
+        }
+    };
+    const getDurationMinutes = (step) => {
+        const unit = step.duration?.unit ?? "minutes";
+        const value = step.duration?.value ?? 0;
+        switch (unit) {
+            case "seconds":
+                return value / 60;
+            case "minutes":
+                return value;
+            case "hours":
+                return value * 60;
+            default:
+                // For distance-based, estimate ~30km/h average
+                if (unit === "meters") {
+                    return (value / 1000 / 30) * 60;
+                }
+                if (unit === "kilometers") {
+                    return (value / 30) * 60;
+                }
+                return value;
+        }
+    };
+    // Process warmup
+    if (structure.warmup) {
+        for (const step of structure.warmup) {
+            addStep(step);
+        }
+    }
+    // Process main set
+    for (const item of structure.main ?? []) {
+        if ("repeats" in item) {
+            const intervalSet = item;
+            for (let i = 0; i < (intervalSet.repeats ?? 1); i++) {
+                for (const step of intervalSet.steps ?? []) {
+                    addStep(step);
+                }
+            }
+        }
+        else {
+            addStep(item);
+        }
+    }
+    // Process cooldown
+    if (structure.cooldown) {
+        for (const step of structure.cooldown) {
+            addStep(step);
+        }
+    }
+    return points;
+}
+/**
+ * Generate simple data points when no structure is provided
+ */
+function generateSimpleDataPoints(workout) {
+    const totalMinutes = workout.durationMinutes || 60;
+    const points = [];
+    // Determine main intensity based on workout type
+    let mainPercent = 65;
+    switch (workout.type) {
+        case "recovery":
+            mainPercent = 55;
+            break;
+        case "endurance":
+            mainPercent = 65;
+            break;
+        case "tempo":
+            mainPercent = 80;
+            break;
+        case "threshold":
+            mainPercent = 95;
+            break;
+        case "vo2max":
+            mainPercent = 110;
+            break;
+        case "intervals":
+            mainPercent = 85;
+            break;
+    }
+    // Warmup (10% of total, ramp from 40% to 65%)
+    const warmupMinutes = Math.min(15, Math.max(5, Math.round(totalMinutes * 0.1)));
+    points.push([0, 40]);
+    points.push([warmupMinutes, 65]);
+    // Main set
+    const cooldownMinutes = Math.min(10, Math.max(5, Math.round(totalMinutes * 0.1)));
+    const mainMinutes = totalMinutes - warmupMinutes - cooldownMinutes;
+    points.push([warmupMinutes, mainPercent]);
+    points.push([warmupMinutes + mainMinutes, mainPercent]);
+    // Cooldown (ramp from 60% to 40%)
+    points.push([warmupMinutes + mainMinutes, 60]);
+    points.push([totalMinutes, 40]);
+    return points;
+}
+/**
+ * Generate a complete MRC file for a workout
+ */
+export function generateMrc(workout, _settings) {
+    if (!isErgSupported(workout.sport)) {
+        throw new Error(`ERG/MRC export only supports bike workouts`);
+    }
+    const dataPoints = workout.structure
+        ? generateDataPoints(workout.structure)
+        : generateSimpleDataPoints(workout);
+    // Build description from workout info
+    let description = workout.name;
+    if (workout.description) {
+        description += ` - ${workout.description}`;
+    }
+    const lines = [
+        "[COURSE HEADER]",
+        `VERSION = 2`,
+        `UNITS = ENGLISH`,
+        `DESCRIPTION = ${description.replace(/[\r\n]/g, " ")}`,
+        `FILE NAME = ${workout.name}`,
+        `MINUTES PERCENT`,
+        "[END COURSE HEADER]",
+        "[COURSE DATA]",
+    ];
+    // Add data points
+    for (const [minutes, percent] of dataPoints) {
+        lines.push(`${minutes.toFixed(2)}\t${percent.toFixed(0)}`);
+    }
+    lines.push("[END COURSE DATA]");
+    return lines.join("\n");
+}
+/**
+ * Generate ERG file (absolute watts) - requires FTP
+ */
+export function generateErg(workout, settings) {
+    if (!isErgSupported(workout.sport)) {
+        throw new Error(`ERG/MRC export only supports bike workouts`);
+    }
+    const ftp = settings.bike?.ftp || 200; // Default to 200W if not set
+    const dataPoints = workout.structure
+        ? generateDataPoints(workout.structure)
+        : generateSimpleDataPoints(workout);
+    let description = workout.name;
+    if (workout.description) {
+        description += ` - ${workout.description}`;
+    }
+    const lines = [
+        "[COURSE HEADER]",
+        `VERSION = 2`,
+        `UNITS = ENGLISH`,
+        `DESCRIPTION = ${description.replace(/[\r\n]/g, " ")}`,
+        `FILE NAME = ${workout.name}`,
+        `FTP = ${ftp}`,
+        `MINUTES WATTS`,
+        "[END COURSE HEADER]",
+        "[COURSE DATA]",
+    ];
+    // Add data points converted to watts
+    for (const [minutes, percent] of dataPoints) {
+        const watts = Math.round((percent / 100) * ftp);
+        lines.push(`${minutes.toFixed(2)}\t${watts}`);
+    }
+    lines.push("[END COURSE DATA]");
+    return lines.join("\n");
+}

package/dist/viewer/lib/export/fit.d.ts

@@ -0,0 +1,25 @@
+/**
+ * FIT (Garmin) Workout Export
+ *
+ * Generates Garmin FIT workout files that can be uploaded to Garmin Connect.
+ * Uses the official @garmin/fitsdk package for binary FIT encoding.
+ *
+ * How to import to Garmin:
+ * - Upload to Garmin Connect (connect.garmin.com) -> Training -> Workouts -> Import
+ * - The workout will sync to compatible Garmin devices
+ */
+import type { Workout, Sport } from "../../../schema/training-plan.js";
+import type { Settings } from "../../stores/settings.js";
+/**
+ * Check if the FIT SDK is available at runtime
+ * Always returns true since the SDK is now bundled
+ */
+export declare function isFitSdkAvailable(): Promise<boolean>;
+/**
+ * Check if a sport is supported by FIT export
+ */
+export declare function isFitSupported(sport: Sport): boolean;
+/**
+ * Generate a complete FIT workout file
+ */
+export declare function generateFit(workout: Workout, _settings: Settings): Promise<Uint8Array>;