Training stats count Open/Free practice by default; laps from qualifying, heats and finals are kept and shown under Based on: Races or All, marked with race, session and series. Races are listed per race session and never split into stints. Same picker in the mobile profile. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1223 lines
58 KiB
JavaScript
1223 lines
58 KiB
JavaScript
import { getDriverProfile, getDriverProfileReferences } from "./driver_profile_logic.js";
|
|
import { getTrackLayoutIdAt } from "./track_layouts_logic.js";
|
|
|
|
const PUBLIC_TRAINING_SECTIONS = ["progress", "achievements", "performance", "goals", "history"];
|
|
|
|
function normalizePublicTrainingVisibility(value) {
|
|
const source = value && typeof value === "object" ? value : {};
|
|
return Object.fromEntries(PUBLIC_TRAINING_SECTIONS.map((key) => [key, source[key] !== false]));
|
|
}
|
|
|
|
function getTrainingDriverIds(state, driverId, classId = "") {
|
|
const profile = getDriverProfile(state, driverId);
|
|
if (!profile) return getDriverProfileReferences(state, driverId);
|
|
const normalizedClassId = String(classId || "");
|
|
return new Set(profile.drivers
|
|
.filter((driver) => !normalizedClassId || String(driver.classId || "") === normalizedClassId)
|
|
.map((driver) => String(driver.id || ""))
|
|
.filter(Boolean));
|
|
}
|
|
|
|
export function normalizeTrainingState(training, { uid }) {
|
|
const source = training && typeof training === "object" ? training : {};
|
|
const clubGoalSource = source.clubGoal && typeof source.clubGoal === "object" ? source.clubGoal : null;
|
|
const clubGoalMetric = String(clubGoalSource?.metric || "") === "sessions" ? "sessions" : "laps";
|
|
const clubGoalExerciseKind = ["timer", "evenLaps", "stepTraining"].includes(String(clubGoalSource?.exerciseKind || "")) ? String(clubGoalSource.exerciseKind) : "";
|
|
const clubGoalHasTarget = clubGoalSource && (clubGoalMetric === "sessions"
|
|
? Number(clubGoalSource.targetSessions || 0) > 0 && clubGoalExerciseKind
|
|
: Number(clubGoalSource.targetLaps || 0) > 0);
|
|
const clubGoal = clubGoalHasTarget
|
|
? {
|
|
id: String(clubGoalSource.id || uid("club_goal")),
|
|
title: String(clubGoalSource.title || "").trim(),
|
|
reward: String(clubGoalSource.reward || "").trim(),
|
|
targetLaps: Math.max(1, Math.round(Number(clubGoalSource.targetLaps || 0) || 0)),
|
|
baselineLaps: Math.max(0, Math.round(Number(clubGoalSource.baselineLaps || 0) || 0)),
|
|
metric: clubGoalMetric,
|
|
exerciseKind: clubGoalMetric === "sessions" ? clubGoalExerciseKind : "",
|
|
targetSessions: Math.max(1, Math.round(Number(clubGoalSource.targetSessions || 0) || 0)),
|
|
baselineSessions: Math.max(0, Math.round(Number(clubGoalSource.baselineSessions || 0) || 0)),
|
|
createdAt: String(clubGoalSource.createdAt || new Date().toISOString()),
|
|
celebratedAt: clubGoalSource.celebratedAt ? String(clubGoalSource.celebratedAt) : "",
|
|
}
|
|
: null;
|
|
const goals = Array.isArray(source.goals)
|
|
? source.goals
|
|
.map((goal) => {
|
|
const metric = String(goal?.metric || "") === "sessions" ? "sessions" : "laps";
|
|
const exerciseKind = ["timer", "evenLaps", "stepTraining"].includes(String(goal?.exerciseKind || "")) ? String(goal.exerciseKind) : "";
|
|
return {
|
|
id: String(goal?.id || uid("goal")),
|
|
driverId: String(goal?.driverId || ""),
|
|
classId: String(goal?.classId || ""),
|
|
title: String(goal?.title || "").trim(),
|
|
reward: String(goal?.reward || "").trim(),
|
|
targetLaps: Math.max(1, Math.round(Number(goal?.targetLaps || 0) || 0)),
|
|
metric,
|
|
exerciseKind: metric === "sessions" ? exerciseKind : "",
|
|
targetSessions: Math.max(1, Math.round(Number(goal?.targetSessions || 0) || 0)),
|
|
createdAt: String(goal?.createdAt || new Date().toISOString()),
|
|
claimedAt: goal?.claimedAt ? String(goal.claimedAt) : "",
|
|
};
|
|
})
|
|
.filter((goal) => goal.driverId && (goal.metric === "sessions" ? goal.exerciseKind && goal.targetSessions > 0 : goal.targetLaps > 0))
|
|
: [];
|
|
|
|
const seenLedgerKeys = new Set();
|
|
const ledger = Array.isArray(source.ledger)
|
|
? source.ledger
|
|
.map((entry) => {
|
|
const timestamp = Math.max(0, Number(entry?.timestamp || 0) || 0);
|
|
return {
|
|
id: String(entry?.id || uid("training_lap")),
|
|
sourceKey: String(entry?.sourceKey || ""),
|
|
sessionId: String(entry?.sessionId || ""),
|
|
sessionName: String(entry?.sessionName || "").trim(),
|
|
eventId: String(entry?.eventId || ""),
|
|
eventName: String(entry?.eventName || "").trim(),
|
|
driverId: String(entry?.driverId || ""),
|
|
sourceId: String(entry?.sourceId || entry?.driverId || ""),
|
|
excludedFromPace: Boolean(entry?.excludedFromPace),
|
|
stintBoundary: Boolean(entry?.stintBoundary),
|
|
timestamp,
|
|
lapMs: Math.max(0, Math.round(Number(entry?.lapMs || 0) || 0)),
|
|
recordedAt: String(entry?.recordedAt || (timestamp ? new Date(timestamp).toISOString() : new Date().toISOString())),
|
|
trackLayoutId: String(entry?.trackLayoutId || "").trim(),
|
|
sessionType: String(entry?.sessionType || "").trim(),
|
|
eventId: String(entry?.eventId || "").trim(),
|
|
};
|
|
})
|
|
.filter((entry) => {
|
|
const key = entry.sourceKey || entry.id;
|
|
if (!entry.driverId || entry.lapMs <= 500 || seenLedgerKeys.has(key)) return false;
|
|
seenLedgerKeys.add(key);
|
|
return true;
|
|
})
|
|
.sort((left, right) => left.timestamp - right.timestamp)
|
|
: [];
|
|
|
|
const seenShareDrivers = new Set();
|
|
const shares = Array.isArray(source.shares)
|
|
? source.shares
|
|
.map((share) => ({
|
|
driverId: String(share?.driverId || ""),
|
|
token: String(share?.token || "").trim(),
|
|
enabled: share?.enabled !== false,
|
|
createdAt: String(share?.createdAt || new Date().toISOString()),
|
|
visibility: normalizePublicTrainingVisibility(share?.visibility),
|
|
}))
|
|
.filter((share) => {
|
|
if (!share.driverId || share.token.length < 24 || seenShareDrivers.has(share.driverId)) return false;
|
|
seenShareDrivers.add(share.driverId);
|
|
return true;
|
|
})
|
|
: [];
|
|
|
|
const markers = Array.isArray(source.markers)
|
|
? source.markers
|
|
.map((marker) => ({
|
|
id: String(marker?.id || uid("training_marker")),
|
|
driverId: String(marker?.driverId || ""),
|
|
classId: String(marker?.classId || ""),
|
|
sessionId: String(marker?.sessionId || ""),
|
|
timestamp: Math.max(0, Number(marker?.timestamp || 0) || 0),
|
|
type: ["setup", "tires", "suspension", "car", "note"].includes(String(marker?.type || "").toLowerCase())
|
|
? String(marker.type).toLowerCase()
|
|
: "setup",
|
|
note: String(marker?.note || "").trim(),
|
|
createdAt: String(marker?.createdAt || new Date().toISOString()),
|
|
}))
|
|
.filter((marker) => marker.driverId && marker.classId && marker.timestamp > 0)
|
|
.sort((left, right) => left.timestamp - right.timestamp)
|
|
: [];
|
|
|
|
const seenEvenLapsConfigs = new Set();
|
|
const evenLaps = Array.isArray(source.evenLaps)
|
|
? source.evenLaps
|
|
.map((entry) => ({
|
|
id: String(entry?.id || uid("even_laps")),
|
|
driverId: String(entry?.driverId || ""),
|
|
classId: String(entry?.classId || ""),
|
|
targetMs: Math.max(0, Math.round(Number(entry?.targetMs || 0) || 0)),
|
|
toleranceMs: Math.max(0, Math.round(Number(entry?.toleranceMs || 0) || 0)),
|
|
lapCount: Math.max(1, Math.round(Number(entry?.lapCount || 0) || 5)),
|
|
updatedAt: String(entry?.updatedAt || new Date().toISOString()),
|
|
}))
|
|
.filter((entry) => {
|
|
const key = `${entry.driverId}:${entry.classId}`;
|
|
if (!entry.driverId || !entry.classId || entry.targetMs <= 0 || seenEvenLapsConfigs.has(key)) return false;
|
|
seenEvenLapsConfigs.add(key);
|
|
return true;
|
|
})
|
|
: [];
|
|
|
|
const seenStepTrainingConfigs = new Set();
|
|
const stepTraining = Array.isArray(source.stepTraining)
|
|
? source.stepTraining
|
|
.map((entry) => ({
|
|
id: String(entry?.id || uid("step_training")),
|
|
driverId: String(entry?.driverId || ""),
|
|
classId: String(entry?.classId || ""),
|
|
steps: Array.isArray(entry?.steps)
|
|
? entry.steps
|
|
.map((step) => ({
|
|
effort: ["calm", "controlled", "fast"].includes(String(step?.effort || "")) ? String(step.effort) : "calm",
|
|
lapCount: Math.max(0, Math.round(Number(step?.lapCount || 0) || 0)),
|
|
}))
|
|
.filter((step) => step.lapCount > 0)
|
|
: [],
|
|
updatedAt: String(entry?.updatedAt || new Date().toISOString()),
|
|
}))
|
|
.filter((entry) => {
|
|
const key = `${entry.driverId}:${entry.classId}`;
|
|
if (!entry.driverId || !entry.classId || !entry.steps.length || seenStepTrainingConfigs.has(key)) return false;
|
|
seenStepTrainingConfigs.add(key);
|
|
return true;
|
|
})
|
|
: [];
|
|
|
|
const seenExerciseSessions = new Set();
|
|
const exerciseSessions = Array.isArray(source.exerciseSessions)
|
|
? source.exerciseSessions
|
|
.map((entry) => ({
|
|
id: String(entry?.id || uid("exercise_session")),
|
|
driverId: String(entry?.driverId || ""),
|
|
classId: String(entry?.classId || ""),
|
|
kind: ["timer", "evenLaps", "stepTraining"].includes(String(entry?.kind || "")) ? String(entry.kind) : "",
|
|
startedAt: Math.max(0, Number(entry?.startedAt || 0) || 0),
|
|
completedAt: String(entry?.completedAt || new Date().toISOString()),
|
|
summary: entry?.summary && typeof entry.summary === "object" ? entry.summary : {},
|
|
}))
|
|
.filter((entry) => {
|
|
if (!entry.driverId || !entry.classId || !entry.kind || !entry.startedAt) return false;
|
|
const key = `${entry.driverId}:${entry.classId}:${entry.kind}:${entry.startedAt}`;
|
|
if (seenExerciseSessions.has(key)) return false;
|
|
seenExerciseSessions.add(key);
|
|
return true;
|
|
})
|
|
.sort((left, right) => right.startedAt - left.startedAt)
|
|
: [];
|
|
|
|
return { goals, ledger, shares, markers, clubGoal, evenLaps, stepTraining, exerciseSessions };
|
|
}
|
|
|
|
function getPassingSourceKey(sessionId, passing, index) {
|
|
const competitor = String(passing?.competitorKey || passing?.driverId || passing?.transponder || "unknown");
|
|
return `${sessionId}:${Number(passing?.timestamp || 0) || 0}:${competitor}:${index}`;
|
|
}
|
|
|
|
export function syncTrainingLedger(training, state, { uid }) {
|
|
const normalized = normalizeTrainingState(training, { uid });
|
|
const results = state?.resultsBySession && typeof state.resultsBySession === "object" ? state.resultsBySession : {};
|
|
const currentSessionIds = new Set(Object.keys(results));
|
|
const sessions = new Map((Array.isArray(state?.sessions) ? state.sessions : []).map((session) => [String(session.id), session]));
|
|
// A session's laps are rebuilt from its results - except laps from before a "Reset data"
|
|
// (session.resultsResetAt): they're gone from the results but stay training history, so an
|
|
// Open Practice can be cleared for a new day without losing anyone's stats.
|
|
const retained = normalized.ledger.filter((entry) => {
|
|
if (!currentSessionIds.has(entry.sessionId)) return true;
|
|
const resetAt = Number(sessions.get(entry.sessionId)?.resultsResetAt || 0);
|
|
return resetAt > 0 && entry.timestamp < resetAt;
|
|
});
|
|
const events = new Map((Array.isArray(state?.events) ? state.events : []).map((event) => [String(event.id), event]));
|
|
const current = [];
|
|
|
|
Object.entries(results).forEach(([sessionId, result]) => {
|
|
const session = sessions.get(String(sessionId));
|
|
const event = session ? events.get(String(session.eventId || "")) : null;
|
|
(Array.isArray(result?.passings) ? result.passings : []).forEach((passing, index) => {
|
|
const driverId = String(passing?.driverId || "");
|
|
const lapMs = Math.round(Number(passing?.lapMs || 0) || 0);
|
|
// A suspect practice lap (a likely shortcut) joins the stats only once it is approved.
|
|
if (!driverId || passing?.validLap === false || passing?.suspect || lapMs <= 500) return;
|
|
const timestamp = Math.max(0, Number(passing?.timestamp || 0) || 0);
|
|
const sourceKey = getPassingSourceKey(sessionId, passing, index);
|
|
current.push({
|
|
id: `training_${sourceKey}`,
|
|
sourceKey,
|
|
sessionId: String(sessionId),
|
|
sessionName: String(session?.name || "").trim(),
|
|
eventId: String(session?.eventId || ""),
|
|
eventName: String(event?.name || "").trim(),
|
|
driverId,
|
|
sourceId: String(passing?.competitorKey || passing?.carId || passing?.transponder || driverId),
|
|
excludedFromPace: Boolean(passing?.excludedFromPace || passing?.validationWarning === "above_max_stint"),
|
|
stintBoundary: Boolean(passing?.stintBoundary || passing?.validationWarning === "above_max_stint"),
|
|
timestamp,
|
|
lapMs,
|
|
recordedAt: timestamp ? new Date(timestamp).toISOString() : new Date().toISOString(),
|
|
// The layout active when this lap was driven, not when the session started: a club
|
|
// can run one Open Practice all season and switch layout mid-session, and laps on
|
|
// either side of the switch must land on their own layout.
|
|
trackLayoutId: timestamp ? getTrackLayoutIdAt(state?.trackLayouts, timestamp) : String(session?.trackLayoutId || "").trim(),
|
|
sessionType: String(session?.type || ""),
|
|
});
|
|
});
|
|
});
|
|
|
|
// Spread the rest of `normalized` rather than listing each field by name: an evenLaps
|
|
// config once went missing here because this rebuild listed fields individually and
|
|
// silently dropped a newly-added one. Only `ledger` actually needs to change.
|
|
// Laps saved before the session type was recorded get it from their session, if it still
|
|
// exists (otherwise they stay "" and count as practice - nothing disappears).
|
|
retained.forEach((entry) => {
|
|
if (!entry.sessionType && sessions.has(entry.sessionId)) entry.sessionType = String(sessions.get(entry.sessionId).type || "");
|
|
});
|
|
return normalizeTrainingState({
|
|
...normalized,
|
|
ledger: [...retained, ...current],
|
|
}, { uid });
|
|
}
|
|
|
|
// Training stats are about practice: laps from qualifying, heats, finals and team races are
|
|
// kept (a driver may want to compare race pace) but only counted when "race" or "all" is
|
|
// chosen. Laps whose session type is unknown count as practice.
|
|
const RACE_SESSION_TYPES = new Set(["qualification", "heat", "final", "team_race"]);
|
|
export const TRAINING_LAP_SOURCES = Object.freeze(["practice", "race", "all"]);
|
|
|
|
export function getTrainingLapSource(sessionType) {
|
|
return RACE_SESSION_TYPES.has(String(sessionType || "")) ? "race" : "practice";
|
|
}
|
|
|
|
export function normalizeTrainingLapSource(value) {
|
|
return TRAINING_LAP_SOURCES.includes(String(value)) ? String(value) : "practice";
|
|
}
|
|
|
|
const practiceLapsOnly = (laps) => laps.filter((lap) => lap.source !== "race");
|
|
|
|
// One row per race session (a qualifying heat, a final ...) the driver took part in: laps,
|
|
// best, average and spread - the race counterpart of the practice stint table.
|
|
export function buildTrainingRaceSessions(state, driverId, classId = "", { layout = "all" } = {}) {
|
|
const bySession = new Map();
|
|
getDriverTrainingLapsForLayout(state, driverId, classId, layout, "race").forEach((lap) => {
|
|
if (!bySession.has(lap.sessionId)) bySession.set(lap.sessionId, { sessionId: lap.sessionId, sessionType: lap.sessionType, sessionName: lap.sessionName, eventId: lap.eventId, eventName: lap.eventName, laps: [] });
|
|
bySession.get(lap.sessionId).laps.push(lap);
|
|
});
|
|
return [...bySession.values()].map((session) => {
|
|
const values = session.laps.filter((lap) => !lap.excludedFromPace).map((lap) => lap.lapMs);
|
|
return {
|
|
sessionId: session.sessionId,
|
|
sessionType: session.sessionType,
|
|
sessionName: session.sessionName,
|
|
eventId: session.eventId,
|
|
eventName: session.eventName,
|
|
startedAt: Math.min(...session.laps.map((lap) => lap.timestamp - lap.lapMs)),
|
|
lapCount: session.laps.length,
|
|
bestLapMs: values.length ? Math.min(...values) : 0,
|
|
averageLapMs: values.length ? Math.round(values.reduce((sum, value) => sum + value, 0) / values.length) : 0,
|
|
consistencyPct: values.length >= 3 ? consistencySpread(values) : null,
|
|
};
|
|
}).sort((a, b) => b.startedAt - a.startedAt);
|
|
}
|
|
|
|
export function getDriverTrainingLaps(state, driverId, classId = "", { source = "practice" } = {}) {
|
|
const ledger = Array.isArray(state?.training?.ledger) ? state.training.ledger : [];
|
|
const profileReferences = getTrainingDriverIds(state, driverId, classId);
|
|
const sessionTypes = new Map((Array.isArray(state?.sessions) ? state.sessions : []).map((session) => [String(session.id), String(session.type || "")]));
|
|
const wanted = normalizeTrainingLapSource(source);
|
|
return ledger
|
|
.filter((entry) => profileReferences.has(String(entry?.driverId || "")) && Number(entry?.lapMs || 0) > 500)
|
|
.map((entry) => {
|
|
const sessionType = String(entry.sessionType || sessionTypes.get(String(entry.sessionId || "")) || "");
|
|
return { entry, sessionType, source: getTrainingLapSource(sessionType) };
|
|
})
|
|
.filter(({ source: lapSource }) => wanted === "all" || lapSource === wanted)
|
|
.map(({ entry, sessionType, source: lapSource }) => ({
|
|
sessionType,
|
|
source: lapSource,
|
|
eventId: String(entry.eventId || ""),
|
|
sessionId: String(entry.sessionId || ""),
|
|
sessionName: String(entry.sessionName || ""),
|
|
eventName: String(entry.eventName || ""),
|
|
driverId: String(entry.driverId || ""),
|
|
sourceId: String(entry.sourceId || entry.driverId || ""),
|
|
excludedFromPace: Boolean(entry.excludedFromPace),
|
|
stintBoundary: Boolean(entry.stintBoundary),
|
|
timestamp: Number(entry.timestamp || 0) || 0,
|
|
lapMs: Number(entry.lapMs || 0),
|
|
trackLayoutId: String(entry.trackLayoutId || ""),
|
|
}))
|
|
.sort((left, right) => left.timestamp - right.timestamp);
|
|
}
|
|
|
|
// Every lifetime/commitment stat (total laps ever driven, training days, achievement
|
|
// badges) intentionally keeps reading the full history via getDriverTrainingLaps above -
|
|
// a track rebuild doesn't erase how much a driver has practiced. Only pace-comparison
|
|
// stats (personal best, consistency, the "stable pace" cue's target) should stop blending
|
|
// laps from a track that no longer exists into today's numbers, so those read this
|
|
// layout-scoped subset instead. With no track layouts configured, every lap's
|
|
// trackLayoutId is "" and getTrackLayoutIdAt() also returns "" - so this returns exactly
|
|
// the same laps as getDriverTrainingLaps, and the feature stays fully inert until used.
|
|
// `layout` picks which laps count: "current" (default, the active layout), "all" (every
|
|
// layout blended - the overall view), "none" (laps driven before any layout existed), or
|
|
// a specific layout id.
|
|
export function getDriverTrainingLapsForLayout(state, driverId, classId = "", layout = "current", source = "practice") {
|
|
const laps = getDriverTrainingLaps(state, driverId, classId, { source });
|
|
if (layout === "all") return laps;
|
|
const layoutId = layout === "current" || !layout ? getTrackLayoutIdAt(state?.trackLayouts) : layout === "none" ? "" : String(layout);
|
|
return laps.filter((lap) => lap.trackLayoutId === layoutId);
|
|
}
|
|
|
|
export function getDriverTrainingLapsForCurrentLayout(state, driverId, classId = "") {
|
|
return getDriverTrainingLapsForLayout(state, driverId, classId, "current");
|
|
}
|
|
|
|
function percentile(values, ratio) {
|
|
if (!values.length) return 0;
|
|
const sorted = [...values].sort((left, right) => left - right);
|
|
const index = Math.min(sorted.length - 1, Math.max(0, Math.round((sorted.length - 1) * ratio)));
|
|
return sorted[index];
|
|
}
|
|
|
|
function average(values) {
|
|
return values.length ? Math.round(values.reduce((sum, value) => sum + value, 0) / values.length) : 0;
|
|
}
|
|
|
|
function consistencySpread(values) {
|
|
const mean = average(values);
|
|
return mean ? ((percentile(values, 0.9) - percentile(values, 0.1)) / mean) * 100 : 0;
|
|
}
|
|
|
|
function trimmedAverage(values, trimRatio = 0.1) {
|
|
if (!values.length) return 0;
|
|
const sorted = [...values].sort((left, right) => left - right);
|
|
const trimCount = sorted.length >= 5 ? Math.max(1, Math.floor(sorted.length * trimRatio)) : 0;
|
|
const kept = trimCount ? sorted.slice(trimCount, sorted.length - trimCount) : sorted;
|
|
return average(kept);
|
|
}
|
|
|
|
export function getDriverTrainingMarkers(state, driverId, classId = "") {
|
|
const profileReferences = getTrainingDriverIds(state, driverId, classId);
|
|
const normalizedClassId = String(classId || "");
|
|
return (Array.isArray(state?.training?.markers) ? state.training.markers : [])
|
|
.filter((marker) => (
|
|
profileReferences.has(String(marker?.driverId || ""))
|
|
&& (!normalizedClassId || String(marker?.classId || "") === normalizedClassId)
|
|
))
|
|
.map((marker) => ({ ...marker }))
|
|
.sort((left, right) => Number(left.timestamp || 0) - Number(right.timestamp || 0));
|
|
}
|
|
|
|
export function buildTrainingPaceBuckets(state, driverId, classId = "", bucketMinutes = 30) {
|
|
const laps = getDriverTrainingLaps(state, driverId, classId).filter((lap) => !lap.excludedFromPace);
|
|
const bucketMs = Math.max(5, Number(bucketMinutes || 30)) * 60 * 1000;
|
|
const buckets = new Map();
|
|
laps.forEach((lap) => {
|
|
const date = new Date(lap.timestamp);
|
|
const bucketMinutesValue = bucketMs / 60000;
|
|
const startTs = new Date(
|
|
date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(),
|
|
Math.floor(date.getMinutes() / bucketMinutesValue) * bucketMinutesValue, 0, 0
|
|
).getTime();
|
|
const key = String(startTs);
|
|
const bucket = buckets.get(key) || { startTs, endTs: startTs + bucketMs, laps: [], sessionIds: new Set() };
|
|
bucket.laps.push(lap);
|
|
if (lap.sessionId) bucket.sessionIds.add(lap.sessionId);
|
|
buckets.set(key, bucket);
|
|
});
|
|
const markers = getDriverTrainingMarkers(state, driverId, classId);
|
|
return [...buckets.values()]
|
|
.sort((left, right) => left.startTs - right.startTs)
|
|
.map((bucket) => {
|
|
const values = bucket.laps.map((lap) => lap.lapMs);
|
|
return {
|
|
startTs: bucket.startTs,
|
|
endTs: bucket.endTs,
|
|
lapCount: values.length,
|
|
paceMs: trimmedAverage(values),
|
|
medianMs: percentile(values, 0.5),
|
|
bestLapMs: values.length ? Math.min(...values) : 0,
|
|
sessionIds: [...bucket.sessionIds],
|
|
markers: markers.filter((marker) => marker.timestamp >= bucket.startTs && marker.timestamp < bucket.endTs),
|
|
};
|
|
});
|
|
}
|
|
|
|
export function buildTrainingWeekdayStats(state, driverId, classId = "") {
|
|
const groups = Array.from({ length: 7 }, (_, weekday) => ({ weekday, laps: [] }));
|
|
getDriverTrainingLaps(state, driverId, classId)
|
|
.filter((lap) => !lap.excludedFromPace)
|
|
.forEach((lap) => groups[new Date(lap.timestamp).getDay()].laps.push(lap.lapMs));
|
|
return groups.map((group) => ({
|
|
weekday: group.weekday,
|
|
lapCount: group.laps.length,
|
|
paceMs: trimmedAverage(group.laps),
|
|
bestLapMs: group.laps.length ? Math.min(...group.laps) : 0,
|
|
}));
|
|
}
|
|
|
|
export function buildTrainingMarkerComparisons(state, driverId, classId = "", windowMinutes = 30) {
|
|
const laps = getDriverTrainingLaps(state, driverId, classId).filter((lap) => !lap.excludedFromPace);
|
|
const windowMs = Math.max(5, Number(windowMinutes || 30)) * 60 * 1000;
|
|
return getDriverTrainingMarkers(state, driverId, classId).map((marker) => {
|
|
const comparableLaps = marker.sessionId ? laps.filter((lap) => lap.sessionId === marker.sessionId) : laps;
|
|
const before = comparableLaps.filter((lap) => lap.timestamp < marker.timestamp && lap.timestamp >= marker.timestamp - windowMs);
|
|
const after = comparableLaps.filter((lap) => lap.timestamp >= marker.timestamp && lap.timestamp < marker.timestamp + windowMs);
|
|
const beforePaceMs = before.length >= 3 ? trimmedAverage(before.map((lap) => lap.lapMs)) : 0;
|
|
const afterPaceMs = after.length >= 3 ? trimmedAverage(after.map((lap) => lap.lapMs)) : 0;
|
|
return {
|
|
...marker,
|
|
beforeLapCount: before.length,
|
|
afterLapCount: after.length,
|
|
beforePaceMs,
|
|
afterPaceMs,
|
|
improvementMs: beforePaceMs && afterPaceMs ? beforePaceMs - afterPaceMs : null,
|
|
};
|
|
});
|
|
}
|
|
|
|
function getBestConsecutiveAverage(laps, count) {
|
|
let best = 0;
|
|
for (let index = 0; index <= laps.length - count; index += 1) {
|
|
const candidate = average(laps.slice(index, index + count).map((lap) => lap.lapMs));
|
|
if (!best || candidate < best) best = candidate;
|
|
}
|
|
return best;
|
|
}
|
|
|
|
function getLongestControlledLapStreak(stints, controlTargetMs) {
|
|
let longest = 0;
|
|
(Array.isArray(stints) ? stints : []).forEach((stint) => {
|
|
let current = 0;
|
|
(Array.isArray(stint?.laps) ? stint.laps : []).forEach((lap) => {
|
|
if (lap.excludedFromPace || !controlTargetMs || Number(lap.lapMs || 0) > controlTargetMs) {
|
|
current = 0;
|
|
return;
|
|
}
|
|
current += 1;
|
|
longest = Math.max(longest, current);
|
|
});
|
|
});
|
|
return longest;
|
|
}
|
|
|
|
function getTrainingStintMetrics(stint) {
|
|
const laps = (Array.isArray(stint?.laps) ? stint.laps : []).filter((lap) => !lap.excludedFromPace);
|
|
const values = laps.map((lap) => Number(lap.lapMs || 0)).filter((lapMs) => lapMs > 500);
|
|
const medianMs = percentile(values, 0.5);
|
|
const outlierThresholdMs = medianMs ? medianMs * 1.15 : 0;
|
|
const outlierLaps = values.filter((lapMs) => outlierThresholdMs && lapMs > outlierThresholdMs).length;
|
|
const comparisonSize = values.length >= 6 ? Math.max(3, Math.floor(values.length / 3)) : 0;
|
|
const startPaceMs = comparisonSize ? trimmedAverage(values.slice(0, comparisonSize)) : 0;
|
|
const endPaceMs = comparisonSize ? trimmedAverage(values.slice(-comparisonSize)) : 0;
|
|
return {
|
|
laps,
|
|
values,
|
|
outlierLaps,
|
|
comparisonSize,
|
|
startPaceMs,
|
|
endPaceMs,
|
|
endChangeMs: startPaceMs && endPaceMs ? startPaceMs - endPaceMs : null,
|
|
strongFinish: Boolean(comparisonSize && endPaceMs <= startPaceMs * 1.01),
|
|
};
|
|
}
|
|
|
|
export function buildTrainingStintAnalysis(state, driverId, classId = "", { layout = "current", source = "practice" } = {}) {
|
|
// Scoped to one track layout (the active one unless another is chosen), same as
|
|
// buildDriverTrainingStats - a "best stint" spanning two tracks would not be comparable.
|
|
// Stints are a practice idea (breaks split a run into stints). A race is one fixed-time run,
|
|
// so race laps never form stints - see buildTrainingRaceSessions for those.
|
|
const stints = splitTrainingStints(practiceLapsOnly(getDriverTrainingLapsForLayout(state, driverId, classId, layout, source)));
|
|
const rows = stints.map((stint, index) => {
|
|
const { laps, values, outlierLaps, startPaceMs, endPaceMs, endChangeMs, strongFinish } = getTrainingStintMetrics(stint);
|
|
return {
|
|
id: `${stint.sessionId}:${stint.startedAt}:${index}`,
|
|
number: index + 1,
|
|
sessionId: stint.sessionId,
|
|
startedAt: stint.startedAt,
|
|
endedAt: stint.endedAt,
|
|
durationMs: stint.durationMs,
|
|
lapCount: values.length,
|
|
bestLapMs: values.length ? Math.min(...values) : 0,
|
|
paceMs: trimmedAverage(values),
|
|
racePace10Ms: values.length >= 10 ? getBestConsecutiveAverage(laps, 10) : 0,
|
|
fiveMinuteResult: getBestTrainingDurationResult([stint], 5 * 60 * 1000),
|
|
mistakes: outlierLaps,
|
|
mistakePct: values.length ? (outlierLaps / values.length) * 100 : 0,
|
|
consistencyPct: values.length >= 3 ? consistencySpread(values) : null,
|
|
startPaceMs,
|
|
endPaceMs,
|
|
endChangeMs,
|
|
strongFinish,
|
|
insufficient: values.length < 3,
|
|
};
|
|
});
|
|
const visibleRows = rows.filter((row) => row.lapCount > 0);
|
|
visibleRows.forEach((row, index) => { row.number = index + 1; });
|
|
const eligible = visibleRows.filter((row) => !row.insufficient);
|
|
const best = eligible.reduce((current, row) => (!current || row.paceMs < current.paceMs ? row : current), null);
|
|
return { rows: visibleRows.sort((left, right) => right.startedAt - left.startedAt), best };
|
|
}
|
|
|
|
export function buildTrainingAchievements(stats) {
|
|
const source = stats && typeof stats === "object" ? stats : {};
|
|
const definitions = [
|
|
["first_session", Number(source.totalSessions || 0), 1],
|
|
["laps_100", Number(source.totalLaps || 0), 100],
|
|
["laps_250", Number(source.totalLaps || 0), 250],
|
|
["laps_500", Number(source.totalLaps || 0), 500],
|
|
["laps_1000", Number(source.totalLaps || 0), 1000],
|
|
["laps_1500", Number(source.totalLaps || 0), 1500],
|
|
["sessions_5", Number(source.totalSessions || 0), 5],
|
|
["days_3", Number(source.trainingDays || 0), 3],
|
|
["days_10", Number(source.trainingDays || 0), 10],
|
|
["controlled_5", Number(source.controlledLapStreak || 0), 5],
|
|
["controlled_10", Number(source.controlledLapStreak || 0), 10],
|
|
["five_minute", source.bestFiveMinuteResult ? 1 : 0, 1],
|
|
["five_minutes_3", Number(source.completedFiveMinuteStints || 0), 3],
|
|
["consistency_5", source.recentLapCount >= 30 && source.consistencySpreadPct <= 5 ? 1 : 0, 1],
|
|
["strong_finish", Number(source.strongFinishStints || 0), 1],
|
|
["clean_five_minute", Number(source.cleanFiveMinuteStints || 0), 1],
|
|
["pace_gain", source.trendSampleReady && source.averageTrendMs > 0 ? 1 : 0, 1],
|
|
];
|
|
return definitions.map(([id, current, target]) => ({
|
|
id,
|
|
current: Math.max(0, current),
|
|
target,
|
|
percent: Math.min(100, Math.max(0, (current / target) * 100)),
|
|
unlocked: current >= target,
|
|
}));
|
|
}
|
|
|
|
function getLocalDayKey(timestamp) {
|
|
const date = new Date(Number(timestamp || 0));
|
|
if (Number.isNaN(date.getTime())) return "unknown";
|
|
const year = date.getFullYear();
|
|
const month = String(date.getMonth() + 1).padStart(2, "0");
|
|
const day = String(date.getDate()).padStart(2, "0");
|
|
return `${year}-${month}-${day}`;
|
|
}
|
|
|
|
function buildDailySummaries(laps) {
|
|
const byDay = new Map();
|
|
laps.forEach((lap) => {
|
|
const key = getLocalDayKey(lap.timestamp);
|
|
const current = byDay.get(key) || { dateKey: key, laps: 0, totalMs: 0, bestLapMs: 0, latestTimestamp: 0, raceLaps: 0, raceSessions: [] };
|
|
current.laps += 1;
|
|
if (lap.source === "race") {
|
|
current.raceLaps += 1;
|
|
const label = [lap.eventName, lap.sessionName].filter(Boolean).join(" · ");
|
|
if (label && !current.raceSessions.includes(label)) current.raceSessions.push(label);
|
|
}
|
|
current.totalMs += lap.lapMs;
|
|
current.bestLapMs = current.bestLapMs ? Math.min(current.bestLapMs, lap.lapMs) : lap.lapMs;
|
|
current.latestTimestamp = Math.max(current.latestTimestamp, lap.timestamp);
|
|
byDay.set(key, current);
|
|
});
|
|
return [...byDay.values()]
|
|
.map((day) => ({ ...day, averageLapMs: day.laps ? Math.round(day.totalMs / day.laps) : 0 }))
|
|
.sort((left, right) => right.latestTimestamp - left.latestTimestamp);
|
|
}
|
|
|
|
export function getControlledLapStreak(lapTimes, controlTargetMs) {
|
|
let streak = 0;
|
|
for (let index = lapTimes.length - 1; index >= 0; index -= 1) {
|
|
if (!controlTargetMs || lapTimes[index] > controlTargetMs) break;
|
|
streak += 1;
|
|
}
|
|
return streak;
|
|
}
|
|
|
|
export function splitTrainingStints(laps, breakThresholdMs = 2 * 60 * 1000) {
|
|
const normalized = (Array.isArray(laps) ? laps : [])
|
|
.filter((lap) => Number(lap?.lapMs || 0) > 500 && Number(lap?.timestamp || 0) > 0)
|
|
.map((lap) => ({
|
|
...lap,
|
|
sessionId: String(lap.sessionId || ""),
|
|
sourceId: String(lap.sourceId || lap.driverId || lap.competitorKey || lap.transponder || "default"),
|
|
timestamp: Number(lap.timestamp),
|
|
lapMs: Number(lap.lapMs),
|
|
}));
|
|
const streams = new Map();
|
|
|
|
normalized.forEach((lap) => {
|
|
const streamKey = `${lap.sessionId}:${lap.sourceId}`;
|
|
if (!streams.has(streamKey)) streams.set(streamKey, []);
|
|
streams.get(streamKey).push(lap);
|
|
});
|
|
|
|
const stints = [];
|
|
streams.forEach((streamLaps) => {
|
|
const sorted = streamLaps.sort((left, right) => left.timestamp - right.timestamp);
|
|
let currentStint = null;
|
|
|
|
sorted.forEach((lap) => {
|
|
const previousLap = currentStint?.laps.at(-1);
|
|
const lapStartedAt = Math.max(0, lap.timestamp - lap.lapMs);
|
|
const breakMs = previousLap ? Math.max(0, lap.timestamp - previousLap.timestamp) : 0;
|
|
const detectedBreak = Boolean(previousLap && breakMs > breakThresholdMs);
|
|
const explicitBoundary = Boolean(lap.stintBoundary);
|
|
const startsNewStint = !currentStint || detectedBreak || explicitBoundary;
|
|
const normalizedLap = {
|
|
...lap,
|
|
excludedFromPace: Boolean(lap.excludedFromPace || explicitBoundary || (detectedBreak && lap.lapMs > breakThresholdMs)),
|
|
stintBoundary: Boolean(explicitBoundary || detectedBreak),
|
|
};
|
|
|
|
if (startsNewStint) {
|
|
const boundaryLap = Boolean(normalizedLap.excludedFromPace && (explicitBoundary || detectedBreak));
|
|
currentStint = {
|
|
sessionId: lap.sessionId,
|
|
sourceId: lap.sourceId,
|
|
startedAt: boundaryLap ? lap.timestamp : lapStartedAt,
|
|
endedAt: lap.timestamp,
|
|
durationMs: boundaryLap ? 0 : lap.lapMs,
|
|
laps: [normalizedLap],
|
|
};
|
|
stints.push(currentStint);
|
|
return;
|
|
}
|
|
|
|
currentStint.laps.push(normalizedLap);
|
|
currentStint.endedAt = lap.timestamp;
|
|
currentStint.durationMs = Math.max(0, currentStint.endedAt - currentStint.startedAt);
|
|
});
|
|
});
|
|
|
|
return stints.sort((left, right) => left.startedAt - right.startedAt);
|
|
}
|
|
|
|
export function getBestConsecutiveTrainingLaps(stints, lapCount = 3) {
|
|
const count = Math.max(1, Math.round(Number(lapCount || 1) || 1));
|
|
let best = null;
|
|
(Array.isArray(stints) ? stints : []).forEach((stint) => {
|
|
const paceLaps = stint.laps.filter((lap) => !lap.excludedFromPace);
|
|
for (let index = 0; index <= paceLaps.length - count; index += 1) {
|
|
const laps = paceLaps.slice(index, index + count);
|
|
const totalMs = laps.reduce((sum, lap) => sum + lap.lapMs, 0);
|
|
const candidate = {
|
|
lapCount: count,
|
|
totalMs,
|
|
averageLapMs: Math.round(totalMs / count),
|
|
startedAt: Math.max(0, laps[0].timestamp - laps[0].lapMs),
|
|
endedAt: laps.at(-1).timestamp,
|
|
sessionId: String(stint.sessionId || ""),
|
|
};
|
|
if (!best || candidate.totalMs < best.totalMs) best = candidate;
|
|
}
|
|
});
|
|
return best;
|
|
}
|
|
|
|
export function getBestTrainingDurationResult(stints, targetMs = 5 * 60 * 1000) {
|
|
const target = Math.max(1, Math.round(Number(targetMs || 0) || 0));
|
|
let best = null;
|
|
|
|
(Array.isArray(stints) ? stints : []).forEach((stint) => {
|
|
const paceLaps = stint.laps.filter((lap) => !lap.excludedFromPace);
|
|
for (let startIndex = 0; startIndex < paceLaps.length; startIndex += 1) {
|
|
const firstLap = paceLaps[startIndex];
|
|
const startedAt = Math.max(0, firstLap.timestamp - firstLap.lapMs);
|
|
const cutoffAt = startedAt + target;
|
|
const counted = [];
|
|
|
|
for (let index = startIndex; index < paceLaps.length; index += 1) {
|
|
const lap = paceLaps[index];
|
|
const lapStartedAt = Math.max(0, lap.timestamp - lap.lapMs);
|
|
if (lapStartedAt >= cutoffAt) break;
|
|
counted.push(lap);
|
|
}
|
|
|
|
const lastLap = counted.at(-1);
|
|
if (!lastLap || lastLap.timestamp < cutoffAt) continue;
|
|
const totalMs = Math.max(0, lastLap.timestamp - startedAt);
|
|
if (totalMs > target + lastLap.lapMs) continue;
|
|
const lapCount = counted.length;
|
|
const candidate = {
|
|
targetMs: target,
|
|
lapCount,
|
|
totalMs,
|
|
averageLapMs: lapCount ? Math.round(counted.reduce((sum, lap) => sum + lap.lapMs, 0) / lapCount) : 0,
|
|
startedAt,
|
|
endedAt: lastLap.timestamp,
|
|
sessionId: String(stint.sessionId || ""),
|
|
};
|
|
if (!best || candidate.lapCount > best.lapCount || (candidate.lapCount === best.lapCount && candidate.totalMs < best.totalMs)) {
|
|
best = candidate;
|
|
}
|
|
}
|
|
});
|
|
|
|
return best;
|
|
}
|
|
|
|
export function buildDriverTrainingStats(state, driverId, classId = "", { layout = "current", source = "practice" } = {}) {
|
|
// Lifetime commitment stats (how much a driver has trained, ever) read the full lap
|
|
// history - a track rebuild doesn't erase past practice. Every pace/record/consistency
|
|
// stat below instead reads layoutLaps, scoped to whichever track layout is active right
|
|
// now, so a lap from a track that no longer exists can't be reported as today's "record"
|
|
// or blend into today's consistency numbers. The `layout` option picks another layout,
|
|
// or "all" for the overall view - see getDriverTrainingLapsForLayout.
|
|
const laps = getDriverTrainingLaps(state, driverId, classId, { source });
|
|
const layoutLaps = getDriverTrainingLapsForLayout(state, driverId, classId, layout, source);
|
|
const historyPaceLaps = laps.filter((lap) => !lap.excludedFromPace);
|
|
const paceLaps = layoutLaps.filter((lap) => !lap.excludedFromPace);
|
|
const lapTimes = paceLaps.map((lap) => lap.lapMs);
|
|
const recentLapTimes = lapTimes.slice(-30);
|
|
const previousWindowLapTimes = lapTimes.slice(Math.max(0, lapTimes.length - 60), Math.max(0, lapTimes.length - 30));
|
|
const earlierLapTimes = lapTimes.slice(0, Math.max(0, lapTimes.length - recentLapTimes.length));
|
|
const totalLaps = laps.length;
|
|
const bestLapMs = lapTimes.length ? Math.min(...lapTimes) : 0;
|
|
const averageLapMs = average(lapTimes);
|
|
const recentAverageMs = average(recentLapTimes);
|
|
const previousRecentAverageMs = average(previousWindowLapTimes);
|
|
const consistencySpreadPct = consistencySpread(recentLapTimes);
|
|
const previousConsistencySpreadPct = consistencySpread(previousWindowLapTimes);
|
|
const trendSampleReady = recentLapTimes.length >= 10 && previousWindowLapTimes.length >= 10;
|
|
const previousBestMs = earlierLapTimes.length ? Math.min(...earlierLapTimes) : 0;
|
|
const recentBestMs = recentLapTimes.length ? Math.min(...recentLapTimes) : 0;
|
|
const personalBestGainMs = previousBestMs && recentBestMs ? Math.max(0, previousBestMs - recentBestMs) : 0;
|
|
const controlZoneMinMs = bestLapMs;
|
|
const controlTargetMs = bestLapMs ? Math.round(bestLapMs * 1.08) : 0;
|
|
const dailySummaries = buildDailySummaries(historyPaceLaps);
|
|
const stints = splitTrainingStints(practiceLapsOnly(layoutLaps));
|
|
const stintMetrics = stints.map((stint) => ({ stint, ...getTrainingStintMetrics(stint) }));
|
|
const controlledLapStreak = getLongestControlledLapStreak(stints, controlTargetMs);
|
|
const completedFiveMinuteStints = stints.filter((stint) => getBestTrainingDurationResult([stint], 5 * 60 * 1000)).length;
|
|
const cleanFiveMinuteStints = stintMetrics.filter(({ stint, outlierLaps }) => !outlierLaps && getBestTrainingDurationResult([stint], 5 * 60 * 1000)).length;
|
|
const strongFinishStints = stintMetrics.filter((metrics) => metrics.strongFinish).length;
|
|
const outlierLaps = stintMetrics.reduce((sum, metrics) => sum + metrics.outlierLaps, 0);
|
|
const bestThreeConsecutive = getBestConsecutiveTrainingLaps(stints, 3);
|
|
const bestFiveMinuteResult = getBestTrainingDurationResult(stints, 5 * 60 * 1000);
|
|
const todayKey = getLocalDayKey(Date.now());
|
|
const todayLaps = layoutLaps.filter((lap) => getLocalDayKey(lap.timestamp) === todayKey);
|
|
const todayStints = splitTrainingStints(practiceLapsOnly(todayLaps));
|
|
const todayStintMetrics = todayStints.map((stint) => ({ stint, ...getTrainingStintMetrics(stint) }));
|
|
const todayLapTimes = todayLaps.filter((lap) => !lap.excludedFromPace).map((lap) => lap.lapMs);
|
|
|
|
const stats = {
|
|
totalLaps,
|
|
totalSessions: new Set(laps.map((lap) => lap.sessionId)).size,
|
|
trainingDays: dailySummaries.length,
|
|
bestLapMs,
|
|
averageLapMs,
|
|
recentAverageMs,
|
|
previousRecentAverageMs,
|
|
averageTrendMs: trendSampleReady ? previousRecentAverageMs - recentAverageMs : 0,
|
|
recentBestMs,
|
|
previousBestMs,
|
|
personalBestGainMs,
|
|
controlZoneMinMs,
|
|
controlZoneMaxMs: controlTargetMs,
|
|
controlledLapStreak,
|
|
outlierLaps,
|
|
strongFinishStints,
|
|
cleanFiveMinuteStints,
|
|
todayLaps: todayLaps.length,
|
|
todayBestLapMs: todayLapTimes.length ? Math.min(...todayLapTimes) : 0,
|
|
todayAverageLapMs: average(todayLapTimes),
|
|
todayControlledLapStreak: getLongestControlledLapStreak(todayStints, controlTargetMs),
|
|
todayOutlierLaps: todayStintMetrics.reduce((sum, metrics) => sum + metrics.outlierLaps, 0),
|
|
todayStrongFinishStints: todayStintMetrics.filter((metrics) => metrics.strongFinish).length,
|
|
todayCompletedFiveMinuteStints: todayStints.filter((stint) => getBestTrainingDurationResult([stint], 5 * 60 * 1000)).length,
|
|
todayCleanFiveMinuteStints: todayStintMetrics.filter(({ stint, outlierLaps: count }) => !count && getBestTrainingDurationResult([stint], 5 * 60 * 1000)).length,
|
|
consistencySpreadPct,
|
|
previousConsistencySpreadPct,
|
|
consistencyTrendPct: trendSampleReady ? previousConsistencySpreadPct - consistencySpreadPct : 0,
|
|
trendSampleReady,
|
|
recentLapCount: recentLapTimes.length,
|
|
lastLapAt: laps.at(-1)?.timestamp || 0,
|
|
dailySummaries,
|
|
stintCount: stints.length,
|
|
completedFiveMinuteStints,
|
|
bestThreeConsecutive,
|
|
bestFiveMinuteResult,
|
|
};
|
|
return { ...stats, achievements: buildTrainingAchievements(stats) };
|
|
}
|
|
|
|
export function buildDriverTimingChannelStats(state, driverId, classId = "") {
|
|
const profileReferences = getTrainingDriverIds(state, driverId, classId);
|
|
const sessions = new Map((Array.isArray(state?.sessions) ? state.sessions : []).map((session) => [String(session.id || ""), session]));
|
|
const events = new Map((Array.isArray(state?.events) ? state.events : []).map((event) => [String(event.id || ""), event]));
|
|
const splits = [];
|
|
const pitStops = [];
|
|
|
|
Object.entries(state?.resultsBySession || {}).forEach(([sessionId, result]) => {
|
|
const session = sessions.get(String(sessionId));
|
|
const event = session ? events.get(String(session.eventId || "")) : null;
|
|
(Array.isArray(result?.splits) ? result.splits : []).forEach((split) => {
|
|
if (!profileReferences.has(String(split?.driverId || "")) || Number(split?.splitMs || 0) <= 0) return;
|
|
splits.push({
|
|
...split,
|
|
sessionId: String(sessionId),
|
|
sessionName: String(session?.name || ""),
|
|
eventName: String(event?.name || ""),
|
|
splitMs: Math.round(Number(split.splitMs)),
|
|
});
|
|
});
|
|
(Array.isArray(result?.pitStops) ? result.pitStops : []).forEach((stop) => {
|
|
if (!profileReferences.has(String(stop?.driverId || "")) || Number(stop?.pitStopMs || 0) <= 0) return;
|
|
pitStops.push({
|
|
...stop,
|
|
sessionId: String(sessionId),
|
|
sessionName: String(session?.name || ""),
|
|
eventName: String(event?.name || ""),
|
|
pitStopMs: Math.round(Number(stop.pitStopMs)),
|
|
});
|
|
});
|
|
});
|
|
|
|
splits.sort((left, right) => Number(left.timestamp || 0) - Number(right.timestamp || 0));
|
|
pitStops.sort((left, right) => Number(left.enteredAt || 0) - Number(right.enteredAt || 0));
|
|
const splitTimes = splits.map((split) => split.splitMs);
|
|
const pitTimes = pitStops.map((stop) => stop.pitStopMs);
|
|
let runningBestSplitMs = 0;
|
|
let latestSplitGainMs = 0;
|
|
let latestSplitGainAt = 0;
|
|
splits.forEach((split) => {
|
|
if (runningBestSplitMs && split.splitMs < runningBestSplitMs) {
|
|
latestSplitGainMs = runningBestSplitMs - split.splitMs;
|
|
latestSplitGainAt = Number(split.timestamp || 0);
|
|
}
|
|
if (!runningBestSplitMs || split.splitMs < runningBestSplitMs) runningBestSplitMs = split.splitMs;
|
|
});
|
|
return {
|
|
splitCount: splits.length,
|
|
splitSessions: new Set(splits.map((split) => split.sessionId)).size,
|
|
bestSplitMs: splitTimes.length ? Math.min(...splitTimes) : 0,
|
|
averageSplitMs: splitTimes.length ? Math.round(splitTimes.reduce((sum, value) => sum + value, 0) / splitTimes.length) : 0,
|
|
lastSplitMs: splitTimes.at(-1) || 0,
|
|
latestSplitGainMs,
|
|
latestSplitGainAt,
|
|
pitStopCount: pitStops.length,
|
|
pitSessions: new Set(pitStops.map((stop) => stop.sessionId)).size,
|
|
totalPitMs: pitTimes.reduce((sum, value) => sum + value, 0),
|
|
averagePitStopMs: pitTimes.length ? Math.round(pitTimes.reduce((sum, value) => sum + value, 0) / pitTimes.length) : 0,
|
|
bestPitStopMs: pitTimes.length ? Math.min(...pitTimes) : 0,
|
|
longestPitStopMs: pitTimes.length ? Math.max(...pitTimes) : 0,
|
|
recentPitStops: pitStops.slice(-10).reverse(),
|
|
};
|
|
}
|
|
|
|
function getActivePracticeLaps(state, driverId, classId) {
|
|
const session = (Array.isArray(state?.sessions) ? state.sessions : [])
|
|
.find((item) => String(item?.id || "") === String(state?.activeSessionId || ""));
|
|
const practiceTypes = new Set(["open_practice", "free_practice", "practice"]);
|
|
if (!session || session.status !== "running" || !practiceTypes.has(String(session.type || "").toLowerCase())) return null;
|
|
|
|
const result = state?.resultsBySession?.[session.id];
|
|
const startedAt = Math.max(0, Number(session.startedAt || 0) || 0);
|
|
const profileReferences = getTrainingDriverIds(state, driverId, classId);
|
|
const laps = (Array.isArray(result?.passings) ? result.passings : [])
|
|
.filter((passing) => (
|
|
profileReferences.has(String(passing?.driverId || ""))
|
|
&& passing?.validLap !== false
|
|
&& Number(passing?.lapMs || 0) > 500
|
|
&& (!startedAt || Number(passing?.timestamp || 0) >= startedAt)
|
|
))
|
|
.map((passing) => ({
|
|
sessionId: String(session.id || ""),
|
|
sourceId: String(passing.competitorKey || passing.carId || passing.transponder || passing.driverId || "default"),
|
|
timestamp: Math.max(0, Number(passing.timestamp || 0) || 0),
|
|
lapMs: Math.round(Number(passing.lapMs || 0) || 0),
|
|
excludedFromPace: Boolean(passing.excludedFromPace || passing.validationWarning === "above_max_stint"),
|
|
stintBoundary: Boolean(passing.stintBoundary || passing.validationWarning === "above_max_stint"),
|
|
}))
|
|
.sort((left, right) => left.timestamp - right.timestamp);
|
|
return { session, startedAt, laps };
|
|
}
|
|
|
|
export function buildDriverActivePracticeStats(state, driverId, nowTs = Date.now(), classId = "") {
|
|
const active = getActivePracticeLaps(state, driverId, classId);
|
|
if (!active) return null;
|
|
const { session, startedAt, laps } = active;
|
|
const paceLapTimes = laps.filter((lap) => !lap.excludedFromPace).map((lap) => lap.lapMs);
|
|
const bestLapMs = paceLapTimes.length ? Math.min(...paceLapTimes) : 0;
|
|
const controlZoneMaxMs = bestLapMs ? Math.round(bestLapMs * 1.08) : 0;
|
|
const activeStints = splitTrainingStints(laps);
|
|
|
|
return {
|
|
sessionId: String(session.id || ""),
|
|
sessionName: String(session.name || "").trim(),
|
|
startedAt,
|
|
elapsedMs: startedAt ? Math.max(0, Number(nowTs || 0) - startedAt) : 0,
|
|
laps: laps.length,
|
|
bestLapMs,
|
|
averageLapMs: average(paceLapTimes),
|
|
lastLapMs: laps.at(-1)?.lapMs || 0,
|
|
controlZoneMinMs: bestLapMs,
|
|
controlZoneMaxMs,
|
|
controlledLapStreak: getLongestControlledLapStreak(activeStints, controlZoneMaxMs),
|
|
};
|
|
}
|
|
|
|
// "Jämna varv" (even laps): a driver-configured target lap time and tolerance, run live
|
|
// inside an already-active Open Practice session. Tolerance is +/- around the target lap
|
|
// time (not the spread between the streak's fastest and slowest lap) - decided because
|
|
// it's simpler to understand and to show live, and matches how a beginner already thinks
|
|
// about "hit the target". A lap outside tolerance, or one excluded from pace (pit/reset),
|
|
// ends the current streak but never erases the best streak already reached today.
|
|
export function buildEvenLapsProgress(state, driverId, classId, config, nowTs = Date.now()) {
|
|
const targetMs = Math.round(Number(config?.targetMs || 0));
|
|
const toleranceMs = Math.round(Number(config?.toleranceMs || 0));
|
|
const lapCount = Math.max(1, Math.round(Number(config?.lapCount || 0) || 0));
|
|
if (!(targetMs > 0) || !(toleranceMs >= 0)) return null;
|
|
|
|
const withinTolerance = (lapMs) => Math.abs(lapMs - targetMs) <= toleranceMs;
|
|
const longestStreak = (lapTimes) => {
|
|
let longest = 0;
|
|
let current = 0;
|
|
for (const lap of lapTimes) {
|
|
if (!lap.excludedFromPace && withinTolerance(lap.lapMs)) {
|
|
current += 1;
|
|
longest = Math.max(longest, current);
|
|
} else {
|
|
current = 0;
|
|
}
|
|
}
|
|
return longest;
|
|
};
|
|
|
|
const active = getActivePracticeLaps(state, driverId, classId);
|
|
const liveLaps = active?.laps || [];
|
|
let currentStreak = 0;
|
|
for (let index = liveLaps.length - 1; index >= 0; index -= 1) {
|
|
if (!liveLaps[index].excludedFromPace && withinTolerance(liveLaps[index].lapMs)) currentStreak += 1;
|
|
else break;
|
|
}
|
|
|
|
const dayStart = new Date(nowTs);
|
|
dayStart.setHours(0, 0, 0, 0);
|
|
const profileReferences = getTrainingDriverIds(state, driverId, classId);
|
|
const ledgerToday = (Array.isArray(state?.training?.ledger) ? state.training.ledger : [])
|
|
.filter((entry) => profileReferences.has(String(entry?.driverId || "")) && Number(entry?.timestamp || 0) >= dayStart.getTime())
|
|
.map((entry) => ({ timestamp: Number(entry.timestamp || 0), lapMs: Number(entry.lapMs || 0), excludedFromPace: Boolean(entry.excludedFromPace) }));
|
|
const seen = new Set();
|
|
const todayLaps = [...ledgerToday, ...liveLaps]
|
|
.sort((left, right) => left.timestamp - right.timestamp)
|
|
.filter((lap) => {
|
|
const key = `${lap.timestamp}:${lap.lapMs}`;
|
|
if (seen.has(key)) return false;
|
|
seen.add(key);
|
|
return true;
|
|
});
|
|
const bestStreakToday = Math.max(longestStreak(todayLaps), currentStreak);
|
|
const lastLap = liveLaps.at(-1) || null;
|
|
|
|
return {
|
|
active: Boolean(active),
|
|
targetMs,
|
|
toleranceMs,
|
|
lapCount,
|
|
currentStreak,
|
|
bestStreakToday,
|
|
lastLapMs: lastLap?.lapMs ?? null,
|
|
lastLapWithinTolerance: lastLap ? !lastLap.excludedFromPace && withinTolerance(lastLap.lapMs) : null,
|
|
};
|
|
}
|
|
|
|
const STEP_TRAINING_EFFORTS = ["calm", "controlled", "fast"];
|
|
|
|
// "Stegträning" (step training): a driver-configured sequence of steps (lap count plus a
|
|
// perceived-effort instruction - calm/controlled/fast), run live inside an already-active
|
|
// Open Practice session. Effort is guidance shown to the driver, never an enforced lap-time
|
|
// target: there is no reliable way to measure how hard a driver is actually pushing. When
|
|
// the config repeats "controlled" (the classic calm/controlled/fast/controlled/calm shape),
|
|
// the first and last controlled steps are compared afterward as a neutral pace difference,
|
|
// never automatically labeled as fatigue.
|
|
export function buildStepTrainingProgress(state, driverId, classId, config, nowTs = Date.now()) {
|
|
const steps = Array.isArray(config?.steps)
|
|
? config.steps
|
|
.map((step) => ({
|
|
effort: STEP_TRAINING_EFFORTS.includes(String(step?.effort || "")) ? String(step.effort) : "calm",
|
|
lapCount: Math.max(0, Math.round(Number(step?.lapCount || 0) || 0)),
|
|
}))
|
|
.filter((step) => step.lapCount > 0)
|
|
: [];
|
|
if (!steps.length) return null;
|
|
|
|
const active = getActivePracticeLaps(state, driverId, classId);
|
|
const liveLaps = active?.laps || [];
|
|
const totalLaps = steps.reduce((sum, step) => sum + step.lapCount, 0);
|
|
|
|
let cursor = 0;
|
|
const stepStates = steps.map((step, index) => {
|
|
const stepLaps = liveLaps.slice(cursor, cursor + step.lapCount);
|
|
cursor += step.lapCount;
|
|
const paceValues = stepLaps.filter((lap) => !lap.excludedFromPace).map((lap) => lap.lapMs);
|
|
return {
|
|
index,
|
|
effort: step.effort,
|
|
lapCount: step.lapCount,
|
|
lapsCompleted: stepLaps.length,
|
|
done: stepLaps.length >= step.lapCount,
|
|
averageLapMs: paceValues.length ? Math.round(paceValues.reduce((sum, value) => sum + value, 0) / paceValues.length) : null,
|
|
};
|
|
});
|
|
|
|
const complete = liveLaps.length >= totalLaps;
|
|
const currentStepIndex = complete ? steps.length - 1 : stepStates.findIndex((step) => !step.done);
|
|
const currentStepState = stepStates[currentStepIndex] || null;
|
|
|
|
const controlledSteps = stepStates.filter((step) => step.effort === "controlled" && step.averageLapMs != null);
|
|
const controlledComparison = controlledSteps.length >= 2
|
|
? {
|
|
firstAvgMs: controlledSteps[0].averageLapMs,
|
|
lastAvgMs: controlledSteps.at(-1).averageLapMs,
|
|
diffMs: controlledSteps.at(-1).averageLapMs - controlledSteps[0].averageLapMs,
|
|
}
|
|
: null;
|
|
|
|
return {
|
|
active: Boolean(active),
|
|
totalSteps: steps.length,
|
|
totalLaps,
|
|
completedLaps: Math.min(liveLaps.length, totalLaps),
|
|
complete,
|
|
currentStepIndex,
|
|
currentStep: currentStepState && {
|
|
index: currentStepState.index,
|
|
effort: currentStepState.effort,
|
|
lapCount: currentStepState.lapCount,
|
|
lapsCompleted: currentStepState.lapsCompleted,
|
|
lapsRemaining: Math.max(0, currentStepState.lapCount - currentStepState.lapsCompleted),
|
|
},
|
|
steps: stepStates,
|
|
controlledComparison,
|
|
};
|
|
}
|
|
|
|
export function buildTrainingRecommendation(stats) {
|
|
if (!stats || stats.totalLaps < 10) {
|
|
return {
|
|
level: "baseline",
|
|
titleKey: "training.plan_baseline_title",
|
|
bodyKey: "training.plan_baseline_body",
|
|
targetLapMs: 0,
|
|
};
|
|
}
|
|
|
|
if (stats.recentLapCount >= 10 && stats.consistencySpreadPct > 8) {
|
|
return {
|
|
level: "consistency",
|
|
titleKey: "training.plan_consistency_title",
|
|
bodyKey: "training.plan_consistency_body",
|
|
targetLapMs: Math.round(stats.bestLapMs * 1.08),
|
|
};
|
|
}
|
|
|
|
return {
|
|
level: "progression",
|
|
titleKey: "training.plan_progression_title",
|
|
bodyKey: "training.plan_progression_body",
|
|
targetLapMs: Math.round(stats.bestLapMs * 1.05),
|
|
};
|
|
}
|
|
|
|
// Goals and the club goal share this same {currentLaps, targetLaps, ...} shape whether they
|
|
// track laps or completed guided-exercise sessions, so every existing progress-bar/reward
|
|
// renderer keeps working unchanged - callers branch on goal.metric only to pick the right
|
|
// label ("laps" vs "sessions"), never to reshape this result.
|
|
export function countExerciseSessions(exerciseSessions, { driverId = "", classId = "", kind = "" } = {}) {
|
|
return (Array.isArray(exerciseSessions) ? exerciseSessions : []).filter((entry) =>
|
|
(!driverId || entry.driverId === driverId) &&
|
|
(!classId || entry.classId === classId) &&
|
|
(!kind || entry.kind === kind)
|
|
).length;
|
|
}
|
|
|
|
// Admin goals store driverId as the *profile* id (see the "training-goal-form" submit handler
|
|
// in training_views.js), the same value buildDriverTrainingStats resolves through
|
|
// getTrainingDriverIds - but exerciseSessions store the specific per-class driver row id
|
|
// (whichever the mobile link's completion request resolved to), the same as ledger entries do.
|
|
// This bridges the two the same way buildDriverTrainingStats already does for laps.
|
|
export function countDriverExerciseSessions(state, driverId, classId, kind) {
|
|
const driverIds = getTrainingDriverIds(state, driverId, classId);
|
|
return (Array.isArray(state?.training?.exerciseSessions) ? state.training.exerciseSessions : [])
|
|
.filter((entry) => driverIds.has(String(entry?.driverId || "")) && String(entry?.classId || "") === String(classId || "") && entry?.kind === kind)
|
|
.length;
|
|
}
|
|
|
|
export function getTrainingGoalProgress(goal, stats, exerciseSessionCount = 0) {
|
|
if (goal?.metric === "sessions") {
|
|
const targetSessions = Math.max(1, Number(goal?.targetSessions || 1));
|
|
const currentSessions = Math.max(0, Number(exerciseSessionCount || 0));
|
|
return {
|
|
currentLaps: currentSessions,
|
|
targetLaps: targetSessions,
|
|
remainingLaps: Math.max(0, targetSessions - currentSessions),
|
|
percent: Math.min(100, Math.max(0, (currentSessions / targetSessions) * 100)),
|
|
reached: currentSessions >= targetSessions,
|
|
};
|
|
}
|
|
const targetLaps = Math.max(1, Number(goal?.targetLaps || 1));
|
|
const currentLaps = Math.max(0, Number(stats?.totalLaps || 0));
|
|
return {
|
|
currentLaps,
|
|
targetLaps,
|
|
remainingLaps: Math.max(0, targetLaps - currentLaps),
|
|
percent: Math.min(100, Math.max(0, (currentLaps / targetLaps) * 100)),
|
|
reached: currentLaps >= targetLaps,
|
|
};
|
|
}
|
|
|
|
export function getNextTrainingMilestone(stats) {
|
|
const currentLaps = Math.max(0, Number(stats?.totalLaps || 0));
|
|
const presets = [100, 250, 500, 1000, 1500, 2500, 5000];
|
|
const targetLaps = presets.find((target) => target > currentLaps) || (Math.floor(currentLaps / 1000) + 1) * 1000;
|
|
return getTrainingGoalProgress({ targetLaps }, stats);
|
|
}
|
|
|
|
export function buildTrainingMissions(stats) {
|
|
const source = stats && typeof stats === "object" ? stats : {};
|
|
const definitions = [
|
|
["laps_today", Number(source.todayLaps || 0), 20],
|
|
["controlled_today", Number(source.todayControlledLapStreak || 0), 5],
|
|
["five_minute_today", Number(source.todayCompletedFiveMinuteStints || 0), 1],
|
|
];
|
|
return definitions.map(([id, current, target]) => ({
|
|
id,
|
|
current: Math.max(0, current),
|
|
target,
|
|
percent: Math.min(100, Math.max(0, (current / target) * 100)),
|
|
completed: current >= target,
|
|
}));
|
|
}
|
|
|
|
export function buildTrainingHighlights(stats) {
|
|
const source = stats && typeof stats === "object" ? stats : {};
|
|
const highlights = [];
|
|
if (source.todayLaps > 0) highlights.push({ id: "today_laps", value: Number(source.todayLaps) });
|
|
if (source.personalBestGainMs > 0) highlights.push({ id: "personal_best", value: Number(source.personalBestGainMs) });
|
|
if (source.latestSplitGainMs > 0) highlights.push({ id: "sector_gain", value: Number(source.latestSplitGainMs) });
|
|
if (source.todayStrongFinishStints > 0) highlights.push({ id: "strong_finish", value: Number(source.todayStrongFinishStints) });
|
|
if (source.todayCleanFiveMinuteStints > 0) highlights.push({ id: "clean_five_minute", value: Number(source.todayCleanFiveMinuteStints) });
|
|
if (source.trendSampleReady && source.averageTrendMs > 0) highlights.push({ id: "pace_gain", value: Number(source.averageTrendMs) });
|
|
if (source.trendSampleReady && source.consistencyTrendPct > 0.1) highlights.push({ id: "consistency_gain", value: Number(source.consistencyTrendPct) });
|
|
if (source.todayControlledLapStreak >= 5) highlights.push({ id: "controlled_streak", value: Number(source.todayControlledLapStreak) });
|
|
if (source.todayCompletedFiveMinuteStints > 0) highlights.push({ id: "five_minute", value: Number(source.todayCompletedFiveMinuteStints) });
|
|
if (!highlights.length && source.totalLaps > 0) highlights.push({ id: "keep_building", value: Number(source.totalLaps) });
|
|
if (!highlights.length) highlights.push({ id: "ready", value: 0 });
|
|
return highlights.slice(0, 3);
|
|
}
|
|
|
|
export function getClubTrainingGoalProgress(training) {
|
|
const goal = training?.clubGoal && typeof training.clubGoal === "object" ? training.clubGoal : null;
|
|
if (!goal) return null;
|
|
if (goal.metric === "sessions") {
|
|
if (!(Number(goal.targetSessions || 0) > 0) || !goal.exerciseKind) return null;
|
|
const totalSessions = countExerciseSessions(training?.exerciseSessions, { kind: goal.exerciseKind });
|
|
const currentSessions = Math.max(0, totalSessions - Math.max(0, Number(goal.baselineSessions || 0)));
|
|
const targetSessions = Math.max(1, Number(goal.targetSessions || 1));
|
|
return {
|
|
currentLaps: currentSessions,
|
|
targetLaps: targetSessions,
|
|
remainingLaps: Math.max(0, targetSessions - currentSessions),
|
|
percent: Math.min(100, Math.max(0, (currentSessions / targetSessions) * 100)),
|
|
reached: currentSessions >= targetSessions,
|
|
};
|
|
}
|
|
if (!(Number(goal.targetLaps || 0) > 0)) return null;
|
|
const totalLaps = Array.isArray(training?.ledger) ? training.ledger.length : 0;
|
|
const currentLaps = Math.max(0, totalLaps - Math.max(0, Number(goal.baselineLaps || 0)));
|
|
const targetLaps = Math.max(1, Number(goal.targetLaps || 1));
|
|
return {
|
|
currentLaps,
|
|
targetLaps,
|
|
remainingLaps: Math.max(0, targetLaps - currentLaps),
|
|
percent: Math.min(100, Math.max(0, (currentLaps / targetLaps) * 100)),
|
|
reached: currentLaps >= targetLaps,
|
|
};
|
|
}
|