@jjlmoya/utils-sports 1.1.0

package/src/tool/gymTracker/i18n/fr.ts

@@ -0,0 +1,225 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { GymTrackerUI } from '../ui';
+
+const slug = 'suivi-entrainement-gym';
+const title = 'Suivi d’Entraînement Gym : Graphiques de Progrès et Force';
+const description =
+  'Enregistrez vos levées, sélectionnez l’exercice et visualisez votre progression avec des graphiques de force. Optimisez votre surcharge progressive à la salle.';
+
+const faqData = [
+  {
+    question: 'À quoi sert le suivi d’entraînement ?',
+    answer:
+      'Il sert à appliquer la surcharge progressive de manière scientifique. En sachant exactement ce que vous avez soulevé lors de la séance précédente, vous pouvez essayer de battre cette marque, ce qui garantit la croissance musculaire et les gains de force à long terme.',
+  },
+  {
+    question: 'Quelles données dois-je enregistrer ?',
+    answer:
+      'Le plus important est le poids maximum (top set) que vous avez réussi à déplacer avec une bonne technique pour un nombre déterminé de répétitions. Notre outil se concentre sur l’enregistrement du poids par séance pour générer votre graphique de progrès.',
+  },
+  {
+    question: 'Comment interpréter les graphiques ?',
+    answer:
+      'Une ligne ascendante indique que vous progressez. Une ligne plate (stagnation) suggère que vous devez ajuster votre volume, votre intensité ou votre récupération. Une ligne descendante persistante peut être le signe d’un surentraînement.',
+  },
+  {
+    question: 'Où sont stockées mes données ?',
+    answer:
+      'Les données sont stockées localement dans votre navigateur (Local Storage). Cela signifie que votre vie privée est totale et que vous n’avez pas besoin de créer de compte, mais si vous effacez les données du navigateur, l’historique sera perdu.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Sélectionnez l’exercice',
+    text: 'Choisissez parmi les mouvements fondamentaux comme le Squat, le Développé Couché ou le Soulevé de Terre dans le menu déroulant.',
+  },
+  {
+    name: 'Entrez le poids',
+    text: 'Après votre série la plus lourde, entrez les kilogrammes soulevés dans le champ correspondant.',
+  },
+  {
+    name: 'Appuyez sur Ajouter',
+    text: 'Enregistrez votre marque. Le système mettra automatiquement à jour votre historique et votre graphique de progression.',
+  },
+  {
+    name: 'Analysez votre évolution',
+    text: 'Consultez le graphique périodiquement pour identifier les stagnations et vous motiver en voyant votre croissance réelle en force.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'HealthApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'fr',
+};
+
+export const content: ToolLocaleContent<GymTrackerUI & Record<string, string>> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Questions Fréquentes',
+  faq: faqData,
+  bibliographyTitle: 'Références Scientifiques',
+  bibliography: [
+    {
+      name: 'Journal of Strength and Conditioning Research - Progressive Overload Study',
+      url: 'https://journals.lww.com/nsca-jscr/Fulltext/2010/10000/The_Mechanisms_of_Muscle_Hypertrophy_and_Their.40.aspx',
+    },
+    {
+      name: 'National Academy of Sports Medicine - Progressive Overload Explained',
+      url: 'https://blog.nasm.org/progressive-overload-explained',
+    },
+    {
+      name: 'Science of Strength - Data Tracking in Resistance Training',
+      url: 'https://pubmed.ncbi.nlm.nih.gov/30558493/',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Suivi d’Entraînement à la Salle : La Clé d’une Progression Réelle',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Dans le monde du fitness et du bodybuilding, il existe un principe fondamental qui sépare ceux qui obtiennent des résultats étonnants de ceux qui stagnent rapidement : la <strong>surcharge progressive</strong>. Cependant, il est impossible d’appliquer ce principe efficacement si vous ne tenez pas un registre détaillé de vos levées. Dans ce guide, nous explorerons pourquoi le suivi de votre entraînement est vital, comment utiliser notre <strong>suivi d’entraînement gym</strong> pour maximiser vos gains, et les fondements scientifiques qui soutiennent cette pratique.',
+    },
+    {
+      type: 'title',
+      text: 'Qu’est-ce que la Surcharge Progressive ?',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'La surcharge progressive est l’augmentation graduelle du stress appliqué au corps pendant l’exercice physique. Pour qu’un muscle se développe ou se renforce, il doit être soumis à un stimulus plus important que celui auquel il est habitué. Si vous allez à la salle et que vous soulevez toujours le même poids, avec les mêmes répétitions et le même temps de repos, votre corps n’aura aucune raison biologique de s’adapter et de se développer.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Augmentation du poids : Soulever plus lourd que la séance précédente.',
+        'Augmentation des répétitions : Faire plus de répétitions avec le même poids.',
+        'Augmentation du volume : Réaliser plus de séries totales par groupe musculaire.',
+        'Réduction du repos : Faire le même effort en moins de temps.',
+        'Amélioration de la technique : Réaliser l’exercice avec un contrôle accru et une plus grande amplitude de mouvement.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Pourquoi le Journal de Bord Manuel est Supérieur à la Mémoire',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'De nombreux athlètes font l’erreur de confier à leur mémoire le soin de se rappeler ce qu’ils ont soulevé la semaine dernière. Pourtant, dans un entraînement typique comprenant 5 à 10 exercices différents, il est très facile d’oublier si vous avez fait 80 kg o 82.5 kg à la presse, ou si vous avez réussi 10 répétitions ou 12. Ce manque de précision mène à la médiocrité.',
+    },
+    {
+      type: 'tip',
+      title: 'Le Pouvoir de Visualiser le Progrès',
+      html: 'Voir une ligne ascendante sur un graphique vous donne l’élan nécessaire pour tenter cette répétition supplémentaire qui fait la différence entre la stagnation et une croissance musculaire constante.',
+    },
+    {
+      type: 'title',
+      text: 'Les Exercices Fondamentaux pour le Suivi',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Bien que tous les exercices soient précieux, certains mouvements polyarticulaires offrent la meilleure vision de votre force globale et de votre développement physique. Voici ceux que vous devriez prioriser dans votre suivi : <strong>Développé Couché</strong> pour la poussée horizontale, <strong>Développé Militaire</strong> pour la poussée verticale, <strong>Tractions</strong> pour le tirage et <strong>Hip Thrust</strong> pour les fessiers.',
+    },
+    {
+      type: 'title',
+      text: 'Comment Analyser vos Graphiques de Progression',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Une fois que vous aurez enregistré plusieurs séances, vous commencerez à voir des modèles : une <strong>ligne ascendante constante</strong> indique que vous êtes sur la bonne voie, une <strong>ligne plate</strong> suggère que vous devez ajuster votre volume ou votre repos, et une <strong>tendance à la baisse</strong> peut être un signe de fatigue accumulée.',
+    },
+    {
+      type: 'title',
+      text: 'La Psychologie du Succès à la Salle',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'S’entraîner est autant un défi mental que physique. En utilisant un outil visuel qui vous montre qu’aujourd’hui vous êtes 1% plus fort qu’il y a quinze jours, vous alimentez votre système de récompense par la dopamine. Cela crée une boucle de rétroaction positive qui transforme l’entraînement en une habitude durable.',
+    },
+  ],
+  ui: {
+    exerciseLabel: 'Exercice',
+    pushCategory: 'Poussée',
+    pullCategory: 'Tirage',
+    gluteCategory: 'Fessiers',
+    customExerciseCategory: 'Personnalisés',
+    addCustomExerciseTitle: 'Ajouter un exercice personnalisé',
+    newExerciseLabel: 'Nouvel exercice',
+    exercisePlaceholder: 'Nom de l’exercice...',
+    addBtn: 'Ajouter',
+    registerWeightLabel: 'Enregistrer le Poids',
+    weightPlaceholder: '00.0',
+    startBtn: 'Démarrer',
+    resetBtn: 'Réinitialiser',
+    okBtn: 'OK',
+    noData: 'Pas de données',
+    recordLabel: 'Record',
+    lastLabel: 'Dernier',
+    historyTitle: 'Logs',
+    exportBtn: 'Exporter',
+    confirmDeleteTitle: 'Effacer l’historique ?',
+    confirmDeleteText: 'Cette action ne peut pas être annulée. Tous les enregistrements de l’exercice sélectionné seront supprimés.',
+    deleteBtn: 'Supprimer',
+    cancelBtn: 'Annuler',
+    units: 'kg',
+
+    benchPress: 'Développé Couché',
+    overheadPress: 'Développé Militaire',
+    pushPress: 'Push Press',
+    inclineDbPress: 'Développé Incliné Haltères',
+    dipsTriceps: 'Dips Triceps',
+    tricepsExtensions: 'Extensions Triceps Poulie',
+    pullUp: 'Tractions',
+    barbellRow: 'Tirage Buste Penché',
+    latPulldown: 'Tirage Vertical',
+    dbRow: 'Tirage Haltère',
+    facePulls: 'Face Pulls',
+    bicepsCurl: 'Curl Biceps Barre',
+    hipThrust: 'Hip Thrust',
+    rdl: 'Soulevé de Terre Roumain',
+    lunges: 'Fentes',
+    gluteKick: 'Kickback Fessier Poulie',
+    hipAbduction: 'Abduction Hanche Machine',
+    stepUp: 'Step Up',
+  },
+};

package/src/tool/gymTracker/index.ts

@@ -0,0 +1,34 @@
+import type { SportsToolEntry, ToolLocaleContent, ToolDefinition } from '../../types';
+import GymTrackerComponent from './component.astro';
+import GymTrackerSEO from './seo.astro';
+import GymTrackerBibliography from './bibliography.astro';
+import type { GymTrackerUI } from './ui';
+
+export type { GymTrackerUI };
+export type GymTrackerLocaleContent = ToolLocaleContent<GymTrackerUI>;
+
+import { content as es } from './i18n/es';
+import { content as en } from './i18n/en';
+import { content as fr } from './i18n/fr';
+
+export const gymTracker: SportsToolEntry<GymTrackerUI> = {
+  id: 'gym-tracker',
+  icons: {
+    bg: 'mdi:weight-lifter',
+    fg: 'mdi:chart-line',
+  },
+  i18n: {
+    es: async () => es as ToolLocaleContent<GymTrackerUI>,
+    en: async () => en as ToolLocaleContent<GymTrackerUI>,
+    fr: async () => fr as ToolLocaleContent<GymTrackerUI>,
+  },
+};
+
+export { GymTrackerComponent, GymTrackerSEO, GymTrackerBibliography };
+
+export const GYM_TRACKER_TOOL: ToolDefinition = {
+  entry: gymTracker,
+  Component: GymTrackerComponent,
+  SEOComponent: GymTrackerSEO,
+  BibliographyComponent: GymTrackerBibliography,
+};

package/src/tool/gymTracker/logic.ts

@@ -0,0 +1,169 @@
+import { getHistory, saveLog, deleteLog, getCustomExercises, saveCustomExercise, deleteExerciseHistory } from "./storage";
+import { initTimer } from "./timer";
+import { updateExerciseOptions, renderHistoryTable, drawProgressChart } from "./ui-utils";
+import type { CustomExercise, HistoryData } from "./types";
+
+interface GTElements {
+  exerciseSelect: HTMLSelectElement;
+  weightInput: HTMLInputElement;
+  addLogBtn: HTMLElement | null;
+  clearHistoryBtn: HTMLElement | null;
+  customExerciseInput: HTMLInputElement;
+  addCustomExerciseBtn: HTMLElement | null;
+  toggleFormBtn: HTMLElement | null;
+  closeFormBtn: HTMLElement | null;
+  form: HTMLElement | null;
+  exportBtn: HTMLElement | null;
+  exportMenu: HTMLElement | null;
+  jsonBtn: HTMLElement | null;
+  csvBtn: HTMLElement | null;
+  modal: HTMLElement | null;
+  confirmBtn: HTMLElement | null;
+  cancelBtn: HTMLElement | null;
+  list: HTMLElement | null;
+  maxEl: HTMLElement | null;
+  lastEl: HTMLElement | null;
+  empty: HTMLElement | null;
+  chartPath: SVGPathElement | null;
+  chartPoints: HTMLElement | null;
+}
+
+export function initGymTracker() {
+  const container = document.getElementById('gym-tracker-app');
+  if (!container) return;
+  const ui = JSON.parse(container.dataset.gtUi || '{}') as Record<string, string>;
+  const els = getElements();
+  if (!els.exerciseSelect) return;
+  setupEventListeners(els, ui);
+  initTimer();
+  getCustomExercises().forEach(ex => addExerciseToSelect(els.exerciseSelect, ex.id, ex.name, ui));
+  updateUI(els, ui);
+}
+
+function getElements(): GTElements {
+  return {
+    exerciseSelect: document.getElementById('exerciseSelect') as HTMLSelectElement,
+    weightInput: document.getElementById('weightInput') as HTMLInputElement,
+    addLogBtn: document.getElementById('addLogBtn'),
+    clearHistoryBtn: document.getElementById('clearHistoryBtn'),
+    customExerciseInput: document.getElementById('customExerciseInput') as HTMLInputElement,
+    addCustomExerciseBtn: document.getElementById('addCustomExerciseBtn'),
+    toggleFormBtn: document.getElementById('toggleCustomExerciseBtn'),
+    closeFormBtn: document.getElementById('closeCustomExerciseBtn'),
+    form: document.getElementById('customExerciseForm'),
+    exportBtn: document.getElementById('exportDataBtn'),
+    exportMenu: document.getElementById('exportMenu'),
+    jsonBtn: document.getElementById('exportJsonBtn'),
+    csvBtn: document.getElementById('exportCsvBtn'),
+    modal: document.getElementById('confirmModal'),
+    confirmBtn: document.getElementById('confirmDeleteBtn'),
+    cancelBtn: document.getElementById('cancelDeleteBtn'),
+    list: document.getElementById('historyList'),
+    maxEl: document.getElementById('maxWeight'),
+    lastEl: document.getElementById('lastWeight'),
+    empty: document.getElementById('emptyState'),
+    chartPath: document.getElementById('chartPath') as unknown as SVGPathElement | null,
+    chartPoints: document.getElementById('chartPoints'),
+  };
+}
+
+function setupEventListeners(els: GTElements, ui: Record<string, string>) {
+  els.addLogBtn?.addEventListener('click', () => {
+    const w = parseFloat(els.weightInput.value);
+    if (!isNaN(w) && w > 0) {
+      saveLog(els.exerciseSelect.value, w);
+      els.weightInput.value = '';
+      updateUI(els, ui);
+    }
+  });
+  els.toggleFormBtn?.addEventListener('click', () => {
+    els.form?.classList.toggle('gt-hidden');
+    if (!els.form?.classList.contains('gt-hidden')) els.customExerciseInput?.focus();
+  });
+  els.closeFormBtn?.addEventListener('click', () => els.form?.classList.add('gt-hidden'));
+  els.addCustomExerciseBtn?.addEventListener('click', () => {
+    const name = els.customExerciseInput.value.trim();
+    if (name) {
+      const id = saveCustomExercise(name);
+      addExerciseToSelect(els.exerciseSelect, id, name, ui);
+      els.exerciseSelect.value = id;
+      els.customExerciseInput.value = '';
+      els.form?.classList.add('gt-hidden');
+      updateUI(els, ui);
+    }
+  });
+  setupExportAndModals(els, ui);
+}
+
+function setupExportAndModals(els: GTElements, ui: Record<string, string>) {
+  els.exportBtn?.addEventListener('click', (e: Event) => {
+    e.stopPropagation();
+    els.exportMenu?.classList.toggle('gt-hidden');
+  });
+  els.jsonBtn?.addEventListener('click', () => {
+    exportJSON(getHistory(), getCustomExercises());
+    els.exportMenu?.classList.add('gt-hidden');
+  });
+  els.csvBtn?.addEventListener('click', () => {
+    exportCSV(getHistory());
+    els.exportMenu?.classList.add('gt-hidden');
+  });
+  els.clearHistoryBtn?.addEventListener('click', () => els.modal?.classList.remove('gt-hidden'));
+  els.confirmBtn?.addEventListener('click', () => {
+    deleteExerciseHistory(els.exerciseSelect.value);
+    els.modal?.classList.add('gt-hidden');
+    updateUI(els, ui);
+  });
+  els.cancelBtn?.addEventListener('click', () => els.modal?.classList.add('gt-hidden'));
+  els.exerciseSelect?.addEventListener('change', () => updateUI(els, ui));
+}
+
+function addExerciseToSelect(select: HTMLSelectElement, id: string, name: string, ui: Record<string, string>) {
+  let group = select.querySelector('optgroup[data-group="custom"]') as HTMLOptGroupElement;
+  if (!group) {
+    group = document.createElement('optgroup');
+    group.label = ui.customExerciseCategory;
+    group.dataset.group = "custom";
+    select.appendChild(group);
+  }
+  const opt = document.createElement('option');
+  opt.value = id;
+  opt.textContent = name;
+  group.appendChild(opt);
+}
+
+function updateUI(els: GTElements, ui: Record<string, string>) {
+  const history = getHistory();
+  const logs = history[els.exerciseSelect.value] || [];
+  updateExerciseOptions(els.exerciseSelect, history, ui);
+  if (els.maxEl) els.maxEl.textContent = logs.length ? `${Math.max(...logs.map(l => l.weight))} ${ui.units}` : `0 ${ui.units}`;
+  if (els.lastEl) els.lastEl.textContent = logs.length ? `${logs[logs.length-1].weight} ${ui.units}` : `0 ${ui.units}`;
+  if (els.empty) els.empty.classList.toggle('gt-hidden', logs.length > 0);
+  if (els.list) renderHistoryTable(els.list, logs, ui, (idx) => {
+    deleteLog(els.exerciseSelect.value, idx);
+    updateUI(els, ui);
+  });
+  drawProgressChart(els.chartPath, els.chartPoints, logs);
+}
+
+function exportJSON(history: HistoryData, customExercises: CustomExercise[]) {
+  downloadFile(JSON.stringify({ exportDate: new Date().toISOString(), history, customExercises }, null, 2), `gym-tracker-${new Date().toISOString().split('T')[0]}.json`, 'application/json');
+}
+
+function exportCSV(history: HistoryData) {
+  const rows = ['Exercise,Date,Weight'];
+  Object.entries(history).forEach(([id, logs]) => {
+    logs.forEach(l => rows.push(`"${id}",${new Date(l.date).toLocaleDateString()},${l.weight}`));
+  });
+  downloadFile(rows.join('\n'), `gym-tracker-${new Date().toISOString().split('T')[0]}.csv`, 'text/csv');
+}
+
+function downloadFile(content: string, filename: string, type: string) {
+  const blob = new Blob([content], { type });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}

package/src/tool/gymTracker/seo.astro

@@ -0,0 +1,15 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { gymTracker } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await gymTracker.i18n[locale]?.();
+if (!content) return;
+---
+
+<SEORenderer content={{ locale: locale as string, sections: content.seo }} />

package/src/tool/gymTracker/storage.ts

@@ -0,0 +1,43 @@
+import type { HistoryData, CustomExercise } from "./types";
+
+const STORAGE_KEY = 'jjlmoya-gym-tracker-data';
+const CUSTOM_EXERCISES_KEY = 'jjlmoya-gym-tracker-custom';
+
+export function getHistory(): HistoryData {
+  const data = localStorage.getItem(STORAGE_KEY);
+  return data ? JSON.parse(data) : {};
+}
+
+export function saveLog(exerciseId: string, weight: number) {
+  const history = getHistory();
+  if (!history[exerciseId]) history[exerciseId] = [];
+  history[exerciseId].push({ date: new Date().toISOString(), weight });
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(history));
+}
+
+export function deleteLog(exerciseId: string, index: number) {
+  const history = getHistory();
+  if (history[exerciseId]) {
+    history[exerciseId].splice(index, 1);
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(history));
+  }
+}
+
+export function deleteExerciseHistory(exerciseId: string) {
+  const history = getHistory();
+  delete history[exerciseId];
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(history));
+}
+
+export function getCustomExercises(): CustomExercise[] {
+  const data = localStorage.getItem(CUSTOM_EXERCISES_KEY);
+  return data ? JSON.parse(data) : [];
+}
+
+export function saveCustomExercise(name: string): string {
+  const custom = getCustomExercises();
+  const id = `custom-${Date.now()}`;
+  custom.push({ id, name });
+  localStorage.setItem(CUSTOM_EXERCISES_KEY, JSON.stringify(custom));
+  return id;
+}

package/src/tool/gymTracker/timer.ts

@@ -0,0 +1,126 @@
+const TIMER_STORAGE_KEY = 'jjlmoya-gym-tracker-data-timer';
+
+interface TimerState {
+  interval: number | null;
+  timeLeft: number;
+  initialTime: number;
+}
+
+interface TimerElements {
+  display: HTMLElement | null;
+  startBtn: HTMLElement | null;
+  resetBtn: HTMLElement | null;
+  progress: HTMLElement | null;
+  customInput: HTMLInputElement | null;
+  setCustomBtn: HTMLElement | null;
+  presets: NodeListOf<Element>;
+}
+
+export function initTimer() {
+  const els = getTimerElements();
+  if (!els.display) return;
+
+  const state: TimerState = {
+    interval: null,
+    timeLeft: 0,
+    initialTime: 0
+  };
+
+  setupTimerEvents(els, state);
+  restoreTimerState(els, state);
+  updateTimerUI(els, state);
+}
+
+function getTimerElements(): TimerElements {
+  return {
+    display: document.getElementById('timerDisplay'),
+    startBtn: document.getElementById('startTimerBtn'),
+    resetBtn: document.getElementById('resetTimerBtn'),
+    progress: document.getElementById('timerProgress'),
+    customInput: document.getElementById('customTimerInput') as HTMLInputElement | null,
+    setCustomBtn: document.getElementById('setCustomTimerBtn'),
+    presets: document.querySelectorAll('.preset-btn')
+  };
+}
+
+function setupTimerEvents(els: TimerElements, state: TimerState) {
+  els.startBtn?.addEventListener('click', () => {
+    if (state.timeLeft > 0 && !state.interval) startTimer(els, state, state.timeLeft);
+  });
+
+  els.resetBtn?.addEventListener('click', () => {
+    stopTimer(els, state);
+    state.timeLeft = 0;
+    state.initialTime = 0;
+    updateTimerUI(els, state);
+  });
+
+  els.presets.forEach((btn: Element) => {
+    (btn as HTMLElement).onclick = () => startTimer(els, state, parseInt((btn as HTMLElement).dataset.seconds || '0'));
+  });
+
+  if (els.setCustomBtn) {
+    els.setCustomBtn.onclick = () => {
+      const s = parseInt(els.customInput?.value || '0');
+      if (!isNaN(s) && s > 0) startTimer(els, state, s);
+    };
+  }
+}
+
+function startTimer(els: TimerElements, state: TimerState, seconds: number) {
+  stopTimer(els, state);
+  state.timeLeft = seconds;
+  state.initialTime = seconds;
+  els.display?.classList.add('gt-timer-active');
+  
+  state.interval = window.setInterval(() => {
+    state.timeLeft--;
+    if (state.timeLeft <= 0) {
+      state.timeLeft = 0;
+      stopTimer(els, state);
+    } else {
+      saveTimerState(state);
+    }
+    updateTimerUI(els, state);
+  }, 1000);
+  
+  saveTimerState(state);
+  updateTimerUI(els, state);
+}
+
+function stopTimer(els: TimerElements, state: TimerState) {
+  if (state.interval) clearInterval(state.interval);
+  state.interval = null;
+  localStorage.removeItem(TIMER_STORAGE_KEY);
+  els.display?.classList.remove('gt-timer-active');
+}
+
+function updateTimerUI(els: TimerElements, state: TimerState) {
+  if (!els.display) return;
+  const m = Math.floor(state.timeLeft / 60);
+  const s = state.timeLeft % 60;
+  els.display.textContent = `${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`;
+  if (els.progress && state.initialTime > 0) {
+    els.progress.style.width = `${(state.timeLeft / state.initialTime) * 100}%`;
+  }
+}
+
+function saveTimerState(state: TimerState) {
+  if (state.interval && state.timeLeft > 0) {
+    const endTime = Date.now() + (state.timeLeft * 1000);
+    localStorage.setItem(TIMER_STORAGE_KEY, JSON.stringify({ endTime, initialTime: state.initialTime }));
+  }
+}
+
+function restoreTimerState(els: TimerElements, state: TimerState) {
+  const data = localStorage.getItem(TIMER_STORAGE_KEY);
+  if (!data) return;
+  const { endTime, initialTime } = JSON.parse(data);
+  const remaining = Math.round((endTime - Date.now()) / 1000);
+  if (remaining > 0) {
+    state.initialTime = initialTime;
+    startTimer(els, state, remaining);
+  } else {
+    localStorage.removeItem(TIMER_STORAGE_KEY);
+  }
+}

package/src/tool/gymTracker/types.ts

@@ -0,0 +1,11 @@
+export interface LogEntry { 
+  date: string; 
+  weight: number; 
+}
+
+export type HistoryData = Record<string, LogEntry[]>;
+
+export interface CustomExercise { 
+  id: string; 
+  name: string; 
+}