@jjlmoya/utils-drones 1.39.0 → 1.41.0

package/src/tool/fpv-drone-lap-timer/controller.ts

@@ -0,0 +1,304 @@
+import {
+  calculateSessionMetrics,
+  computeLapRecords,
+  formatLapTime,
+  isDebounceLocked,
+  PRESETS,
+  type SessionConfig,
+} from './logic';
+import { loadSessionConfig, saveSessionConfig, loadSessionLaps, saveSessionLaps } from './storage';
+import { RaceAudioSynthesizer } from './audio';
+import { renderTelemetryScene, renderLapTable } from './dom-views';
+import { exportSessionCsv, copySessionSummary } from './export';
+import type { FpvDroneLapTimerUI } from './ui';
+
+export class LapTimerSession {
+  private config: SessionConfig;
+  private audio: RaceAudioSynthesizer;
+  private status: 'idle' | 'countdown' | 'running' | 'paused' | 'finished' = 'idle';
+  private lapDurationsMs: number[] = [];
+  private lapStartTime = 0;
+  private lastRecordedTimestamp = 0;
+  private animFrameId: number | null = null;
+  private currentLapNumber = 1;
+
+  constructor(private root: HTMLElement, private ui: FpvDroneLapTimerUI) {
+    this.config = loadSessionConfig();
+    this.lapDurationsMs = loadSessionLaps();
+    this.currentLapNumber = Math.max(1, this.lapDurationsMs.length + 1);
+    this.audio = new RaceAudioSynthesizer(this.config.soundEnabled);
+    this.bindEvents();
+    this.syncInputs();
+    this.updateViews();
+    if (this.lapDurationsMs.length > 0) {
+      const display = this.query<HTMLElement>('.fpv-lap-timer-digits');
+      if (display) {
+        const lastLap = this.lapDurationsMs[this.lapDurationsMs.length - 1];
+        if (lastLap !== undefined) {
+          display.textContent = formatLapTime(lastLap);
+        }
+      }
+    }
+  }
+
+  private query<T extends HTMLElement>(selector: string): T | null {
+    return this.root.querySelector<T>(selector);
+  }
+
+  private syncInputs(): void {
+    const fields: [string, number][] = [
+      ['#fpv-lap-timer-track-length', this.config.trackLengthM],
+      ['#fpv-lap-timer-target-laps', this.config.targetLaps],
+      ['#fpv-lap-timer-battery', this.config.batteryCapacityMah],
+      ['#fpv-lap-timer-debounce', this.config.debounceMs / 1000],
+    ];
+    fields.forEach(([id, val]) => {
+      const el = this.query<HTMLInputElement>(id);
+      if (el) el.value = String(val);
+    });
+    const sound = this.query<HTMLInputElement>('#fpv-lap-timer-sound');
+    if (sound) sound.checked = this.config.soundEnabled;
+    this.audio.setEnabled(this.config.soundEnabled);
+  }
+
+  private readInputs(): void {
+    const getNum = (id: string, def: number, min: number) =>
+      Math.max(min, Number(this.query<HTMLInputElement>(id)?.value) || def);
+    this.config.trackLengthM = getNum('#fpv-lap-timer-track-length', 250, 10);
+    this.config.targetLaps = getNum('#fpv-lap-timer-target-laps', 3, 0);
+    this.config.batteryCapacityMah = getNum('#fpv-lap-timer-battery', 1300, 100);
+    this.config.debounceMs = getNum('#fpv-lap-timer-debounce', 3, 1) * 1000;
+    const sound = this.query<HTMLInputElement>('#fpv-lap-timer-sound');
+    this.config.soundEnabled = sound?.checked ?? true;
+    this.audio.setEnabled(this.config.soundEnabled);
+    saveSessionConfig(this.config);
+    this.updateViews();
+  }
+
+  private updateSidebarStats(completed: number, avgMs: number, avgKmh: number): void {
+    const setText = (id: string, text: string) => {
+      const el = this.query<HTMLElement>(id);
+      if (el) el.textContent = text;
+    };
+    setText('#fpv-lap-timer-stat-completed', String(completed));
+    setText('#fpv-lap-timer-stat-avg', avgMs > 0 ? formatLapTime(avgMs) : '--');
+    setText('#fpv-lap-timer-stat-speed', avgKmh > 0 ? `${avgKmh} ${this.ui.speedUnitKmh || 'km/h'}` : '--');
+  }
+
+  private updateHud(completed: number): void {
+    const targetStr = this.config.targetLaps > 0 ? String(this.config.targetLaps) : '∞';
+    const lapNum = this.status === 'finished' ? completed : this.currentLapNumber;
+    const hudLap = this.query<HTMLElement>('#fpv-lap-timer-hud-lap');
+    if (hudLap) hudLap.textContent = `${this.ui.lapNumberPrefix || 'Lap'} ${lapNum} / ${targetStr}`;
+    const statusText = this.query<HTMLElement>('#fpv-lap-timer-status-text');
+    if (statusText) statusText.textContent = this.getStatusLabel();
+    const statusChip = this.query<HTMLElement>('.fpv-lap-timer-status-chip');
+    if (statusChip) statusChip.className = `fpv-lap-timer-chip fpv-lap-timer-status-chip fpv-lap-timer-status-${this.status}`;
+  }
+
+  private updateViews(): void {
+    const laps = computeLapRecords(this.lapDurationsMs, this.config.trackLengthM, this.config.batteryCapacityMah);
+    const metrics = calculateSessionMetrics(this.lapDurationsMs, this.config.trackLengthM, this.config.batteryCapacityMah);
+    const telem = this.query<HTMLElement>('.fpv-lap-timer-telemetry-mount');
+    if (telem) {
+      telem.innerHTML = renderTelemetryScene({
+        metrics, laps, currentLapNumber: this.currentLapNumber,
+        targetLaps: this.config.targetLaps, status: this.status, ui: this.ui,
+      });
+    }
+    const table = this.query<HTMLElement>('.fpv-lap-timer-table-mount');
+    if (table) table.innerHTML = renderLapTable(laps, this.ui);
+    this.updateSidebarStats(metrics.completedLaps, metrics.averageLapMs, metrics.averageSpeedKmh);
+    this.updateHud(metrics.completedLaps);
+    this.updateControlButtons();
+  }
+
+  private updateControlButtons(): void {
+    const isBusy = this.status === 'running' || this.status === 'countdown';
+    this.updatePrimaryButtons(isBusy);
+    this.updateTriggerButton();
+  }
+
+  private updatePrimaryButtons(isBusy: boolean): void {
+    const start = this.query<HTMLButtonElement>('#fpv-lap-timer-btn-start');
+    if (start) {
+      start.disabled = isBusy;
+      start.style.display = this.status === 'paused' ? 'none' : 'inline-flex';
+      if (this.status !== 'countdown') start.textContent = this.ui.startCountdownButton;
+    }
+    const pause = this.query<HTMLButtonElement>('#fpv-lap-timer-btn-pause');
+    if (pause) {
+      pause.style.display = isBusy || this.status === 'paused' ? 'inline-flex' : 'none';
+      pause.textContent = this.status === 'paused' ? this.ui.resumeTimerButton : this.ui.pauseTimerButton;
+    }
+  }
+
+  private updateTriggerButton(): void {
+    const trigger = this.query<HTMLButtonElement>('.fpv-lap-timer-giant-btn');
+    if (trigger) {
+      trigger.disabled = this.status !== 'running';
+      trigger.classList.toggle('fpv-lap-timer-btn-countdown-active', this.status === 'countdown');
+      const caption = trigger.querySelector<HTMLElement>('.fpv-lap-timer-btn-caption');
+      if (caption && this.status !== 'countdown') caption.textContent = this.ui.recordLapButton;
+    }
+  }
+
+  private tick = (): void => {
+    if (this.status === 'running') {
+      const display = this.query<HTMLElement>('.fpv-lap-timer-digits');
+      if (display) display.textContent = formatLapTime(performance.now() - this.lapStartTime);
+      this.animFrameId = requestAnimationFrame(this.tick);
+    }
+  };
+
+  public startCountdown(): void {
+    if (this.status === 'running' || this.status === 'countdown') return;
+    this.status = 'countdown';
+    this.updateViews();
+    this.audio.playFaiCountdown(
+      (label) => this.paintCountdown(label),
+      () => this.beginRace()
+    );
+  }
+
+  private paintCountdown(label: string): void {
+    const start = this.query<HTMLButtonElement>('#fpv-lap-timer-btn-start');
+    if (start) start.textContent = label;
+    const triggerCaption = this.query<HTMLElement>('.fpv-lap-timer-giant-btn .fpv-lap-timer-btn-caption');
+    if (triggerCaption) triggerCaption.textContent = label;
+    const display = this.query<HTMLElement>('.fpv-lap-timer-digits');
+    if (display) display.textContent = label;
+  }
+
+  private beginRace(): void {
+    this.status = 'running';
+    this.lapStartTime = performance.now();
+    this.lastRecordedTimestamp = 0;
+    this.currentLapNumber = 1;
+    this.updateViews();
+    this.tick();
+  }
+
+  public recordLap(): void {
+    if (this.status !== 'running') return;
+    const now = performance.now();
+    if (isDebounceLocked(this.lastRecordedTimestamp, now, this.config.debounceMs)) return;
+
+    const lapDuration = now - this.lapStartTime;
+    const isNewFastest = this.lapDurationsMs.length === 0 || lapDuration < Math.min(...this.lapDurationsMs);
+    this.lapDurationsMs.push(lapDuration);
+    saveSessionLaps(this.lapDurationsMs);
+    this.lastRecordedTimestamp = now;
+    this.lapStartTime = now;
+    this.currentLapNumber += 1;
+    this.audio.playLapSound(isNewFastest);
+
+    if (this.config.targetLaps > 0 && this.lapDurationsMs.length >= this.config.targetLaps) {
+      this.finishRace();
+    } else {
+      this.updateViews();
+    }
+  }
+
+  public pauseRace(): void {
+    if (this.status === 'running') {
+      this.status = 'paused';
+      if (this.animFrameId) cancelAnimationFrame(this.animFrameId);
+      this.updateViews();
+    } else if (this.status === 'paused') {
+      this.status = 'running';
+      this.lapStartTime = performance.now();
+      this.updateViews();
+      this.tick();
+    }
+  }
+
+  public finishRace(): void {
+    this.status = 'finished';
+    if (this.animFrameId) cancelAnimationFrame(this.animFrameId);
+    const display = this.query<HTMLElement>('.fpv-lap-timer-digits');
+    if (display) {
+      const total = this.lapDurationsMs.reduce((acc, d) => acc + d, 0);
+      display.textContent = formatLapTime(total);
+    }
+    this.audio.playFinishFanfare();
+    this.updateViews();
+  }
+
+  public resetSession(): void {
+    this.status = 'idle';
+    this.audio.cancelPendingTones();
+    if (this.animFrameId) cancelAnimationFrame(this.animFrameId);
+    this.lapDurationsMs = [];
+    saveSessionLaps([]);
+    this.currentLapNumber = 1;
+    this.lapStartTime = 0;
+    this.lastRecordedTimestamp = 0;
+    const display = this.query<HTMLElement>('.fpv-lap-timer-digits');
+    if (display) display.textContent = '00:00.000';
+    this.updateViews();
+  }
+
+  public applyPreset(presetKey: 'multigp' | 'whoop' | 'sprint'): void {
+    const p = PRESETS[presetKey];
+    this.config.trackLengthM = p.trackLengthM;
+    this.config.targetLaps = p.targetLaps;
+    this.config.batteryCapacityMah = p.batteryCapacityMah;
+    saveSessionConfig(this.config);
+    this.syncInputs();
+    this.root.querySelectorAll('.fpv-lap-timer-preset').forEach((btn) => {
+      btn.classList.toggle('active', btn.getAttribute('data-preset') === presetKey);
+    });
+    this.updateViews();
+  }
+
+  public exportCsv(): void {
+    exportSessionCsv(this.lapDurationsMs, this.config);
+  }
+
+  public async copySummary(): Promise<void> {
+    const copied = await copySessionSummary(this.lapDurationsMs, this.config);
+    if (copied) {
+      const notice = this.query<HTMLElement>('#fpv-lap-timer-copy-notice');
+      if (notice) {
+        notice.style.display = 'inline-block';
+        setTimeout(() => {
+          notice.style.display = 'none';
+        }, 3000);
+      }
+    }
+  }
+
+  private getStatusLabel(): string {
+    const labels = { countdown: this.ui.statusCountdown, running: this.ui.statusRunning, paused: this.ui.statusPaused, finished: this.ui.statusFinished };
+    return labels[this.status as keyof typeof labels] || this.ui.statusIdle || 'Ready for Start';
+  }
+
+  private bindEvents(): void {
+    const clicks: [string, () => void][] = [
+      ['#fpv-lap-timer-btn-start', () => this.startCountdown()],
+      ['#fpv-lap-timer-btn-pause', () => this.pauseRace()],
+      ['#fpv-lap-timer-btn-reset', () => this.resetSession()],
+      ['.fpv-lap-timer-giant-btn', () => this.recordLap()],
+      ['#fpv-lap-timer-export-csv', () => this.exportCsv()],
+      ['#fpv-lap-timer-copy-summary', () => this.copySummary()],
+    ];
+    clicks.forEach(([sel, fn]) => this.query(sel)?.addEventListener('click', fn));
+    ['#fpv-lap-timer-track-length', '#fpv-lap-timer-target-laps', '#fpv-lap-timer-battery', '#fpv-lap-timer-debounce', '#fpv-lap-timer-sound'].forEach((id) => {
+      this.query(id)?.addEventListener('change', () => this.readInputs());
+    });
+    this.root.querySelectorAll('.fpv-lap-timer-preset').forEach((btn) => {
+      btn.addEventListener('click', () => {
+        const k = btn.getAttribute('data-preset') as 'multigp' | 'whoop' | 'sprint';
+        if (k) this.applyPreset(k);
+      });
+    });
+  }
+
+  public destroy(): void {
+    this.audio.cancelPendingTones();
+    if (this.animFrameId) cancelAnimationFrame(this.animFrameId);
+  }
+}
+
+export { initializeLapTimer } from './bootstrap';

package/src/tool/fpv-drone-lap-timer/dom-views.ts

@@ -0,0 +1,213 @@
+import type { LapRecord, SessionMetrics } from './logic';
+import { formatLapTime, formatDelta } from './logic';
+import type { FpvDroneLapTimerUI } from './ui';
+
+export interface TelemetrySceneProps {
+  metrics: SessionMetrics;
+  laps: LapRecord[];
+  currentLapNumber: number;
+  targetLaps: number;
+  status: 'idle' | 'countdown' | 'running' | 'paused' | 'finished';
+  ui: FpvDroneLapTimerUI;
+}
+
+function renderPaceBarsSvg(laps: LapRecord[]): string {
+  const maxDur = laps.length > 0 ? Math.max(...laps.map((l) => l.durationMs)) : 1;
+  return laps
+    .map((lap, idx) => {
+      const barHeight = Math.max(12, Math.round((lap.durationMs / maxDur) * 52));
+      const y = 80 - barHeight;
+      const x = 16 + idx * 26;
+      const fillClass = lap.isBest ? 'fpv-lap-timer-bar-best' : 'fpv-lap-timer-bar-normal';
+      return `<g class="fpv-lap-timer-bar-group" data-lap="${lap.lapIndex}">
+        <rect x="${x}" y="${y}" width="18" height="${barHeight}" rx="3" class="${fillClass}" />
+        <text x="${x + 9}" y="95" class="fpv-lap-timer-bar-label">${lap.lapIndex}</text>
+      </g>`;
+    })
+    .join('');
+}
+
+function renderDroneRacerSvg(status: 'idle' | 'countdown' | 'running' | 'paused' | 'finished'): string {
+  const isRacing = status === 'running';
+  const motionTag = isRacing
+    ? `<animateMotion
+        path="M 160 25 L 230 25 A 65 65 0 0 1 230 155 L 90 155 A 65 65 0 0 1 90 25 Z"
+        dur="6s"
+        repeatCount="indefinite"
+        rotate="auto"
+      />`
+    : '';
+  const initialTransform = isRacing ? '' : 'transform="translate(160, 25)"';
+
+  return `
+    <g class="fpv-lap-timer-drone-racer" ${initialTransform} filter="url(#fpvGlow)">
+      ${motionTag}
+      <line x1="-6" y1="-6" x2="6" y2="6" class="fpv-lap-timer-drone-arm" />
+      <line x1="-6" y1="6" x2="6" y2="-6" class="fpv-lap-timer-drone-arm" />
+      <circle cx="-6" cy="-6" r="2" class="fpv-lap-timer-drone-motor" />
+      <circle cx="6" cy="-6" r="2" class="fpv-lap-timer-drone-motor" />
+      <circle cx="-6" cy="6" r="2" class="fpv-lap-timer-drone-motor" />
+      <circle cx="6" cy="6" r="2" class="fpv-lap-timer-drone-motor" />
+      <circle cx="-6" cy="-6" r="4.2" class="fpv-lap-timer-drone-rotor-blur" />
+      <circle cx="6" cy="-6" r="4.2" class="fpv-lap-timer-drone-rotor-blur" />
+      <circle cx="-6" cy="6" r="4.2" class="fpv-lap-timer-drone-rotor-blur" />
+      <circle cx="6" cy="6" r="4.2" class="fpv-lap-timer-drone-rotor-blur" />
+      <rect x="-4" y="-3.5" width="8" height="7" rx="2" class="fpv-lap-timer-drone-body" />
+      <circle cx="4" cy="0" r="1.5" class="fpv-lap-timer-drone-cam" />
+      <circle cx="-4" cy="0" r="1.5" class="fpv-lap-timer-drone-led" />
+    </g>
+  `;
+}
+
+function renderGatesSvg(status: 'idle' | 'countdown' | 'running' | 'paused' | 'finished'): string {
+  return `
+    <rect x="148" y="19" width="24" height="12" rx="3" fill="none" class="fpv-lap-timer-gate fpv-lap-timer-gate-sf" />
+    <text x="160" y="11" class="fpv-lap-timer-gate-label">GATE 1 [S/F]</text>
+    <circle cx="295" cy="90" r="5" class="fpv-lap-timer-gate fpv-lap-timer-gate-sector" />
+    <text x="305" y="94" class="fpv-lap-timer-gate-label">G2</text>
+    <circle cx="160" cy="155" r="5" class="fpv-lap-timer-gate fpv-lap-timer-gate-sector" />
+    <text x="160" y="174" class="fpv-lap-timer-gate-label">G3</text>
+    <circle cx="25" cy="90" r="5" class="fpv-lap-timer-gate fpv-lap-timer-gate-sector" />
+    <text x="15" y="94" class="fpv-lap-timer-gate-label">G4</text>
+    ${renderDroneRacerSvg(status)}
+  `;
+}
+
+function renderRacetrackCenterHud(timeStr: string, fastestHeading: string, speedStr: string): string {
+  return `
+    <g class="fpv-lap-timer-drone-center">
+      <text x="160" y="78" class="fpv-lap-timer-center-time">${timeStr}</text>
+      <text x="160" y="96" class="fpv-lap-timer-center-sub">${fastestHeading}</text>
+      <text x="160" y="116" class="fpv-lap-timer-center-speed">${speedStr}</text>
+    </g>
+  `;
+}
+
+function renderRacetrackSvg(
+  metrics: SessionMetrics,
+  targetLaps: number,
+  status: 'idle' | 'countdown' | 'running' | 'paused' | 'finished',
+  ui: FpvDroneLapTimerUI
+): string {
+  const progress = targetLaps > 0 ? Math.min(100, Math.round((metrics.completedLaps / targetLaps) * 100)) : 100;
+  const offset = 640 - (640 * progress) / 100;
+  const timeStr = metrics.fastestLapMs > 0 ? formatLapTime(metrics.fastestLapMs) : '00:00.000';
+  const speedStr = metrics.averageSpeedKmh > 0 ? `${metrics.averageSpeedKmh} ${ui.speedUnitKmh}` : '--';
+
+  return `
+    <div class="fpv-lap-timer-racetrack-box">
+      <svg class="fpv-lap-timer-racetrack-svg" viewBox="0 0 320 180" role="img" aria-label="Racetrack layout">
+        <defs>
+          <linearGradient id="fpvTrackGrad" x1="0%" y1="0%" x2="100%" y2="100%">
+            <stop offset="0%" stop-color="var(--fpv-cyan)" /><stop offset="100%" stop-color="var(--fpv-emerald)" />
+          </linearGradient>
+          <filter id="fpvGlow" x="-20%" y="-20%" width="140%" height="140%"><feGaussianBlur stdDeviation="3" result="blur" /><feComposite in="SourceGraphic" in2="blur" operator="over" /></filter>
+        </defs>
+        <rect x="25" y="25" width="270" height="130" rx="65" fill="none" class="fpv-lap-timer-track-bg" />
+        <rect x="25" y="25" width="270" height="130" rx="65" fill="none" stroke="url(#fpvTrackGrad)" class="fpv-lap-timer-track-active" stroke-dasharray="640" stroke-dashoffset="${offset}" />
+        ${renderGatesSvg(status)}
+        ${renderRacetrackCenterHud(timeStr, ui.fastestLapHeading, speedStr)}
+      </svg>
+    </div>
+  `;
+}
+
+function renderPaceChart(metrics: SessionMetrics, laps: LapRecord[], ui: FpvDroneLapTimerUI): string {
+  const badgeStr = metrics.fastestLapMs > 0 ? `${ui.fastestLapBadge}: ${formatLapTime(metrics.fastestLapMs)}` : '--';
+  const chartWidth = Math.max(140, 16 + laps.length * 26 + 16);
+  const axisWidth = Math.max(132, 16 + laps.length * 26 + 8);
+  const chartInner = laps.length > 0
+    ? `<svg class="fpv-lap-timer-bars-svg" viewBox="0 0 ${chartWidth} 104" role="img" aria-label="Lap times bar comparison">
+        <line x1="8" y1="80" x2="${axisWidth}" y2="80" class="fpv-lap-timer-chart-axis" />
+        ${renderPaceBarsSvg(laps)}
+      </svg>`
+    : `<div class="fpv-lap-timer-empty-notice">${ui.noLapsRecordedNotice}</div>`;
+
+  return `
+    <div class="fpv-lap-timer-pace-box">
+      <div class="fpv-lap-timer-pace-header">
+        <h4>${ui.lapHistoryHeading}</h4>
+        <span class="fpv-lap-timer-fastest-pill">${badgeStr}</span>
+      </div>
+      <div class="fpv-lap-timer-pace-chart">${chartInner}</div>
+    </div>
+  `;
+}
+
+export function renderTelemetryScene(props: TelemetrySceneProps): string {
+  const { metrics, laps, targetLaps, ui } = props;
+  const ratingLabel = getConsistencyRatingLabel(metrics.consistencyRating, ui);
+
+  return `
+    <div class="fpv-lap-timer-telemetry-deck" aria-label="FPV Race Telemetry Scene">
+      <div class="fpv-lap-timer-telemetry-status-row">
+        <div class="fpv-lap-timer-chip fpv-lap-timer-consistency-chip fpv-lap-timer-rating-${metrics.consistencyRating}">
+          <span>${ui.consistencyIndexHeading}: <strong>${metrics.consistencyIndex}%</strong> (${ratingLabel})</span>
+        </div>
+      </div>
+      <div class="fpv-lap-timer-telemetry-grid">
+        ${renderRacetrackSvg(metrics, targetLaps, props.status, ui)}
+        ${renderPaceChart(metrics, laps, ui)}
+      </div>
+    </div>
+  `;
+}
+
+function getDeltaClass(deltaMs: number, isBest: boolean): string {
+  if (isBest) return 'fpv-lap-timer-delta-best';
+  if (deltaMs < 1000) return 'fpv-lap-timer-delta-good';
+  return 'fpv-lap-timer-delta-slow';
+}
+
+function renderLapRow(lap: LapRecord, ui: FpvDroneLapTimerUI): string {
+  const bestClass = lap.isBest ? 'fpv-lap-timer-row-best' : '';
+  const deltaFormatted = formatDelta(lap.deltaBestMs, lap.isBest);
+  const deltaClass = getDeltaClass(lap.deltaBestMs, lap.isBest);
+  const fastestBadge = lap.isBest ? `<span class="fpv-lap-timer-best-mini">${ui.fastestLapBadge}</span>` : '';
+
+  return `
+    <tr class="fpv-lap-timer-tr ${bestClass}">
+      <td class="fpv-lap-timer-td-lap">
+        <span class="fpv-lap-timer-lap-tag">${ui.lapNumberPrefix} ${lap.lapIndex}</span>
+        ${fastestBadge}
+      </td>
+      <td class="fpv-lap-timer-td-time font-mono">${formatLapTime(lap.durationMs)}</td>
+      <td class="fpv-lap-timer-td-split"><span class="fpv-lap-timer-delta-pill ${deltaClass}">${deltaFormatted}</span></td>
+      <td class="fpv-lap-timer-td-speed font-mono">${lap.speedKmh} ${ui.speedUnitKmh} <small class="fpv-lap-timer-subtle">(${lap.speedMph} ${ui.speedUnitMph})</small></td>
+      <td class="fpv-lap-timer-td-battery font-mono">${lap.batteryUsedMah} ${ui.batteryUsedUnit}</td>
+      <td class="fpv-lap-timer-td-total font-mono fpv-lap-timer-subtle">${formatLapTime(lap.splitTimeMs)}</td>
+    </tr>
+  `;
+}
+
+export function renderLapTable(laps: LapRecord[], ui: FpvDroneLapTimerUI): string {
+  if (laps.length === 0) {
+    return `<div class="fpv-lap-timer-table-empty">${ui.noLapsRecordedNotice}</div>`;
+  }
+
+  const rows = laps.map((lap) => renderLapRow(lap, ui)).join('');
+  return `
+    <div class="fpv-lap-timer-table-wrap">
+      <table class="fpv-lap-timer-table">
+        <thead>
+          <tr>
+            <th>${ui.lapColumnHeader}</th>
+            <th>${ui.timeColumnHeader}</th>
+            <th>${ui.splitColumnHeader}</th>
+            <th>${ui.speedColumnHeader}</th>
+            <th>${ui.batteryColumnHeader}</th>
+            <th>Total Split</th>
+          </tr>
+        </thead>
+        <tbody>${rows}</tbody>
+      </table>
+    </div>
+  `;
+}
+
+function getConsistencyRatingLabel(rating: 'elite' | 'pro' | 'club' | 'novice', ui: FpvDroneLapTimerUI): string {
+  if (rating === 'elite') return ui.consistencyRatingElite;
+  if (rating === 'pro') return ui.consistencyRatingPro;
+  if (rating === 'club') return ui.consistencyRatingClub;
+  return ui.consistencyRatingNovice;
+}

package/src/tool/fpv-drone-lap-timer/entry.ts

@@ -0,0 +1,27 @@
+import type { DronesToolEntry, ToolLocaleContent } from '../../types';
+import type { FpvDroneLapTimerUI } from './ui';
+
+export type { FpvDroneLapTimerUI };
+export type FpvDroneLapTimerLocaleContent = ToolLocaleContent<FpvDroneLapTimerUI>;
+
+export const fpvDroneLapTimer: DronesToolEntry<FpvDroneLapTimerUI> = {
+  id: 'fpv-drone-lap-timer',
+  icons: { bg: 'mdi:timer-outline', fg: 'mdi:quadcopter' },
+  i18n: {
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    de: () => import('./i18n/de').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+  },
+};

package/src/tool/fpv-drone-lap-timer/export.ts

@@ -0,0 +1,41 @@
+import type { SessionConfig, LapRecord, SessionMetrics } from './logic';
+import { computeLapRecords, calculateSessionMetrics, formatLapTime, formatDelta } from './logic';
+
+export function exportSessionCsv(durationsMs: number[], config: SessionConfig): void {
+  const laps = computeLapRecords(durationsMs, config.trackLengthM, config.batteryCapacityMah);
+  if (laps.length === 0) return;
+  const headers = ['Lap', 'Time_Ms', 'Formatted_Time', 'Delta_Best_Ms', 'Speed_Kmh', 'Battery_Used_Mah', 'Split_Time_Ms'];
+  const rows = laps.map((l) => [
+    l.lapIndex, l.durationMs.toFixed(1), formatLapTime(l.durationMs),
+    l.deltaBestMs.toFixed(1), l.speedKmh, l.batteryUsedMah, l.splitTimeMs.toFixed(1),
+  ]);
+  const blob = new Blob([[headers.join(','), ...rows.map((r) => r.join(','))].join('\n')], { type: 'text/csv;charset=utf-8;' });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = `fpv-drone-laps-${new Date().toISOString().slice(0, 10)}.csv`;
+  link.click();
+  URL.revokeObjectURL(url);
+}
+
+function buildSummaryLines(laps: LapRecord[], metrics: SessionMetrics, trackLengthM: number): string[] {
+  return [
+    'FPV DRONE RACE SESSION SUMMARY',
+    `Track: ${trackLengthM}m | Laps: ${metrics.completedLaps} | Total: ${formatLapTime(metrics.totalDurationMs)}`,
+    `Fastest: ${metrics.fastestLapMs > 0 ? formatLapTime(metrics.fastestLapMs) : '--'} | Speed: ${metrics.averageSpeedKmh} km/h`,
+    `Consistency: ${metrics.consistencyIndex}% (${metrics.consistencyRating.toUpperCase()})`,
+    ...laps.map((l) => `Lap ${l.lapIndex}: ${formatLapTime(l.durationMs)} (Delta: ${formatDelta(l.deltaBestMs, l.isBest)})`),
+  ];
+}
+
+export async function copySessionSummary(durationsMs: number[], config: SessionConfig): Promise<boolean> {
+  const laps = computeLapRecords(durationsMs, config.trackLengthM, config.batteryCapacityMah);
+  const metrics = calculateSessionMetrics(durationsMs, config.trackLengthM, config.batteryCapacityMah);
+  const lines = buildSummaryLines(laps, metrics, config.trackLengthM);
+  try {
+    await navigator.clipboard.writeText(lines.join('\n'));
+    return true;
+  } catch {
+    return false;
+  }
+}