endurance-coach 0.1.0 → 1.0.0

package/dist/templates/interpolate.js

@@ -0,0 +1,204 @@
+/**
+ * Variable Interpolation Engine
+ *
+ * Replaces ${variable} patterns in template strings with actual values.
+ * Supports:
+ * - Simple variables: ${paces.easy} → "5:30/km"
+ * - Math expressions: ${10 + (reps * 3)} → "22"
+ * - Nested access: ${zones.hr.lthr} → "170"
+ */
+/**
+ * Pattern to match ${...} interpolation markers.
+ */
+const INTERPOLATION_PATTERN = /\$\{([^}]+)\}/g;
+/**
+ * Pattern to detect if a string contains a math expression.
+ */
+const MATH_EXPRESSION_PATTERN = /[+\-*/%()]/;
+/**
+ * Get a nested value from an object using dot notation.
+ *
+ * @example
+ * getNestedValue({ paces: { easy: "5:30" } }, "paces.easy") // "5:30"
+ * getNestedValue({ a: { b: { c: 1 } } }, "a.b.c") // 1
+ */
+function getNestedValue(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current !== "object") {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Evaluate a simple math expression with variable substitution.
+ *
+ * This uses a safe evaluation approach that only allows basic math operations.
+ * Variables in the expression are first replaced with their values from context.
+ *
+ * @example
+ * evaluateExpression("10 + (reps * 3)", { reps: 4 }) // 22
+ */
+export function evaluateExpression(expr, context) {
+    // First, replace any variable references in the expression
+    let substituted = expr;
+    // Find all word tokens that could be variables
+    const variablePattern = /\b([a-zA-Z_][a-zA-Z0-9_.]*)\b/g;
+    let match;
+    while ((match = variablePattern.exec(expr)) !== null) {
+        const varName = match[1];
+        // Skip JavaScript keywords and numbers
+        if (["true", "false", "null", "undefined", "NaN", "Infinity"].includes(varName)) {
+            continue;
+        }
+        // Try to get the value from context
+        const value = getNestedValue(context, varName);
+        if (value !== undefined) {
+            // Convert to appropriate format for the expression
+            let replacement;
+            if (typeof value === "number") {
+                replacement = String(value);
+            }
+            else if (typeof value === "string") {
+                // If it's a string that looks like a number, use it directly
+                const numValue = parseFloat(value);
+                if (!isNaN(numValue)) {
+                    replacement = String(numValue);
+                }
+                else {
+                    // For non-numeric strings, quote them
+                    replacement = `"${value}"`;
+                }
+            }
+            else {
+                replacement = String(value);
+            }
+            // Replace this specific occurrence
+            substituted = substituted.replace(new RegExp(`\\b${varName}\\b`, "g"), replacement);
+        }
+    }
+    // Check if the result looks like a math expression
+    if (MATH_EXPRESSION_PATTERN.test(substituted)) {
+        try {
+            // Safe evaluation using Function constructor
+            // Only allow numbers, operators, and parentheses
+            const sanitized = substituted.replace(/[^0-9+\-*/().%\s]/g, "");
+            if (sanitized.trim() !== substituted.trim()) {
+                // Expression contained invalid characters after substitution
+                return substituted;
+            }
+            // Evaluate the expression
+            const fn = new Function(`return (${sanitized})`);
+            const result = fn();
+            if (typeof result === "number" && !isNaN(result) && isFinite(result)) {
+                // Round to reasonable precision
+                return Math.round(result * 100) / 100;
+            }
+        }
+        catch {
+            // If evaluation fails, return the substituted string
+        }
+    }
+    // Return the substituted string (might be a simple value)
+    return substituted;
+}
+/**
+ * Interpolate all ${variable} patterns in a string.
+ *
+ * @example
+ * interpolate("Run ${duration} min @ ${paces.easy}", {
+ *   duration: 30,
+ *   paces: { easy: "5:30/km" }
+ * })
+ * // "Run 30 min @ 5:30/km"
+ */
+export function interpolate(template, context) {
+    return template.replace(INTERPOLATION_PATTERN, (_, expr) => {
+        const trimmed = expr.trim();
+        // Check if it's a simple variable reference (no math)
+        if (!MATH_EXPRESSION_PATTERN.test(trimmed)) {
+            const value = getNestedValue(context, trimmed);
+            if (value !== undefined && value !== null) {
+                return String(value);
+            }
+            // Return placeholder if variable not found
+            return `\${${trimmed}}`;
+        }
+        // It's an expression - evaluate it
+        const result = evaluateExpression(trimmed, context);
+        return String(result);
+    });
+}
+/**
+ * Interpolate all string values in an object recursively.
+ */
+export function interpolateObject(obj, context) {
+    if (typeof obj === "string") {
+        return interpolate(obj, context);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => interpolateObject(item, context));
+    }
+    if (obj !== null && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = interpolateObject(value, context);
+        }
+        return result;
+    }
+    return obj;
+}
+/**
+ * Create an interpolation context from a compact plan's athlete data.
+ */
+export function createContext(paces, zones, params) {
+    return {
+        paces,
+        zones,
+        ...params,
+    };
+}
+/**
+ * Check if a string contains any interpolation markers.
+ */
+export function hasInterpolation(str) {
+    return INTERPOLATION_PATTERN.test(str);
+}
+/**
+ * Extract all variable names from a template string.
+ *
+ * @example
+ * extractVariables("Run ${duration} min @ ${paces.easy}")
+ * // ["duration", "paces.easy"]
+ */
+export function extractVariables(template) {
+    const variables = [];
+    let match;
+    // Reset the regex
+    const pattern = new RegExp(INTERPOLATION_PATTERN.source, "g");
+    while ((match = pattern.exec(template)) !== null) {
+        const expr = match[1].trim();
+        // For simple variables, add directly
+        if (!MATH_EXPRESSION_PATTERN.test(expr)) {
+            variables.push(expr);
+        }
+        else {
+            // For expressions, extract variable names
+            const varPattern = /\b([a-zA-Z_][a-zA-Z0-9_.]*)\b/g;
+            let varMatch;
+            while ((varMatch = varPattern.exec(expr)) !== null) {
+                const varName = varMatch[1];
+                if (!["true", "false", "null", "undefined", "NaN", "Infinity"].includes(varName)) {
+                    variables.push(varName);
+                }
+            }
+        }
+    }
+    return [...new Set(variables)];
+}

package/dist/templates/loader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Template Loader
+ *
+ * Loads workout templates from YAML files in the templates directory.
+ */
+import { type WorkoutTemplate } from "./template.schema.js";
+import type { TemplateRegistry } from "./template.types.js";
+/**
+ * Load all templates from the templates directory.
+ */
+export declare function loadTemplates(templatesDir?: string): TemplateRegistry;
+/**
+ * Load templates from an array of template objects (for testing or embedded templates).
+ */
+export declare function loadTemplatesFromArray(templateArray: WorkoutTemplate[]): TemplateRegistry;
+/**
+ * Get the path to the templates directory.
+ */
+export declare function getTemplatesPath(): string;

package/dist/templates/loader.js

@@ -0,0 +1,129 @@
+/**
+ * Template Loader
+ *
+ * Loads workout templates from YAML files in the templates directory.
+ */
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
+import { join, dirname, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse as parseYaml } from "./yaml-parser.js";
+import { validateTemplateOrThrow } from "./template.schema.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Default templates directory location.
+ * In development: ./templates relative to project root
+ * In production: bundled with the package
+ */
+function getTemplatesDir() {
+    // Try multiple locations
+    const locations = [
+        join(__dirname, "..", "..", "templates"), // From dist/templates
+        join(__dirname, "..", "templates"), // From src/templates
+        join(process.cwd(), "templates"), // From current working directory
+    ];
+    for (const loc of locations) {
+        if (existsSync(loc)) {
+            return loc;
+        }
+    }
+    throw new Error(`Templates directory not found. Searched: ${locations.join(", ")}`);
+}
+/**
+ * Recursively find all YAML files in a directory.
+ */
+function findYamlFiles(dir) {
+    const files = [];
+    if (!existsSync(dir)) {
+        return files;
+    }
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+            files.push(...findYamlFiles(fullPath));
+        }
+        else if (stat.isFile() && (entry.endsWith(".yaml") || entry.endsWith(".yml"))) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+/**
+ * Load a single template from a YAML file.
+ */
+function loadTemplateFile(filePath) {
+    const content = readFileSync(filePath, "utf-8");
+    const data = parseYaml(content);
+    // Validate against schema
+    return validateTemplateOrThrow(data);
+}
+/**
+ * Load all templates from the templates directory.
+ */
+export function loadTemplates(templatesDir) {
+    const dir = templatesDir ?? getTemplatesDir();
+    const yamlFiles = findYamlFiles(dir);
+    const templates = new Map();
+    for (const file of yamlFiles) {
+        try {
+            const template = loadTemplateFile(file);
+            if (templates.has(template.id)) {
+                console.warn(`Duplicate template ID: ${template.id} in ${file}`);
+            }
+            templates.set(template.id, template);
+        }
+        catch (error) {
+            const fileName = basename(file);
+            if (error instanceof Error) {
+                console.error(`Failed to load template ${fileName}: ${error.message}`);
+            }
+            else {
+                console.error(`Failed to load template ${fileName}: Unknown error`);
+            }
+        }
+    }
+    return createRegistry(templates);
+}
+/**
+ * Load templates from an array of template objects (for testing or embedded templates).
+ */
+export function loadTemplatesFromArray(templateArray) {
+    const templates = new Map();
+    for (const template of templateArray) {
+        const validated = validateTemplateOrThrow(template);
+        templates.set(validated.id, validated);
+    }
+    return createRegistry(templates);
+}
+/**
+ * Create a template registry from a Map of templates.
+ */
+function createRegistry(templates) {
+    return {
+        templates,
+        get(id) {
+            return templates.get(id);
+        },
+        list(sport) {
+            const all = Array.from(templates.values());
+            if (!sport) {
+                return all;
+            }
+            return all.filter((t) => t.sport === sport);
+        },
+        has(id) {
+            return templates.has(id);
+        },
+        ids() {
+            return Array.from(templates.keys());
+        },
+    };
+}
+/**
+ * Get the path to the templates directory.
+ */
+export function getTemplatesPath() {
+    return getTemplatesDir();
+}