endurance-coach 0.1.0

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

@@ -0,0 +1,308 @@
+/**
+ * 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 { Encoder, Profile } from "@garmin/fitsdk";
+/**
+ * Check if the FIT SDK is available at runtime
+ * Always returns true since the SDK is now bundled
+ */
+export async function isFitSdkAvailable() {
+    return true;
+}
+/**
+ * Check if a sport is supported by FIT export
+ */
+export function isFitSupported(sport) {
+    // FIT supports most sports, excluding rest and race-specific
+    return sport !== "rest" && sport !== "race";
+}
+/**
+ * Map our sport types to FIT sport enum values
+ */
+function getFitSport(sport) {
+    switch (sport) {
+        case "swim":
+            return "swimming";
+        case "bike":
+            return "cycling";
+        case "run":
+            return "running";
+        case "strength":
+            return "training";
+        case "brick":
+            return "multisport";
+        default:
+            return "generic";
+    }
+}
+/**
+ * Map our sport types to FIT sub_sport enum values
+ */
+function getFitSubSport(sport) {
+    switch (sport) {
+        case "swim":
+            return "lap_swimming";
+        case "bike":
+            return "road";
+        case "run":
+            return "road";
+        case "strength":
+            return "strength_training";
+        case "brick":
+            return "triathlon";
+        default:
+            return "generic";
+    }
+}
+/**
+ * Get workout step intensity/duration type based on step type
+ */
+function getStepIntensity(stepType) {
+    switch (stepType) {
+        case "warmup":
+            return "warmup";
+        case "cooldown":
+            return "cooldown";
+        case "rest":
+            return "rest";
+        case "recovery":
+            return "recovery";
+        case "work":
+            return "active";
+        default:
+            return "active";
+    }
+}
+/**
+ * Convert duration to FIT workout step duration
+ */
+function getDurationValue(value, unit) {
+    switch (unit) {
+        case "seconds":
+            return value * 1000; // FIT uses milliseconds
+        case "minutes":
+            return value * 60 * 1000;
+        case "hours":
+            return value * 3600 * 1000;
+        case "meters":
+            return value * 100; // FIT uses centimeters
+        case "kilometers":
+            return value * 100000;
+        case "miles":
+            return value * 160934; // cm per mile
+        default:
+            return value * 1000;
+    }
+}
+/**
+ * Get duration type for FIT
+ */
+function getDurationType(unit) {
+    switch (unit) {
+        case "seconds":
+        case "minutes":
+        case "hours":
+            return "time";
+        case "meters":
+        case "kilometers":
+        case "miles":
+            return "distance";
+        default:
+            return "time";
+    }
+}
+/**
+ * Generate workout steps from structured workout
+ */
+function generateStepsFromStructure(structure) {
+    const steps = [];
+    let stepIndex = 0;
+    // Helper to add a step
+    const addStep = (step, isPartOfRepeat = false) => {
+        const durationType = getDurationType(step.duration?.unit ?? "minutes");
+        const durationValue = getDurationValue(step.duration?.value ?? 0, step.duration?.unit ?? "minutes");
+        const fitStep = {
+            messageIndex: stepIndex,
+            workoutStepName: step.name || "",
+            intensity: getStepIntensity(step.type),
+            durationType: durationType,
+            durationValue: durationValue,
+            notes: step.notes || "",
+        };
+        // Add target based on intensity unit
+        if (step.intensity) {
+            const intensityValue = step.intensity.value ?? 50;
+            switch (step.intensity.unit) {
+                case "percent_ftp":
+                    fitStep.targetType = "power";
+                    fitStep.targetValue = 0;
+                    fitStep.customTargetValueLow = step.intensity.valueLow ?? intensityValue - 5;
+                    fitStep.customTargetValueHigh = step.intensity.valueHigh ?? intensityValue + 5;
+                    break;
+                case "percent_lthr":
+                case "hr_zone":
+                    fitStep.targetType = "heart_rate";
+                    fitStep.targetValue = 0;
+                    // HR zone values need to be actual BPM if available
+                    if (step.intensity.valueLow !== undefined && step.intensity.valueHigh !== undefined) {
+                        fitStep.customTargetValueLow = step.intensity.valueLow;
+                        fitStep.customTargetValueHigh = step.intensity.valueHigh;
+                    }
+                    else {
+                        // Use zone as target value (1-5)
+                        fitStep.targetValue = intensityValue;
+                    }
+                    break;
+                case "rpe":
+                    // No direct RPE support in FIT, use open target
+                    fitStep.targetType = "open";
+                    break;
+                default:
+                    fitStep.targetType = "open";
+            }
+        }
+        else {
+            fitStep.targetType = "open";
+        }
+        // Add cadence target if present
+        if (step.cadence) {
+            fitStep.customTargetCadenceLow = step.cadence.low ?? 80;
+            fitStep.customTargetCadenceHigh = step.cadence.high ?? 100;
+        }
+        steps.push(fitStep);
+        stepIndex++;
+        return stepIndex - 1;
+    };
+    // Helper to add interval set
+    const addIntervalSet = (intervalSet) => {
+        // For FIT, we need to add a repeat step that references the child steps
+        const repeatStepIndex = stepIndex;
+        stepIndex++; // Reserve index for repeat step
+        // Add the child steps
+        const childStepIndices = [];
+        for (const childStep of intervalSet.steps) {
+            childStepIndices.push(addStep(childStep, true));
+        }
+        // Create the repeat step
+        const repeatStep = {
+            messageIndex: repeatStepIndex,
+            workoutStepName: intervalSet.name || "Intervals",
+            durationType: "repeat_until_steps_cmplt",
+            durationValue: intervalSet.repeats,
+            targetType: "open",
+            intensity: "interval",
+        };
+        // Insert repeat step at correct position
+        steps.splice(repeatStepIndex, 0, repeatStep);
+        stepIndex++; // Adjust for inserted repeat step
+    };
+    // 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) {
+            addIntervalSet(item);
+        }
+        else {
+            addStep(item);
+        }
+    }
+    // Process cooldown
+    if (structure.cooldown) {
+        for (const step of structure.cooldown) {
+            addStep(step);
+        }
+    }
+    return { steps, totalSteps: steps.length };
+}
+/**
+ * Generate simple workout steps when no structure is provided
+ */
+function generateSimpleSteps(workout) {
+    const steps = [];
+    const totalMinutes = workout.durationMinutes || 60;
+    // Warmup (10% of total, 5-15 min)
+    const warmupMinutes = Math.min(15, Math.max(5, Math.round(totalMinutes * 0.1)));
+    steps.push({
+        messageIndex: 0,
+        workoutStepName: "Warm Up",
+        intensity: "warmup",
+        durationType: "time",
+        durationValue: warmupMinutes * 60 * 1000,
+        targetType: "open",
+    });
+    // Main (80% of total)
+    const cooldownMinutes = Math.min(10, Math.max(5, Math.round(totalMinutes * 0.1)));
+    const mainMinutes = totalMinutes - warmupMinutes - cooldownMinutes;
+    let mainIntensity = "active";
+    if (workout.type === "recovery")
+        mainIntensity = "recovery";
+    else if (workout.type === "rest")
+        mainIntensity = "rest";
+    else if (workout.type === "intervals" || workout.type === "vo2max")
+        mainIntensity = "interval";
+    steps.push({
+        messageIndex: 1,
+        workoutStepName: "Main Set",
+        intensity: mainIntensity,
+        durationType: "time",
+        durationValue: mainMinutes * 60 * 1000,
+        targetType: "open",
+        notes: workout.description || "",
+    });
+    // Cooldown (10% of total, 5-10 min)
+    steps.push({
+        messageIndex: 2,
+        workoutStepName: "Cool Down",
+        intensity: "cooldown",
+        durationType: "time",
+        durationValue: cooldownMinutes * 60 * 1000,
+        targetType: "open",
+    });
+    return { steps, totalSteps: 3 };
+}
+/**
+ * Generate a complete FIT workout file
+ */
+export async function generateFit(workout, _settings) {
+    if (!isFitSupported(workout.sport)) {
+        throw new Error(`FIT export not supported for ${workout.sport} workouts`);
+    }
+    const encoder = new Encoder();
+    // File ID message (required)
+    encoder.onMesg(Profile.MesgNum.FILE_ID, {
+        type: "workout",
+        manufacturer: "development",
+        product: 1,
+        serialNumber: Math.floor(Math.random() * 1000000),
+        timeCreated: new Date(),
+    });
+    // Generate steps
+    const { steps, totalSteps } = workout.structure
+        ? generateStepsFromStructure(workout.structure)
+        : generateSimpleSteps(workout);
+    // Workout message
+    encoder.onMesg(Profile.MesgNum.WORKOUT, {
+        workoutName: workout.name,
+        sport: getFitSport(workout.sport),
+        subSport: getFitSubSport(workout.sport),
+        numValidSteps: totalSteps,
+    });
+    // Write workout steps
+    for (const step of steps) {
+        encoder.onMesg(Profile.MesgNum.WORKOUT_STEP, step);
+    }
+    // Finalize and return
+    return encoder.close();
+}

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

@@ -0,0 +1,13 @@
+/**
+ * ICS (iCalendar) Export
+ *
+ * Generates iCalendar files (RFC 5545) for importing training plans
+ * into Google Calendar, Apple Calendar, Outlook, etc.
+ *
+ * Each workout becomes an all-day event on its scheduled date.
+ */
+import type { TrainingPlan } from "../../../schema/training-plan.js";
+/**
+ * Generate a complete iCalendar file for the training plan
+ */
+export declare function generateIcs(plan: TrainingPlan): string;

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

@@ -0,0 +1,142 @@
+/**
+ * ICS (iCalendar) Export
+ *
+ * Generates iCalendar files (RFC 5545) for importing training plans
+ * into Google Calendar, Apple Calendar, Outlook, etc.
+ *
+ * Each workout becomes an all-day event on its scheduled date.
+ */
+import { formatDuration, getSportIcon } from "../utils.js";
+/**
+ * Format date as iCalendar DATE value (YYYYMMDD)
+ */
+function formatIcsDate(dateStr) {
+    return dateStr.replace(/-/g, "");
+}
+/**
+ * Escape special characters for iCalendar text fields
+ * According to RFC 5545, we need to escape: backslash, semicolon, comma, newline
+ */
+function escapeIcsText(text) {
+    return text
+        .replace(/\\/g, "\\\\") // Backslash
+        .replace(/;/g, "\\;") // Semicolon
+        .replace(/,/g, "\\,") // Comma
+        .replace(/\n/g, "\\n") // Newline
+        .replace(/\\n/g, "\\n"); // Handle already-escaped newlines from humanReadable
+}
+/**
+ * Fold long lines according to RFC 5545 (max 75 octets per line)
+ */
+function foldLine(line) {
+    const maxLength = 75;
+    if (line.length <= maxLength) {
+        return line;
+    }
+    const result = [];
+    let remaining = line;
+    // First line can be full length
+    result.push(remaining.substring(0, maxLength));
+    remaining = remaining.substring(maxLength);
+    // Continuation lines start with space and have length 74 (75 - 1 for space)
+    while (remaining.length > 0) {
+        result.push(" " + remaining.substring(0, 74));
+        remaining = remaining.substring(74);
+    }
+    return result.join("\r\n");
+}
+/**
+ * Generate a unique identifier for an event
+ */
+function generateUid(workoutId, date) {
+    return `${workoutId}-${date}@endurance-coach`;
+}
+/**
+ * Generate a VEVENT for a workout
+ */
+function generateVevent(workout, day, planName) {
+    const uid = generateUid(workout.id, day.date);
+    const dateStr = formatIcsDate(day.date);
+    const sportEmoji = getSportIcon(workout.sport);
+    const duration = formatDuration(workout.durationMinutes);
+    // Summary: emoji + sport type + workout name
+    const summary = escapeIcsText(`${sportEmoji} ${workout.sport.charAt(0).toUpperCase() + workout.sport.slice(1)}: ${workout.name}`);
+    // Description: include all workout details
+    let description = "";
+    if (workout.description) {
+        description += workout.description + "\\n\\n";
+    }
+    if (duration) {
+        description += `Duration: ${duration}\\n`;
+    }
+    if (workout.primaryZone) {
+        description += `Target Zone: ${workout.primaryZone}\\n`;
+    }
+    if (workout.humanReadable) {
+        description += "\\nWorkout Structure:\\n" + workout.humanReadable.replace(/\\n/g, "\\n");
+    }
+    description = escapeIcsText(description.trim());
+    // Categories for filtering
+    const categories = [workout.sport, workout.type, planName].join(",");
+    const lines = [
+        "BEGIN:VEVENT",
+        foldLine(`UID:${uid}`),
+        `DTSTAMP:${new Date().toISOString().replace(/[-:]/g, "").split(".")[0]}Z`,
+        `DTSTART;VALUE=DATE:${dateStr}`,
+        `DTEND;VALUE=DATE:${dateStr}`, // All-day event
+        foldLine(`SUMMARY:${summary}`),
+        foldLine(`DESCRIPTION:${description}`),
+        foldLine(`CATEGORIES:${escapeIcsText(categories)}`),
+        `TRANSP:TRANSPARENT`, // Don't block time (shows as free)
+        "END:VEVENT",
+    ];
+    return lines.join("\r\n");
+}
+/**
+ * Generate a complete iCalendar file for the training plan
+ */
+export function generateIcs(plan) {
+    const now = new Date().toISOString().replace(/[-:]/g, "").split(".")[0] + "Z";
+    const eventName = plan.meta?.event ?? "Training Plan";
+    const eventDate = plan.meta?.eventDate ?? "";
+    const header = [
+        "BEGIN:VCALENDAR",
+        "VERSION:2.0",
+        "PRODID:-//Endurance Coach//Training Plan//EN",
+        "CALSCALE:GREGORIAN",
+        "METHOD:PUBLISH",
+        `X-WR-CALNAME:${escapeIcsText(eventName)} Training`,
+        `X-WR-CALDESC:${escapeIcsText(`Training plan for ${eventName} on ${eventDate}`)}`,
+    ].join("\r\n");
+    const events = [];
+    // Generate events for all workouts
+    for (const week of plan.weeks ?? []) {
+        for (const day of week.days ?? []) {
+            for (const workout of day.workouts ?? []) {
+                // Skip rest days without actual workouts
+                if (workout.sport === "rest" && !workout.name) {
+                    continue;
+                }
+                events.push(generateVevent(workout, day, eventName));
+            }
+        }
+    }
+    // Add a race day event if we have a date
+    if (eventDate) {
+        const raceDayEvent = [
+            "BEGIN:VEVENT",
+            `UID:race-day@endurance-coach`,
+            `DTSTAMP:${now}`,
+            `DTSTART;VALUE=DATE:${formatIcsDate(eventDate)}`,
+            `DTEND;VALUE=DATE:${formatIcsDate(eventDate)}`,
+            foldLine(`SUMMARY:\u{1F3C6} RACE DAY: ${escapeIcsText(eventName)}`),
+            foldLine(`DESCRIPTION:${escapeIcsText(`Race day for ${eventName}!`)}`),
+            `CATEGORIES:race,${escapeIcsText(eventName)}`,
+            `TRANSP:OPAQUE`, // Block time for race day
+            "END:VEVENT",
+        ].join("\r\n");
+        events.push(raceDayEvent);
+    }
+    const footer = "END:VCALENDAR";
+    return header + "\r\n" + events.join("\r\n") + "\r\n" + footer;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Training Plan Export
+ *
+ * Unified export interface for generating workout files client-side.
+ * Supports:
+ * - ZWO (Zwift workouts) - bike/run only
+ * - FIT (Garmin workouts) - all sports
+ * - MRC (ERG/MRC) - bike only, for indoor trainers
+ * - ICS (iCalendar) - full plan calendar events
+ */
+import type { Workout, TrainingPlan, Sport } from "../../../schema/training-plan.js";
+import type { Settings } from "../../stores/settings.js";
+export type ExportFormat = "zwo" | "fit" | "mrc" | "ics";
+export interface ExportResult {
+    success: boolean;
+    filename: string;
+    error?: string;
+}
+/**
+ * Trigger a file download in the browser
+ */
+export declare function downloadFile(content: string | Uint8Array, filename: string, mimeType: string): void;
+/**
+ * Sanitize filename to be safe across platforms
+ */
+export declare function sanitizeFilename(name: string): string;
+/**
+ * Get available export formats for a workout based on its sport
+ */
+export declare function getAvailableFormats(sport: Sport): ExportFormat[];
+/**
+ * Export a single workout to the specified format
+ */
+export declare function exportWorkout(workout: Workout, format: ExportFormat, settings: Settings): Promise<ExportResult>;
+/**
+ * Export the full training plan to iCalendar format
+ */
+export declare function exportPlanToCalendar(plan: TrainingPlan): ExportResult;
+/**
+ * Export all workouts in the plan to a single ZIP file
+ * Contains ZWO/FIT/MRC files based on the selected format
+ */
+export declare function exportAllWorkouts(plan: TrainingPlan, format: "zwo" | "fit" | "mrc", settings: Settings): Promise<{
+    exported: number;
+    skipped: number;
+    errors: string[];
+}>;
+export { isZwoSupported } from "./zwo.js";
+export { isFitSupported, isFitSdkAvailable } from "./fit.js";
+export { isErgSupported } from "./erg.js";