);
}
// ── RIR Selector ──────────────────────────────────────────────────────────────
// El objetivo del programa está en RIR, así que el registro opcional por serie
// también es RIR (0–5), no RPE. 0 = al fallo · 5 = muy fácil.
function WpRirSelector({ value, onChange }) {
return (
RIR (OPCIONAL) · REPS EN RESERVA
{[0,1,2,3,4,5].map(r => (
))}
);
}
// ── Finish Screen ─────────────────────────────────────────────────────────────
// Returns per-exercise comparison rows against the most recent matching session
function wpBuildComparison(finished) {
const history = WorkoutSessionStore.getHistory(20);
// Skip the just-completed session itself: anything logged at/after this
// workout started is the current session (it may or may not have been
// persisted to the store yet when this renders).
const startTs = finished?.startTime || finished?.dateTs || 0;
const currNames = new Set((finished?.exercises || []).map(e => e.name));
let prev = null;
for (let i = 0; i < history.length; i++) {
const h = history[i];
if ((h.dateTs || 0) >= startTs) continue;
const overlap = (h.exercises || []).filter(e => currNames.has(e.name)).length;
if (overlap >= Math.min(2, Math.floor(currNames.size * 0.4))) { prev = h; break; }
}
if (!prev) return null;
// Build previous-session map. Weighted exercises compare by max kg; isometric
// (time) exercises compare by max seconds held.
const isTimeEx = ex => ex.unit === 'time' || (ex.sets || []).some(s => s.sec != null && s.sec !== '' && !(Number(s.reps) > 0));
const prevMap = {};
(prev.exercises || []).forEach(ex => {
if (isTimeEx(ex)) {
const done = (ex.sets || []).filter(s => s.done && Number(s.sec) > 0);
if (!done.length) return;
prevMap[ex.name] = { time: true, sec: Math.max(...done.map(s => Number(s.sec))), sets: done.length };
} else {
const doneSets = (ex.sets || []).filter(s => s.done && Number(s.kg) > 0);
if (!doneSets.length) return;
prevMap[ex.name] = {
kg: Math.max(...doneSets.map(s => Number(s.kg))),
reps: Math.round(doneSets.reduce((a, s) => a + Number(s.reps || 0), 0) / doneSets.length),
sets: doneSets.length,
};
}
});
const rows = (finished?.exercises || []).map(ex => {
const p = prevMap[ex.name];
if (isTimeEx(ex)) {
const done = (ex.sets || []).filter(s => s.done && Number(s.sec) > 0);
if (!done.length) return null;
const currSec = Math.max(...done.map(s => Number(s.sec)));
const delta = (p && p.time) ? +(currSec - p.sec).toFixed(0) : null;
return { name: ex.name, time: true, currSec, currSets: done.length, prevSec: p?.time ? p.sec : null, delta };
}
const doneSets = (ex.sets || []).filter(s => s.done && Number(s.kg) > 0);
if (!doneSets.length) return null;
const currKg = Math.max(...doneSets.map(s => Number(s.kg)));
const currReps = Math.round(doneSets.reduce((a, s) => a + Number(s.reps || 0), 0) / doneSets.length);
const delta = (p && !p.time) ? +(currKg - p.kg).toFixed(1) : null;
return { name: ex.name, currKg, currReps, currSets: doneSets.length, prevKg: p?.time ? null : p?.kg, prevReps: p?.reps, delta };
}).filter(Boolean);
return rows.length ? { rows, prevDate: prev.date, prevDateTs: prev.dateTs || Date.parse(prev.date) || 0 } : null;
}
// Fecha corta en español, como en el resto de la app: "mar, 10 nov".
function wpFmtShortDate(ts, fallback) {
try {
const d = new Date(ts || fallback);
if (isNaN(d.getTime())) return fallback || '';
return d.toLocaleDateString('es-ES', { weekday: 'short', day: 'numeric', month: 'short' }).replace('.', '');
} catch { return fallback || ''; }
}
// Gemas de récord realmente acreditadas esta sesión (misma lógica que la store:
// computeSessionPRBonus sobre el historial anterior). Permite integrar el
// "+N por récord" en la tarjeta del récord y no contradecir el aviso "Sin gemas".
function wpRecordGems(finished) {
if (typeof computeSessionPRBonus !== 'function') return 0;
let history = [];
try { history = WorkoutSessionStore.getHistory(100); } catch (e) { return 0; }
const startTs = finished?.startTime || finished?.dateTs || 0;
const prior = history.filter(h => (h.dateTs || 0) < startTs);
const current = history.find(h => (h.dateTs || 0) >= startTs);
const exercises = current ? current.exercises : (finished?.exercises || []);
try { return computeSessionPRBonus(prior, exercises) || 0; } catch (e) { return 0; }
}
// Nuevos récords de peso de la sesión (competimos con uno mismo, nunca con otros).
// La primera vez que se registra un ejercicio no cuenta como récord.
function wpSessionRecords(finished) {
let history = [];
try { history = WorkoutSessionStore.getHistory(100); } catch (e) { return []; }
const startTs = finished?.startTime || finished?.dateTs || 0;
const prior = history.filter(h => (h.dateTs || 0) < startTs);
const bestPrior = {};
for (const h of prior) for (const ex of (h.exercises || [])) {
if (!ex.name) continue;
const sets = (ex.sets || []).filter(s => Number(s.kg) > 0 && Number(s.reps) > 0);
if (!sets.length) continue;
const kg = Math.max(...sets.map(s => Number(s.kg)));
const b = bestPrior[ex.name] || { kg: 0 };
bestPrior[ex.name] = { kg: Math.max(b.kg, kg) };
}
const fmtKg = v => (v % 1 === 0 ? String(v) : String(Math.round(v * 10) / 10).replace('.', ','));
const records = [];
for (const ex of (finished?.exercises || [])) {
const done = (ex.sets || []).filter(s => s.done && Number(s.kg) > 0 && Number(s.reps) > 0);
if (!done.length) continue;
const prev = bestPrior[ex.name];
if (!prev) continue; // primera vez → no es récord
const top = done.slice().sort((a, b) => (Number(b.kg) - Number(a.kg)) || (Number(b.reps) - Number(a.reps)))[0];
const kg = Number(top.kg), reps = Number(top.reps);
if (kg > prev.kg + 0.01) records.push({ name: ex.name, text: `${fmtKg(kg)} kg × ${reps}` });
}
return records;
}
// Aviso suave de rendimiento a la baja (≥3 ejercicios peor en la última sesión),
// mostrado como mucho una vez por semana. Nunca lenguaje médico ni diagnósticos.
function wpPerfDropNotice() {
try {
if (typeof progPerformanceDrop !== 'function') return false;
const log = WorkoutSessionStore.getHistory(60);
const drop = progPerformanceDrop(log);
if (drop.count < 3) return false;
const now = new Date();
const wk = `${now.getFullYear()}-W${Math.ceil(((now - new Date(now.getFullYear(), 0, 1)) / 86400000 + now.getDay() + 1) / 7)}`;
const KEY = 'atlas.perfdrop.week.v1';
if (localStorage.getItem(KEY) === wk) return false;
localStorage.setItem(KEY, wk);
return true;
} catch (e) { return false; }
}
function WpFinishScreen({ finished, onHome, onCoach, onOpenArticle, addOffer, onAddToRoutine, onDismissOffer }) {
const dur = finished?.duration || 0;
const partial = !!finished?.partial;
// "Músculos trabajados": solo los de ejercicios con alguna serie completada.
const muscles = [...new Set(
(finished?.exercises || [])
.filter(ex => (ex.sets || []).some(s => s.done))
.flatMap(ex => ex.muscles?.primary || [])
)].slice(0, 6);
const comparison = React.useMemo(() => wpBuildComparison(finished), [finished]);
const records = React.useMemo(() => wpSessionRecords(finished), [finished]);
const recordGems = React.useMemo(() => wpRecordGems(finished), [finished]);
const perfDrop = React.useMemo(() => wpPerfDropNotice(), [finished]);
return (
{/* Session reward — effort-tiered, capped to one per day */}
{(() => {
const earned = finished?.gemsAwarded || 0;
const tier = finished?.gemsTier || 0;
let label, sub;
if (earned > 0) {
label = `+${earned} 💎`;
sub = tier >= 20 ? 'Sesión completa' : 'Sesión parcial';
} else if (recordGems > 0) {
// No hay gemas por % de series, pero sí por récord: no mostramos el
// pill de "Sin gemas" (lo integra la tarjeta del récord, abajo).
return null;
} else if (finished?.rewardCapped) {
label = 'Sin gemas';
sub = 'Ya ganaste tu recompensa de hoy';
} else {
label = 'Sin gemas';
sub = 'Completa al menos el 30% de las series';
}
const pos = earned > 0;
return (
{label}{sub}
);
})()}
{/* Muscles */}
{muscles.length > 0 && (
MÚSCULOS TRABAJADOS
{muscles.map(m => (
{m}
))}
)}
{/* Aviso suave de rendimiento a la baja (máx. 1/semana) */}
{perfDrop && (
Tu rendimiento ha bajado estos días. Puede ser fatiga, sueño o estrés. Si se repite, valora una semana de descarga.
)}
{/* Nuevos récords de la sesión */}
{records.length > 0 && (
{addOffer.kind === 'newRoutine'
? <>Series o ejercicios distintos de {addOffer.routineName} (una predeterminada, no se edita) · ¿guardarla como rutina tuya?
: <>Series o ejercicios distintos de la plantilla · ¿guardar estos cambios en {addOffer.routineName}?}
) : (
<>
Añadiste {addOffer.names.length === 1 ? 'un ejercicio' : `${addOffer.names.length} ejercicios`} sobre la marcha
{addOffer.names.slice(0,3).join(', ')}{addOffer.names.length>3?'…':''} · ¿guardarlo también en {addOffer.routineName} para la próxima?
)}
)}
{/* CTAs */}
);
}
// ── History Screen ────────────────────────────────────────────────────────────
function WpHistoryScreen({ onNewWorkout }) {
const history = React.useMemo(() => WorkoutSessionStore.getHistory(20), []);
return (
Historial
Entrenamientos completados
{history.length === 0 ? (
🏋️
No hay entrenamientos completados todavía
Genera una rutina en el Coach y empieza a entrenar
);
}
// ── Active View ───────────────────────────────────────────────────────────────
// Exercise demonstration image for the active workout. Uses ExerciseMedia.Thumbnail
// so exercises WITH a free-exercise-db photo get the animated crossfade, and those
// WITHOUT one (or whose photo fails to load) get the elegant navy silhouette
// placeholder — never an empty gap or a broken image.
function wpImgGroup(ex) {
const p = ((ex?.muscles?.primary?.[0]) || ex?.group || '').toLowerCase();
if (/pec|pecho/.test(p)) return 'pecho';
if (/dorsal|espalda|trapecio|romboid|lumbar|erector/.test(p)) return 'espalda';
if (/delto|hombro/.test(p)) return 'hombro';
if (/b[íi]cep|braquial/.test(p)) return 'biceps';
if (/tr[íi]cep/.test(p)) return 'triceps';
if (/cu[áa]dri|isqui|gl[úu]te|femoral|pierna|gemelo|aductor|abductor|pantorr|soleo/.test(p)) return 'pierna';
return 'core';
}
function WpExerciseImage({ id, name }) {
if (typeof ExerciseMedia === 'undefined') return null;
// Enrich from the DB (muscles/compound) so the placeholder silhouette matches.
const info = (typeof ExerciseService !== 'undefined' && ExerciseService.getById)
? ExerciseService.getById(id) : null;
const ex = { id, name, muscles: info?.muscles, compound: info?.compound };
return (
);
}
// A tappable substitute option in the swap sheet (comfortable 44px+ target)
function WpSwapOption({ ex, onPick }) {
const patternMeta = (ExerciseService.META?.PATTERN_META || {})[ex.pattern];
const primary = ex.muscles?.primary?.[0] || '';
const equip = ex.equipment ? ex.equipment[0].toUpperCase() + ex.equipment.slice(1) : '';
return (
);
}
// Small thumbnail for swap options (mirrors WpExerciseImage but compact).
// No image / load error → la ilustración del GRUPO muscular (igual que en las
// tarjetas), no un círculo vacío que parezca una imagen cargando.
function WpExThumb({ id, name }) {
const [ok, setOk] = React.useState(true);
const url = (typeof ExerciseImages !== 'undefined') ? ExerciseImages.urlFor(id) : null;
if (!url || !ok) {
let ex = null; try { ex = (typeof ExerciseService !== 'undefined') ? ExerciseService.getById(id) : null; } catch (e) {}
const group = (typeof wpImgGroup === 'function') ? wpImgGroup(ex || { id }) : 'core';
const SvgComp = (typeof ExerciseMedia !== 'undefined' && ExerciseMedia.SVGS) ? ExerciseMedia.SVGS[group] : null;
return (
);
}
// ── Time field (isometric / duration-based sets) ───────────────────────────────
// Records DURATION in seconds instead of reps: a live stopwatch plus a manual
// seconds input. The value lives in the set (`sec`) so it persists exactly like
// kg/reps and survives reload; the stopwatch just writes into it.
function WpTimeField({ set, target, onChange, isMobile, disabled }) {
const [running, setRunning] = React.useState(false);
const tickRef = React.useRef(null);
const baseRef = React.useRef(0); // sec value when the stopwatch started
const startRef = React.useRef(0); // Date.now() at start
const lastRef = React.useRef(-1); // last whole-second emitted (throttle writes)
function stop() {
if (tickRef.current) { clearInterval(tickRef.current); tickRef.current = null; }
setRunning(false);
}
React.useEffect(() => () => { if (tickRef.current) clearInterval(tickRef.current); }, []);
// If the set is completed elsewhere while the clock runs, stop it.
React.useEffect(() => { if (disabled && tickRef.current) stop(); }, [disabled]);
function start() {
baseRef.current = parseInt(set?.sec) || 0;
startRef.current = Date.now();
lastRef.current = -1;
setRunning(true);
// Timestamp-based so backgrounding doesn't drift; only write on second change.
tickRef.current = setInterval(() => {
const elapsed = Math.round((Date.now() - startRef.current) / 1000);
const total = baseRef.current + elapsed;
if (total !== lastRef.current) { lastRef.current = total; onChange(String(total)); }
}, 300);
}
function toggle() { running ? stop() : start(); }
function reset() { stop(); onChange(''); }
const secVal = set?.sec || '';
const btnBase = { minHeight: isMobile ? 50 : 42, borderRadius:10, cursor: disabled ? 'default' : 'pointer', fontFamily:'Inter,system-ui', fontWeight:800, border:'none', transition:'background 150ms ease, color 150ms ease, border-color 150ms ease' };
return (
DURACIÓN (SEG)
{target &&
OBJETIVO {target}
}
{/* Seconds value on its own row (full width) */}
onChange(e.target.value)} placeholder="0"
style={{ width:'100%', boxSizing:'border-box', padding: isMobile ? '13px 12px' : '10px 12px', minHeight: isMobile ? 50 : undefined, borderRadius:10, border:`1px solid ${running ? 'rgba(34,197,94,0.5)' : WP.border}`, background:WP.input, color: running ? WP.green : WP.text, fontFamily:'ui-monospace,Menlo,monospace', fontSize: isMobile ? 22 : 20, fontWeight:800, textAlign:'center' }} />
{/* Stopwatch controls below, so they never crowd the value on narrow screens */}
);
}
// ── Drop sets (optional advanced technique) ────────────────────────────────────
// A drop set = the main set + one or more "drops" (less weight, no rest). Opt-in
// per set, so it never gets in the way of standard logging. Sub-tramos are stored
// on the set as `drops: [{kg, reps}]`.
function WpDropSets({ set, onChange, isMobile, disabled }) {
const drops = set?.drops || [];
const add = () => onChange([...(set?.drops || []), { kg: '', reps: '' }]);
const upd = (i, patch) => onChange(drops.map((d, di) => di === i ? { ...d, ...patch } : d));
const del = (i) => { const next = drops.filter((_, di) => di !== i); onChange(next.length ? next : undefined); };
// Mismo input que la serie normal: ancho suficiente para "102,5"/"15", números
// tabulares y coma decimal. minWidth:0 deja que la rejilla reparta, pero el
// contenido no se corta porque la columna nunca baja de su mínimo legible.
// Fuente/padding ajustados para que "102,5" quepa incluso a 320 px (el botón de
// borrar mantiene 44 px de objetivo táctil, así que el ancho se gana en el input).
const numSty = { width:'100%', minWidth:0, boxSizing:'border-box', padding: isMobile ? '11px 6px' : '9px 10px', minHeight: isMobile ? 44 : 38, borderRadius:9, border:`1px solid ${WP.border}`, background:WP.input, color:WP.text, fontFamily:'ui-monospace,Menlo,monospace', fontSize: isMobile ? 15 : 15, fontWeight:800, textAlign:'center', fontVariantNumeric:'tabular-nums' };
const colLab = t => (
,
document.body
);
}
function WpActiveView({ session, log, onOpenArticle, exIdx, setIdx, elapsed, restTimer, restFlash, onCompleteSet, onUpdateSet, onUpdateSide, onSelectSet, onNavigateEx, onFinish, onExitPause, onExitSave, onExitDiscard, onRestAdjust, onRestSkip, onSwap, onAddExercise, swapRoutineName, onAddSet, onRemoveLastSet, undoSet, onUndoRemove, onDismissUndo, confirmSet, onConfirmRemove, onCancelConfirm }) {
const isMobile = useIsMobile();
const TABBAR = 'calc(56px + env(safe-area-inset-bottom))';
// Exit dialog state
const [exitOpen, setExitOpen] = React.useState(false);
const [confirmDiscard, setConfirmDiscard] = React.useState(false);
const [confirmFinish, setConfirmFinish] = React.useState(false);
const doneCount = session.exercises.reduce((t, e) => t + e.sets.filter(s => s.done).length, 0);
const totalCount = session.exercises.reduce((t, e) => t + e.sets.length, 0);
// Terminar con menos de la mitad de las series → pedir confirmación.
function handleFinishClick() {
if (totalCount > 0 && doneCount < totalCount / 2) setConfirmFinish(true);
else onFinish();
}
function handleSalir() {
// Nothing logged yet → nothing to lose, exit straight away (discard).
if (doneCount === 0) { onExitDiscard(); return; }
setConfirmDiscard(false);
setExitOpen(true);
}
// Exercise picker sheet — one selector reused for two modes:
// 'swap' → replace the current exercise
// 'add' → add an extra exercise to today's session
const [sheetMode, setSheetMode] = React.useState(null); // null | 'swap' | 'add'
const [histOpen, setHistOpen] = React.useState(false); // "Ver historial" del ejercicio actual
const [sheetQuery, setSheetQuery] = React.useState('');
const [applyToRoutine, setApplyToRoutine] = React.useState(false);
const sheetEx = sheetMode ? session.exercises[exIdx] : null; // seeds smart suggestions
const alternatives = React.useMemo(
() => (sheetEx ? ExerciseService.alternativesFor(sheetEx, 12) : []),
[sheetEx?.id, exIdx, sheetMode]
);
const searchResults = React.useMemo(() => {
const q = sheetQuery.trim();
if (q.length < 2) return [];
const altIds = new Set(alternatives.map(a => a.id));
return ExerciseService.getAll({ query: q })
.filter(e => (sheetMode === 'add' || e.id !== sheetEx?.id) && !altIds.has(e.id))
.slice(0, 20);
}, [sheetQuery, alternatives, sheetEx?.id, sheetMode]);
function openSwap() { setSheetQuery(''); setApplyToRoutine(false); setSheetMode('swap'); }
function openAdd() { setSheetQuery(''); setSheetMode('add'); }
function closeSheet() { setSheetMode(null); setSheetQuery(''); }
function pickExercise(dbEx) {
if (sheetMode === 'add') onAddExercise(dbEx);
else onSwap(dbEx, applyToRoutine);
closeSheet();
}
// Immersive training: hide the app's mobile top header during the active view
React.useEffect(() => {
document.body.classList.add('atlas-training');
return () => document.body.classList.remove('atlas-training');
}, []);
const ex = session.exercises[exIdx];
if (!ex) return null;
const set = ex.sets[setIdx];
const isTime = ex.unit === 'time';
const isUni = !isTime && ex.unilateral === true;
const totalExs = session.exercises.length;
const doneSets = session.exercises.reduce((t, e) => t + e.sets.filter(s => s.done).length, 0);
const totalSets = session.exercises.reduce((t, e) => t + e.sets.length, 0);
const pct = totalSets > 0 ? Math.round((doneSets / totalSets) * 100) : 0;
// Look up cues from ExerciseService
const cues = React.useMemo(() => {
try {
const info = ExerciseService.getById(ex.id);
return (info?.cues || []).slice(0, 3);
} catch { return []; }
}, [ex.id]);
return (
Entrenamiento en curso{session?.sessionName ? ` — ${session.sessionName}` : ''}
{/* Rest-finished visual flash — the silent-mode fallback (no external assets) */}
{restFlash && (
¡Siguiente serie!
)}
{/* Fixed header — training hides the app's mobile header (which carried the
safe-area inset), so pad the top here or the notch/Dynamic Island covers
"← Salir". The dark bg fills the inset zone too (no transparent strip). */}
{/* Top bar — "← Salir" y el cronómetro no se parten; el nombre largo del
ejercicio es quien se trunca (antes a 320 px "Salir" caía a dos líneas). */}
{ex.name}
{wpFmtTime(elapsed)}
{/* Progress info */}
Ej {exIdx + 1} de {totalExs} · {doneSets}/{totalSets} series
{pct}%
{/* Rest timer banner */}
{/* Scrollable content — clears the fixed mobile tab bar */}
{/* Exercise card — keyed by exercise id so it fades in when the active
exercise changes (navigation, auto-advance, swap). */}
{/* Set status grid + añadir/quitar serie (solo esta sesión) */}
SERIES · {ex.sets.filter(s => s.done).length}/{ex.sets.length}
onSelectSet(exIdx, i)} />
{/* Exercise navigation */}
{/* Add an extra exercise mid-session (today only) — reuses the picker. */}
{/* Confirmación al terminar con menos de la mitad de las series hechas */}
{confirmFinish && typeof ReactDOM !== 'undefined' && ReactDOM.createPortal(
Has completado {doneCount} de {totalCount} {totalCount === 1 ? 'serie' : 'series'}. ¿Terminar igualmente?
,
document.body
)}
{/* Confirmación al quitar una serie YA COMPLETADA (no por toque accidental) */}
{confirmSet && typeof ReactDOM !== 'undefined' && ReactDOM.createPortal(
Llevas {doneCount} {doneCount === 1 ? 'serie' : 'series'} registrada{doneCount === 1 ? '' : 's'}. Elige qué hacer con tu progreso.
{!confirmDiscard ? (
<>
) : (
<>
Descartar y perder el progreso
Se eliminará la sesión activa y las {doneCount} {doneCount === 1 ? 'serie' : 'series'} registrada{doneCount === 1 ? '' : 's'}. Esto no se puede deshacer.
)}
,
document.body
)}
);
}
// ── Main Component ────────────────────────────────────────────────────────────
function WorkoutPlayerSection() {
const { state, actions } = useStore();
const { navigate } = useRoute();
const [session, setSession] = React.useState(null);
const [exIdx, setExIdx] = React.useState(0);
const [setIdx, setSetIdx] = React.useState(0);
const [elapsed, setElapsed] = React.useState(0);
const [view, setView] = React.useState('loading');
const [finished, setFinished] = React.useState(null);
const [restFlash, setRestFlash] = React.useState(false);
// Offer at finish: save mid-session-added exercises to the saved routine.
const [addOffer, setAddOffer] = React.useState(null);
// Quitar serie: "Deshacer" durante unos segundos tras quitar una pendiente,
// y confirmación si la serie estaba completada.
const [undoSet, setUndoSet] = React.useState(null); // { ei, si, set }
const [confirmSet, setConfirmSet] = React.useState(null); // { ei, si }
const undoTimerRef = React.useRef(null);
// The session's start timestamp (Date.now()). Elapsed is ALWAYS derived from
// this (Date.now() - startTime), never accumulated per tick — so it stays
// accurate through backgrounding, lock and reload (the browser freezes
// setInterval in the background, which would otherwise lose time).
const startTimeRef = React.useRef(0);
const elapsedIntRef = React.useRef(null);
const flashTimerRef = React.useRef(null);
const keepAwakePref = state.prefs?.keepAwake !== false;
// Rest-end alert mode ('sound' | 'vibration' | 'none') lives in AtlasSettings
// (atlas.settings.v1). Kept reactive so changes in Ajustes apply immediately.
const [restAlert, setRestAlert] = React.useState(
() => (typeof AtlasSettings !== 'undefined' ? AtlasSettings.get('restAlert') : 'sound')
);
React.useEffect(() => {
const sync = () => { try { setRestAlert(AtlasSettings.get('restAlert')); } catch {} };
window.addEventListener('atlas:settingschange', sync);
return () => window.removeEventListener('atlas:settingschange', sync);
}, []);
function triggerRestFlash() {
setRestFlash(true);
if (flashTimerRef.current) clearTimeout(flashTimerRef.current);
flashTimerRef.current = setTimeout(() => setRestFlash(false), 1100);
}
// Timestamp-based rest timer (survives backgrounding + reload). Persisted so
// an active rest resumes after an accidental reload / app-close.
const { restTimer, start: startRest, adjust: adjustRest, skip: skipRest } =
useRestTimer(restAlert, { persist: true, onDone: triggerRestFlash });
// ── Mount: load or create session ─────────────────────────────────────────
React.useEffect(() => {
const rawExs = (() => { try { return JSON.parse(localStorage.getItem('atlas.pendingWorkout') || 'null'); } catch { return null; } })();
const rawMeta = (() => { try { return JSON.parse(localStorage.getItem('atlas.pendingWorkoutMeta') || 'null'); } catch { return null; } })();
if (rawExs && Array.isArray(rawExs) && rawExs.length > 0) {
// Clear pending keys
localStorage.removeItem('atlas.pendingWorkout');
localStorage.removeItem('atlas.pendingWorkoutMeta');
const s = WorkoutSessionStore.create(rawExs, rawMeta);
// Precarga cada serie con la sugerencia de progresión (o el peso de la
// última vez). Solo en sesiones nuevas; persiste para sobrevivir recargas.
try { wpPrefillSuggestions(s, state.log); WorkoutSessionStore.save(s); } catch (e) {}
setSession(s);
startTimeRef.current = s.startTime || Date.now();
setElapsed(0);
setExIdx(0);
setSetIdx(0);
setView('active');
} else {
const active = WorkoutSessionStore.getActive();
if (active) {
setSession(active);
// Duration is derived from the PERSISTED start timestamp, not from zero —
// so resuming mid-session (reload / app-close) shows the real elapsed time.
startTimeRef.current = active.startTime || Date.now();
setElapsed(Math.max(0, Math.round((Date.now() - startTimeRef.current) / 1000)));
// Find first incomplete ex+set
let foundEx = 0, foundSet = 0;
outer: for (let ei = 0; ei < active.exercises.length; ei++) {
for (let si = 0; si < active.exercises[ei].sets.length; si++) {
if (!active.exercises[ei].sets[si].done) { foundEx = ei; foundSet = si; break outer; }
}
}
setExIdx(foundEx);
setSetIdx(foundSet);
setView('active');
} else {
setView('history');
}
}
}, []);
// ── Elapsed timer ──────────────────────────────────────────────────────────
// The interval only REPAINTS; the value is recomputed from the start timestamp
// each tick, so a frozen background tab never loses time. On returning to the
// foreground we recompute immediately (visibilitychange) instead of waiting for
// the next tick, so the jump to the real elapsed time is instant.
React.useEffect(() => {
if (view !== 'active') return;
const tick = () => {
const st = startTimeRef.current || Date.now();
setElapsed(Math.max(0, Math.round((Date.now() - st) / 1000)));
};
tick();
elapsedIntRef.current = setInterval(tick, 1000);
const onVisible = () => { if (document.visibilityState === 'visible') tick(); };
document.addEventListener('visibilitychange', onVisible);
return () => {
clearInterval(elapsedIntRef.current);
document.removeEventListener('visibilitychange', onVisible);
};
}, [view]);
// Rest timer: warning/done sounds, background-freeze recovery and persistence
// are all handled inside useRestTimer (timestamp-based). The helpers below just
// translate the rest string / actions.
function startRestTimer(restStr) {
// Parse rest string like '90s', '2 min', '90-120s' → pick first number
const match = (restStr || '90s').match(/(\d+)/);
const secs = match ? parseInt(match[1]) : 90;
startRest(secs);
}
function handleRestAdjust(delta) { adjustRest(delta); }
function handleRestSkip() { skipRest(); }
// ── Keep-awake + audio unlock during training ──────────────────────────────
React.useEffect(() => {
if (view !== 'active') return;
if (keepAwakePref) { try { AtlasTimer.requestWake(); } catch (e) {} }
// iOS Safari needs a user gesture to unlock audio — prime on first touch.
const unlock = () => { try { AtlasTimer.unlock(); } catch (e) {} };
window.addEventListener('pointerdown', unlock, { once: true });
window.addEventListener('touchstart', unlock, { once: true });
return () => {
try { AtlasTimer.releaseWake(); } catch (e) {}
window.removeEventListener('pointerdown', unlock);
window.removeEventListener('touchstart', unlock);
};
}, [view, keepAwakePref]);
// ── Update a set field ─────────────────────────────────────────────────────
function updateSet(ei, si, patch) {
setSession(prev => {
if (!prev) return prev;
const exercises = prev.exercises.map((ex, eIdx) => {
if (eIdx !== ei) return ex;
return { ...ex, sets: ex.sets.map((s, sIdx) => sIdx === si ? { ...s, ...patch } : s) };
});
const next = { ...prev, exercises };
WorkoutSessionStore.save(next);
return next;
});
}
// ── Update one side of a unilateral set (nested merge) ─────────────────────
function updateSetSide(ei, si, side, patch) {
setSession(prev => {
if (!prev) return prev;
const exercises = prev.exercises.map((ex, eIdx) => {
if (eIdx !== ei) return ex;
return { ...ex, sets: ex.sets.map((s, sIdx) =>
sIdx === si ? { ...s, [side]: { ...(s[side] || { kg:'', reps:'' }), ...patch } } : s) };
});
const next = { ...prev, exercises };
WorkoutSessionStore.save(next);
return next;
});
}
// ── Complete a set ─────────────────────────────────────────────────────────
function completeSet(ei, si) {
setSession(prev => {
if (!prev) return prev;
const justDone = prev.exercises[ei]?.sets[si] || {};
const exercises = prev.exercises.map((ex, eIdx) => {
if (eIdx !== ei) return ex;
return { ...ex, sets: ex.sets.map((s, sIdx) => {
if (sIdx === si) return { ...s, done: true, doneAt: Date.now() };
// La siguiente serie se rellena con el peso/reps de la recién hecha
// (si está vacía). Son editables.
if (sIdx === si + 1 && !s.done) {
const patch = {};
if ((s.kg == null || s.kg === '') && (justDone.kg != null && justDone.kg !== '')) patch.kg = justDone.kg;
if ((s.reps == null || s.reps === '') && (justDone.reps != null && justDone.reps !== '')) patch.reps = justDone.reps;
if ((s.sec == null || s.sec === '') && (justDone.sec != null && justDone.sec !== '')) patch.sec = justDone.sec;
return Object.keys(patch).length ? { ...s, ...patch } : s;
}
return s;
}) };
});
const next = { ...prev, exercises };
WorkoutSessionStore.save(next);
// Find next undone set/exercise
let foundEx = ei, foundSet = si;
outer: for (let e = ei; e < exercises.length; e++) {
const startS = e === ei ? si + 1 : 0;
for (let s = startS; s < exercises[e].sets.length; s++) {
if (!exercises[e].sets[s].done) { foundEx = e; foundSet = s; break outer; }
}
}
setTimeout(() => { setExIdx(foundEx); setSetIdx(foundSet); }, 50);
// Start rest timer. The exercise's own rest wins; otherwise fall back to
// the user's default from Ajustes (atlas.settings.v1), then to 90s.
const settingsRest = (typeof AtlasSettings !== 'undefined') ? AtlasSettings.get('restDefault') : null;
const restStr = exercises[ei]?.rest || settingsRest || '90s';
startRestTimer(restStr);
return next;
});
}
// ── Añadir una serie al final (solo esta sesión) ───────────────────────────
// Hereda el objetivo del ejercicio (reps/RIR vienen del propio ejercicio) y
// precarga el último peso usado. Marca la sesión como modificada para ofrecer
// guardarla en la rutina al terminar.
function addSet(ei) {
setSession(prev => {
if (!prev) return prev;
const exercises = prev.exercises.map((ex, eIdx) => {
if (eIdx !== ei) return ex;
const sets = ex.sets || [];
const lastKg = [...sets].reverse().find(s => s.kg != null && s.kg !== '')?.kg || '';
const base = { idx: sets.length, kg: lastKg, reps: '', rir: null, done: false, doneAt: null };
if (ex.unilateral) { base.left = { kg: '', reps: '' }; base.right = { kg: '', reps: '' }; }
return { ...ex, sets: [...sets, base] };
});
const next = { ...prev, exercises, structChanged: true };
WorkoutSessionStore.save(next);
return next;
});
}
// ── Quitar una serie (mínimo 1 por ejercicio) ──────────────────────────────
function removeSet(ei, si) {
setSession(prev => {
if (!prev) return prev;
const cur = prev.exercises[ei];
if (!cur || (cur.sets || []).length <= 1) return prev; // mínimo 1 serie
const exercises = prev.exercises.map((ex, eIdx) => {
if (eIdx !== ei) return ex;
const sets = ex.sets.filter((_, sIdx) => sIdx !== si).map((s, i) => ({ ...s, idx: i }));
return { ...ex, sets };
});
const next = { ...prev, exercises, structChanged: true };
WorkoutSessionStore.save(next);
return next;
});
}
// Reinsertar una serie quitada (para "Deshacer"), en su posición original.
function restoreSetAt(ei, si, set) {
setSession(prev => {
if (!prev) return prev;
const exercises = prev.exercises.map((ex, eIdx) => {
if (eIdx !== ei) return ex;
const sets = [...ex.sets];
sets.splice(Math.min(si, sets.length), 0, set);
return { ...ex, sets: sets.map((s, i) => ({ ...s, idx: i })) };
});
const next = { ...prev, exercises };
WorkoutSessionStore.save(next);
return next;
});
}
// Quita la ÚLTIMA serie: si está completada pide confirmación; si está
// pendiente, la quita al momento y ofrece "Deshacer" unos segundos.
function requestRemoveLastSet(ei) {
const sets = session?.exercises[ei]?.sets || [];
if (sets.length <= 1) return;
const si = sets.length - 1;
if (sets[si]?.done) { setConfirmSet({ ei, si }); return; }
doRemoveSet(ei, si);
}
function doRemoveSet(ei, si) {
const set = session?.exercises[ei]?.sets[si];
removeSet(ei, si);
// Ajusta el foco si la serie actual queda fuera de rango.
setSetIdx(cur => Math.max(0, Math.min(cur, (session?.exercises[ei]?.sets.length || 1) - 2)));
if (set) {
setUndoSet({ ei, si, set });
if (undoTimerRef.current) clearTimeout(undoTimerRef.current);
undoTimerRef.current = setTimeout(() => setUndoSet(null), 5000);
}
setConfirmSet(null);
}
function undoRemoveSet() {
if (!undoSet) return;
restoreSetAt(undoSet.ei, undoSet.si, undoSet.set);
if (undoTimerRef.current) clearTimeout(undoTimerRef.current);
setUndoSet(null);
}
// ── Navigate to set ────────────────────────────────────────────────────────
function handleSelectSet(ei, si) {
setExIdx(ei);
setSetIdx(si);
handleRestSkip();
}
// ── Navigate exercise ──────────────────────────────────────────────────────
function handleNavigateEx(newEi) {
if (!session) return;
const clampedEi = Math.max(0, Math.min(session.exercises.length - 1, newEi));
setExIdx(clampedEi);
// Find first undone set in new exercise
const ex = session.exercises[clampedEi];
const firstUndone = ex.sets.findIndex(s => !s.done);
setSetIdx(firstUndone >= 0 ? firstUndone : 0);
handleRestSkip();
}
// ── Swap the active exercise (occupied machine) ────────────────────────────
const swapRoutineName = React.useMemo(() => {
if (!session?.routineId) return null;
const r = (state.savedRoutines || []).find(x => x.id === session.routineId);
return r ? r.name : null;
}, [session?.routineId, state.savedRoutines]);
function applySwapToRoutine(origId, dbEx) {
const rid = session?.routineId;
if (!rid || !origId) return;
const routine = (state.savedRoutines || []).find(r => r.id === rid);
if (!routine) return;
const sIdx = session.sessionIndex;
const matchSession = (s, i) =>
(sIdx != null ? i === sIdx : (s.exercises || []).some(e => e.id === origId));
let touched = false;
const sessions = (routine.sessions || []).map((s, i) => {
if (touched || !matchSession(s, i)) return s;
let replaced = false;
const exercises = (s.exercises || []).map(e => {
if (!replaced && e.id === origId) {
replaced = true; touched = true;
return { ...e, id: dbEx.id, name: dbEx.name, pattern: dbEx.pattern,
muscles: dbEx.muscles || { primary: [], secondary: [] }, group: dbEx.group || dbEx.category || '' };
}
return e;
});
return { ...s, exercises };
});
if (touched) { try { actions.saveRoutine({ ...routine, sessions }); } catch (e) {} }
}
// Abre un artículo del Aula (desde "¿Por qué?" de la sugerencia).
function openArticle(id) {
try { localStorage.setItem('atlas.aula.pending.v1', id); } catch (e) {}
navigate('/aula');
}
function handleSwap(dbEx, applyToRoutine) {
if (!session || !dbEx) return;
const ei = exIdx;
const orig = session.exercises[ei];
if (!orig) return;
const doneSets = orig.sets.filter(s => s.done);
const undoneSets = orig.sets.filter(s => !s.done);
const reindex = arr => arr.map((s, i) => ({ ...s, idx: i }));
const subMeta = {
id: dbEx.id, name: dbEx.name,
muscles: dbEx.muscles || { primary: [], secondary: [] },
group: dbEx.group || dbEx.category || '',
pattern: dbEx.pattern || null,
// Carry the substitute's own registration mode so the panel renders the
// right inputs (a swap can change reps↔time↔per-side).
unit: dbEx.unit === 'time' ? 'time' : 'reps',
timeTarget: dbEx.timeTarget || null,
unilateral: dbEx.unit !== 'time' && dbEx.unilateral === true,
// Se mantienen las REPS objetivo, el RIR y el descanso del hueco.
targetSets: orig.targetSets, repsRange: orig.repsRange, rir: orig.rir, rest: orig.rest,
swappedFrom: orig.swappedFrom || orig.name,
};
// El peso NO se hereda del ejercicio original (pueden ser cargas muy
// distintas: una prensa mueve mucho más que un hack squat). Se precarga con
// la sugerencia / última vez del NUEVO ejercicio, o se deja vacío si no tiene
// historial. Las reps objetivo (repsRange), el RIR y el descanso sí se mantienen.
let subKg = '';
try {
const info = wpSuggestFor(subMeta, state.log);
if (info && !info.isBodyweight) {
const k = (info.sug && info.sug.kg != null) ? info.sug.kg
: (info.history[0] ? info.history[0].maxKg : null);
if (k != null && k > 0) subKg = String(k);
}
} catch (e) {}
const freshSet = s => ({ idx: 0, kg: subKg, reps: s.reps || '', rpe: null, done: false, doneAt: null });
// Where the substitute lands: in-place (0 hechas) → mismo índice; con series
// hechas se inserta DESPUÉS del original conservado → ei+1. Se calcula aquí,
// no dentro del updater de setSession (que corre en el render siguiente), para
// que el foco salte de verdad al sustituto y no se quede en el original.
const focusIdx = doneSets.length > 0 ? ei + 1 : ei;
setSession(prev => {
if (!prev) return prev;
const cur = prev.exercises[ei];
let exercises;
if (cur.sets.filter(s => s.done).length === 0) {
// No logged data → clean in-place replacement, full scheme preserved.
const replaced = { ...subMeta, sets: reindex(cur.sets.map(freshSet)) };
exercises = prev.exercises.map((e, i) => (i === ei ? replaced : e));
} else {
// Sets already logged → keep original (trimmed, partial) + substitute
// for the remaining sets. Nothing entered is lost.
const kept = { ...cur, sets: reindex(cur.sets.filter(s => s.done)), partial: true };
const remaining = cur.sets.filter(s => !s.done);
const rem = remaining.length ? remaining : [{ kg: '', reps: cur.sets[0]?.reps || '', done: false }];
const substitute = { ...subMeta, sets: reindex(rem.map(freshSet)) };
exercises = [];
prev.exercises.forEach((e, i) => { if (i === ei) { exercises.push(kept, substitute); } else exercises.push(e); });
}
const next = { ...prev, exercises, structChanged: true };
WorkoutSessionStore.save(next);
return next;
});
setSetIdx(0);
setExIdx(focusIdx); // enfoca el sustituto
handleRestSkip();
if (applyToRoutine) applySwapToRoutine(orig.id, dbEx);
}
// ── Add an extra exercise mid-session (today only) ─────────────────────────
// Inserted right AFTER the current exercise and focused, so the user can do it
// now and then continue with what was next. Default scheme 3×(8-12); respects
// isometric (time) / unilateral (per-side) registration. Flagged `added` so we
// can offer to save it to the routine at the end. Persisted to the active
// session so it survives lock / reload / close and reaches the history.
function handleAddExercise(dbEx) {
if (!session || !dbEx) return;
const raw = {
id: dbEx.id, name: dbEx.name,
muscles: dbEx.muscles || { primary: [], secondary: [] },
pattern: dbEx.pattern || null,
group: dbEx.group || dbEx.category || '',
unit: dbEx.unit, timeTarget: dbEx.timeTarget, unilateral: dbEx.unilateral,
setsCount: 3, repsRange: '8-12', rir: 2, rest: '90s',
};
let norm;
try { norm = WorkoutSessionStore.normalize([raw])[0]; } catch { norm = null; }
if (!norm) return;
norm.added = true;
const ei = exIdx;
setSession(prev => {
if (!prev) return prev;
const exercises = [...prev.exercises];
exercises.splice(Math.min(ei + 1, exercises.length), 0, norm);
const next = { ...prev, exercises, structChanged: true };
WorkoutSessionStore.save(next);
return next;
});
setSetIdx(0);
setExIdx(ei + 1); // focus the newly added exercise
handleRestSkip();
}
// Append exercises to a saved routine's trained session (offered at finish).
function addExercisesToRoutine(routineId, sessionIndex, routineExs) {
const routine = (state.savedRoutines || []).find(r => r.id === routineId);
if (!routine || !routineExs.length) return false;
const sessions = (routine.sessions || []).map((s, i) => {
const target = sessionIndex != null ? i === sessionIndex : i === 0;
return target ? { ...s, exercises: [...(s.exercises || []), ...routineExs] } : s;
});
try { actions.saveRoutine({ ...routine, sessions }); return true; } catch { return false; }
}
// Reemplaza los ejercicios de la sesión entrenada de la rutina por los de HOY
// (nº de series, sustituciones y añadidos). Excluye los restos parciales que
// deja un cambio de ejercicio (el original conservado con sus series hechas).
function saveSessionChangesToRoutine(routineId, sessionIndex, exercises) {
const routine = (state.savedRoutines || []).find(r => r.id === routineId);
if (!routine) return false;
const toRoutineEx = e => ({
id: e.id, name: e.name, pattern: e.pattern || null,
muscles: e.muscles || { primary: [], secondary: [] },
group: e.group || '',
setsCount: (e.sets || []).length || e.targetSets || 3,
repsRange: e.repsRange || '8-12', rir: e.rir ?? 2, rest: e.rest || '90s',
...(e.unit === 'time' ? { unit: 'time', timeTarget: e.timeTarget || null } : {}),
...(e.unilateral ? { unilateral: true } : {}),
});
const routineExs = (exercises || []).filter(e => !e.partial).map(toRoutineEx);
if (!routineExs.length) return false;
const sessions = (routine.sessions || []).map((s, i) => {
const target = sessionIndex != null ? i === sessionIndex : i === 0;
return target ? { ...s, exercises: routineExs } : s;
});
try { actions.saveRoutine({ ...routine, sessions }); return true; } catch { return false; }
}
// Guarda la sesión de hoy como una rutina NUEVA del usuario (para cuando venía
// de una predeterminada, que no se edita). Un solo día con los ejercicios de hoy.
function saveSessionAsNewRoutine(name, exercises) {
const toRoutineEx = e => ({
id: e.id, name: e.name, pattern: e.pattern || null,
muscles: e.muscles || { primary: [], secondary: [] },
group: e.group || '',
setsCount: (e.sets || []).length || e.targetSets || 3,
repsRange: e.repsRange || '8-12', rir: e.rir ?? 2, rest: e.rest || '90s',
...(e.unit === 'time' ? { unit: 'time', timeTarget: e.timeTarget || null } : {}),
...(e.unilateral ? { unilateral: true } : {}),
});
const routineExs = (exercises || []).filter(e => !e.partial).map(toRoutineEx);
if (!routineExs.length) return false;
const routine = {
id: `routine-${Date.now()}`,
name: `${name || 'Mi rutina'} (mi versión)`,
createdAt: Date.now(),
sessions: [{ name: session?.sessionName || 'Sesión', exercises: routineExs }],
};
try { actions.saveRoutine(routine); return true; } catch { return false; }
}
// ── Finish workout ─────────────────────────────────────────────────────────
// Logs whatever sets are done. Sessions with unfinished sets are flagged
// `partial` so Perfil/Progreso can label them.
function finishWorkout() {
if (!session) return;
clearInterval(elapsedIntRef.current);
skipRest();
// ¿Hubo cambios de estructura (series, sustituciones o añadidos)? Al terminar
// se ofrece UNA vez guardarlos: en la rutina guardada si la hay, o como
// rutina nueva si venía de una predeterminada (que no se edita).
const savedRoutine = (state.savedRoutines || []).find(r => r.id === session.routineId);
if (session.structChanged && savedRoutine) {
setAddOffer({
kind: 'changes',
routineName: savedRoutine.name,
routineId: session.routineId,
sessionIndex: session.sessionIndex,
exercises: (session.exercises || []),
done: false,
});
} else if (session.structChanged && !savedRoutine) {
// Predeterminada u origen sin rutina guardada → guardar como rutina mía.
setAddOffer({
kind: 'newRoutine',
routineName: session.routineName || 'Mi rutina',
exercises: (session.exercises || []),
done: false,
});
} else {
setAddOffer(null);
}
const completed = WorkoutSessionStore.complete(session);
const isPartial = (completed.completedSets || 0) < (completed.totalSets || 0);
// Effort-tiered session reward: ≥60% of planned sets done AND ≥15 min → 20;
// 30–60% → 10; under 30% → 0. Capped to one session reward per day (the
// store enforces the cap via sessions.lastGemDate).
const ratio = completed.totalSets > 0 ? completed.completedSets / completed.totalSets : 0;
const minutes = (completed.duration || 0) / 60;
const gemsTier = ratio >= 0.3 ? ((ratio >= 0.6 && minutes >= 15) ? 20 : 10) : 0;
const rewardedToday = (state.sessions?.lastGemDate === new Date().toDateString());
const gemsAwarded = rewardedToday ? 0 : gemsTier;
// Build exercises payload for logSession (compatible with store format).
// Guardamos también el RIR de cada serie y los objetivos del ejercicio
// (rango de reps y RIR objetivo), para el seguimiento de cargas y la
// sugerencia de progresión. Retrocompatible: las series antiguas sin estos
// campos siguen siendo válidas (rir ausente = cumplido).
const tr = ex => (typeof progParseRepRange === 'function') ? progParseRepRange(ex.repsRange) : { min: 8, max: 12 };
const logExercises = completed.exercises.map(ex => {
const t = tr(ex);
return {
name: ex.name,
...(ex.id ? { id: ex.id } : {}),
group: ex.group || '',
...(ex.pattern ? { pattern: ex.pattern } : {}),
...(ex.equipment ? { equipment: ex.equipment } : {}),
...(ex.unit === 'time' ? { unit: 'time' } : {}),
...(ex.unilateral ? { unilateral: true } : {}),
muscles: (ex.muscles?.primary || []),
targetRepsMin: t.min,
targetRepsMax: t.max,
targetRir: (ex.rir != null ? ex.rir : null),
repsRange: ex.repsRange || `${t.min}-${t.max}`,
sets: ex.sets.filter(s => s.done).map(s => {
const common = { rir: (s.rir != null ? s.rir : null), done: true, targetRepsMin: t.min, targetRepsMax: t.max, targetRir: (ex.rir != null ? ex.rir : null) };
if (ex.unit === 'time') return { kg: s.kg, sec: s.sec, ...common };
if (ex.unilateral) {
const l = s.left || {}, r = s.right || {};
// Representative top-level kg/reps = the heavier side, so progression/
// analysis (which read set.kg/reps) keep working; per-side detail kept.
const kg = String(Math.max(parseFloat(l.kg) || 0, parseFloat(r.kg) || 0) || '');
const reps = String(Math.max(parseInt(l.reps) || 0, parseInt(r.reps) || 0) || '');
return { kg, reps, left: { kg: l.kg || '', reps: l.reps || '' }, right: { kg: r.kg || '', reps: r.reps || '' }, ...common };
}
// Standard set — keep drop-set sub-tramos with real data only, con el
// kg normalizado (coma→punto) igual que la serie principal.
const normKg = (typeof WorkoutSessionStore !== 'undefined' && WorkoutSessionStore.normKgStr)
? WorkoutSessionStore.normKgStr
: (v => { const n = parseFloat(String(v == null ? '' : v).replace(',', '.')); return Number.isFinite(n) ? String(n) : ''; });
const drops = (s.drops || [])
.filter(d => (d.kg !== '' && d.kg != null) || (d.reps !== '' && d.reps != null))
.map(d => ({ ...d, kg: normKg(d.kg) }));
return { kg: s.kg, reps: s.reps, ...(drops.length ? { drops } : {}), ...common };
}),
};
});
try {
actions.logSession(logExercises, {
duration: completed.duration,
routineName: completed.routineName,
sessionName: completed.sessionName,
partial: isPartial,
gemsEarned: gemsTier,
allowPR: true,
});
} catch (e) { /* store may not support this */ }
setFinished({ ...completed, gemsAwarded, gemsTier, rewardCapped: rewardedToday && gemsTier > 0, partial: isPartial });
setView('finish');
}
// ── Exit choices (Salir dialog) ────────────────────────────────────────────
// Pause: keep the session (and rest timer) persisted so it resumes exactly
// where it was. Inicio surfaces a "Entrenamiento en curso" banner.
function handleExitPause() {
clearInterval(elapsedIntRef.current);
navigate('/');
}
// Save & finish: log the completed sets (as partial) and show the summary.
function handleExitSave() { finishWorkout(); }
// Discard: drop the active session without saving anything.
function handleExitDiscard() {
clearInterval(elapsedIntRef.current);
skipRest();
try { WorkoutSessionStore.discard(); } catch (e) {}
navigate('/');
}
// ── Render ─────────────────────────────────────────────────────────────────
if (view === 'loading') return ;
if (view === 'history') {
return navigate('/coach')} />;
}
if (view === 'finish') {
return (
navigate('/')}
onCoach={() => navigate('/coach')}
onOpenArticle={openArticle}
addOffer={addOffer}
onAddToRoutine={() => {
if (!addOffer) return;
const ok = addOffer.kind === 'changes'
? saveSessionChangesToRoutine(addOffer.routineId, addOffer.sessionIndex, addOffer.exercises)
: addOffer.kind === 'newRoutine'
? saveSessionAsNewRoutine(addOffer.routineName, addOffer.exercises)
: addExercisesToRoutine(addOffer.routineId, addOffer.sessionIndex, addOffer.exs);
setAddOffer(prev => prev ? { ...prev, done: ok } : prev);
}}
onDismissOffer={() => setAddOffer(null)}
/>
);
}
// 'active'
if (!session) return ;
return (
{ if (undoTimerRef.current) clearTimeout(undoTimerRef.current); setUndoSet(null); }}
confirmSet={confirmSet}
onConfirmRemove={() => confirmSet && doRemoveSet(confirmSet.ei, confirmSet.si)}
onCancelConfirm={() => setConfirmSet(null)}
/>
);
}
Object.assign(window, { WorkoutPlayerSection });