@jjlmoya/utils-sports 1.12.0 → 1.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-sports",
-    "version": "1.12.0",
+    "version": "1.14.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/pages/[locale]/[slug].astro

@@ -34,18 +34,28 @@ export async function getStaticPaths() {
       ]),
     ) as Partial<Record<KnownLocale, string>>;
 
+    const firstLoader = entry.i18n.en ?? Object.values(entry.i18n)[0];
+    const englishSlug = firstLoader ? (await firstLoader()).slug : entry.id;
+
     for (const { locale, content } of localeContents) {
-      const allToolsNav = await Promise.all(
-        ALL_TOOLS.map(async ({ entry: navEntry }) => ({
-          id: navEntry.id,
-          title: (await navEntry.i18n[locale]!()).title,
-          href: `/${locale}/${(await navEntry.i18n[locale]!()).slug}`,
-          isActive: navEntry.id === entry.id,
-        })),
-      );
+      const allToolsNav = (
+        await Promise.all(
+          ALL_TOOLS.map(async ({ entry: navEntry }) => {
+            const loader = navEntry.i18n[locale] ?? navEntry.i18n.en;
+            if (!loader) return null;
+            const navContent = await loader();
+            return {
+              id: navEntry.id,
+              title: navContent.title,
+              href: `/${locale}/${navContent.slug}`,
+              isActive: navEntry.id === entry.id,
+            };
+          }),
+        )
+      ).filter(Boolean) as NavItem[];
       paths.push({
         params: { locale, slug: content.slug },
-        props: { Component, locale, content, localeUrls, allToolsNav },
+        props: { Component, locale, content, localeUrls, allToolsNav, englishSlug },
       });
     }
   }
@@ -66,11 +76,16 @@ interface Props {
   content: ToolLocaleContent;
   localeUrls: Partial<Record<KnownLocale, string>>;
   allToolsNav: NavItem[];
+  englishSlug: string;
 }
 
-const { Component, locale, content, localeUrls, allToolsNav } = Astro.props;
+const { Component, locale, content, localeUrls, allToolsNav, englishSlug } = Astro.props;
+
+const cssFiles = import.meta.glob("../../tool/**" + "/" + "*.css", { query: "?raw", import: "default" });
+const cssKey = Object.keys(cssFiles).find((k) => k.endsWith(`/${englishSlug}.css`));
+const toolCss = cssKey ? await cssFiles[cssKey]() as string : "";
 
-const seoContent: UtilitySEOContent = { locale, sections: content.seo };
+const seoContent: UtilitySEOContent = { locale, sections: content.seo ?? [] };
 
 const words = content.title.split(" ");
 const titleHighlight = words[0] || "";
@@ -89,8 +104,9 @@ const titleBase = words.slice(1).join(" ") || "";
     tools={allToolsNav}
   />
   <Fragment slot="head">
+    {toolCss ? <Fragment set:html={`<style is:inline>${toolCss}</style>`} /> : null}
     {
-      content.schemas.map((schema: unknown) => (
+      ( content.schemas ?? []).map((schema: unknown) => (
         <script
           is:inline
           type="application/ld+json"
@@ -116,11 +132,11 @@ const titleBase = words.slice(1).join(" ") || "";
     </section>
 
     <section class="section-faq">
-      <FAQSection items={content.faq} title={content.ui.faqTitle} inLanguage={locale} />
+      <FAQSection items={content.faq} inLanguage={locale} />
     </section>
 
     <section class="section-bibliography">
-      <Bibliography links={content.bibliography} title={content.ui.bibliographyTitle} />
+      <Bibliography links={content.bibliography} />
     </section>
   </div>
 </PreviewLayout>

package/src/tests/locale_completeness.test.ts

@@ -1,42 +1,8 @@
 import { describe, it, expect } from 'vitest';
 import { ALL_TOOLS } from '../tools';
-import type { ToolLocaleContent } from '../types';
 
 describe('Locale Completeness Validation', () => {
-  ALL_TOOLS.forEach((tool) => {
-    describe(`Tool: ${tool.entry.id}`, () => {
-      Object.keys(tool.entry.i18n).forEach((locale) => {
-        describe(`Locale: ${locale}`, () => {
-          it('faqTitle should be defined when faq items exist', async () => {
-            const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
-            const content = (await loader?.()) as ToolLocaleContent;
-
-            if (content.faq.length > 0) {
-              expect(
-                content.faqTitle,
-                `Tool "${tool.entry.id}" locale "${locale}" has ${content.faq.length} FAQ items but is missing faqTitle`,
-              ).toBeTruthy();
-            }
-          });
-
-          it('bibliographyTitle should be defined when bibliography items exist', async () => {
-            const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
-            const content = (await loader?.()) as ToolLocaleContent;
-
-            if (content.bibliography.length > 0) {
-              expect(
-                content.bibliographyTitle,
-                `Tool "${tool.entry.id}" locale "${locale}" has ${content.bibliography.length} bibliography items but is missing bibliographyTitle`,
-              ).toBeTruthy();
-            }
-          });
-        });
-      });
-    });
-  });
-
-  it('all 10 tools registered', () => {
+  it('all tools registered', () => {
     expect(ALL_TOOLS.length).toBe(4);
   });
 });
-

package/src/tests/shared-test-helpers.ts

@@ -0,0 +1,56 @@
+import type { ToolDefinition } from '../types';
+
+export interface ToolExportValidationResult {
+  passed: boolean;
+  failures: string[];
+}
+
+function validateComponentType(
+  toolId: string,
+  componentName: string,
+  component: unknown,
+  failures: string[],
+): void {
+  if (typeof component !== 'function') {
+    failures.push(`${toolId}: ${componentName} is not a function (${typeof component})`);
+  }
+}
+
+async function validateComponentExecution(
+  toolId: string,
+  componentName: string,
+  fn: () => Promise<unknown>,
+  failures: string[],
+): Promise<void> {
+  try {
+    const result = await fn();
+    if (!result || typeof result !== 'object') {
+      failures.push(`${toolId}: ${componentName} import returned invalid result`);
+    }
+  } catch (error) {
+    failures.push(`${toolId}: ${componentName} execution error - ${error instanceof Error ? error.message : 'unknown'}`);
+  }
+}
+
+export async function validateToolExports(tools: ToolDefinition[]): Promise<ToolExportValidationResult> {
+  const failures: string[] = [];
+
+  for (const tool of tools) {
+    validateComponentType(tool.entry.id, 'Component', tool.Component, failures);
+    validateComponentType(tool.entry.id, 'SEOComponent', tool.SEOComponent, failures);
+    validateComponentType(tool.entry.id, 'BibliographyComponent', tool.BibliographyComponent, failures);
+
+    const componentFn = tool.Component as () => Promise<unknown>;
+    const seoFn = tool.SEOComponent as () => Promise<unknown>;
+    const bibFn = tool.BibliographyComponent as () => Promise<unknown>;
+
+    await validateComponentExecution(tool.entry.id, 'Component', componentFn, failures);
+    await validateComponentExecution(tool.entry.id, 'SEOComponent', seoFn, failures);
+    await validateComponentExecution(tool.entry.id, 'BibliographyComponent', bibFn, failures);
+  }
+
+  return {
+    passed: failures.length === 0,
+    failures,
+  };
+}

package/src/tests/tool_exports.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import { validateToolExports } from './shared-test-helpers';
+
+describe('Tool Exports Pattern Validation', () => {
+  describe('Component Exports Format', () => {
+    ALL_TOOLS.forEach((tool) => {
+      it(`${tool.entry.id}: Component should be a lazy-loaded function`, () => {
+        expect(typeof tool.Component).toBe('function');
+        expect(tool.Component).toBeInstanceOf(Function);
+      });
+
+      it(`${tool.entry.id}: SEOComponent should be a lazy-loaded function`, () => {
+        expect(typeof tool.SEOComponent).toBe('function');
+        expect(tool.SEOComponent).toBeInstanceOf(Function);
+      });
+
+      it(`${tool.entry.id}: BibliographyComponent should be a lazy-loaded function`, () => {
+        expect(typeof tool.BibliographyComponent).toBe('function');
+        expect(tool.BibliographyComponent).toBeInstanceOf(Function);
+      });
+    });
+  });
+
+  describe('Dynamic Import Validation', () => {
+    it('all tools must have functional dynamic imports', async () => {
+      const result = await validateToolExports(ALL_TOOLS);
+      if (!result.passed) {
+        throw new Error(`Tool export validation failed:\n${result.failures.join('\n')}`);
+      }
+      expect(result.passed).toBe(true);
+    });
+  });
+});

package/src/tool/gymTracker/bibliography.astro

@@ -1,15 +1,6 @@
 ---
-import { Bibliography } 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;
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { bibliography } from './bibliography';
 ---
 
-<Bibliography links={content.bibliography} title={content.bibliographyTitle} />
+<SharedBibliography links={bibliography} />

package/src/tool/gymTracker/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    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/',
+  },
+];

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

@@ -1,3 +1,4 @@
+import { bibliography } from '../bibliography';
 import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
 import type { ToolLocaleContent } from '../../../types';
 import type { GymTrackerUI } from '../ui';
@@ -11,41 +12,41 @@ const faqData = [
   {
     question: 'Was ist der Zweck der Trainingsverfolgung?',
     answer:
-      'Es dient dazu, progressive Überlastung wissenschaftlich anzuwenden. Indem Sie genau wissen, wie viel Sie in der vorherigen Sitzung gehoben haben, können Sie versuchen, diese Marke zu übertreffen, was Muskelwachstum und langfristige Kraftgewinne garantiert.',
+      'Es dient dazu, progressive Überlastung wissenschaftlich anzuwenden. Indem Sie genau wissen, wie viel Sie in der vorherigen Sitzung gehoben haben, können Sie versuchen, diese Marke zu übertreffen, was Muskelwachstum und langfristige Kraftgewinne garantiert.'
   },
   {
     question: 'Welche Daten sollte ich aufzeichnen?',
     answer:
-      'Das Wichtigste ist das maximale Gewicht (Top Set), das Sie mit guter Form für eine festgelegte Anzahl von Wiederholungen erreicht haben. Unser Tool konzentriert sich auf die Aufzeichnung des Gewichts pro Sitzung, um Ihr Fortschrittsdiagramm zu erstellen.',
+      'Das Wichtigste ist das maximale Gewicht (Top Set), das Sie mit guter Form für eine festgelegte Anzahl von Wiederholungen erreicht haben. Unser Tool konzentriert sich auf die Aufzeichnung des Gewichts pro Sitzung, um Ihr Fortschrittsdiagramm zu erstellen.'
   },
   {
     question: 'Wie werden die Diagramme interpretiert?',
     answer:
-      'Eine ansteigende Linie zeigt an, dass Sie Fortschritte machen. Eine flache Linie (Plateau) deutet darauf hin, dass Sie Ihr Volumen, Ihre Intensität oder Ihre Erholung anpassen müssen. Eine anhaltend fallende Linie kann ein Zeichen für Übertraining sein.',
+      'Eine ansteigende Linie zeigt an, dass Sie Fortschritte machen. Eine flache Linie (Plateau) deutet darauf hin, dass Sie Ihr Volumen, Ihre Intensität oder Ihre Erholung anpassen müssen. Eine anhaltend fallende Linie kann ein Zeichen für Übertraining sein.'
   },
   {
     question: 'Wo werden meine Daten gespeichert?',
     answer:
-      'Die Daten werden lokal in Ihrem Browser (Local Storage) gespeichert. Dies bedeutet, dass Ihre Privatsphäre absolut gewahrt bleibt und Sie kein Konto erstellen müssen. Wenn Sie jedoch die Browserdaten löschen, geht der Verlauf verloren.',
+      'Die Daten werden lokal in Ihrem Browser (Local Storage) gespeichert. Dies bedeutet, dass Ihre Privatsphäre absolut gewahrt bleibt und Sie kein Konto erstellen müssen. Wenn Sie jedoch die Browserdaten löschen, geht der Verlauf verloren.'
   },
 ];
 
 const howToData = [
   {
     name: 'Wählen Sie die Übung aus',
-    text: 'Wählen Sie im Dropdown-Menü aus Grundübungen wie Kniebeugen, Bankdrücken oder Kreuzheben.',
+    text: 'Wählen Sie im Dropdown-Menü aus Grundübungen wie Kniebeugen, Bankdrücken oder Kreuzheben.'
   },
   {
     name: 'Geben Sie das Gewicht ein',
-    text: 'Geben Sie nach Ihrem schwersten Satz das gehobene Gewicht in Kilogramm/Pfund in das entsprechende Feld ein.',
+    text: 'Geben Sie nach Ihrem schwersten Satz das gehobene Gewicht in Kilogramm/Pfund in das entsprechende Feld ein.'
   },
   {
     name: 'Drücken Sie auf Hinzufügen',
-    text: 'Speichern Sie Ihre Marke. Das System aktualisiert automatisch Ihren Verlauf und Ihr Fortschrittsdiagramm.',
+    text: 'Speichern Sie Ihre Marke. Das System aktualisiert automatisch Ihren Verlauf und Ihr Fortschrittsdiagramm.'
   },
   {
     name: 'Analysieren Sie Ihre Entwicklung',
-    text: 'Konsultieren Sie regelmäßig das Diagramm, um Plateaus zu identifizieren und sich durch Ihren realen Kraftzuwachs zu motivieren.',
+    text: 'Konsultieren Sie regelmäßig das Diagramm, um Plateaus zu identifizieren und sich durch Ihren realen Kraftzuwachs zu motivieren.'
   },
 ];
 
@@ -55,8 +56,8 @@ const faqSchema: WithContext<FAQPage> = {
   mainEntity: faqData.map((item) => ({
     '@type': 'Question',
     name: item.question,
-    acceptedAnswer: { '@type': 'Answer', text: item.answer },
-  })),
+    acceptedAnswer: { '@type': 'Answer', text: item.answer }
+  }))
 };
 
 const howToSchema: WithContext<HowTo> = {
@@ -68,8 +69,8 @@ const howToSchema: WithContext<HowTo> = {
     '@type': 'HowToStep',
     position: i + 1,
     name: step.name,
-    text: step.text,
-  })),
+    text: step.text
+  }))
 };
 
 const appSchema: WithContext<SoftwareApplication> = {
@@ -80,50 +81,35 @@ const appSchema: WithContext<SoftwareApplication> = {
   applicationCategory: 'HealthApplication',
   operatingSystem: 'All',
   offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
-  inLanguage: 'de',
+  inLanguage: 'de'
 };
 
 export const content: ToolLocaleContent<GymTrackerUI & Record<string, string>> = {
   slug,
   title,
   description,
-  faqTitle: 'Häufig gestellte Fragen',
   faq: faqData,
-  bibliographyTitle: 'Wissenschaftliche Referenzen',
-  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/',
-    },
-  ],
+  bibliography,
   howTo: howToData,
   schemas: [faqSchema, howToSchema, appSchema],
   seo: [
     {
       type: 'title',
       text: 'Fitness-Tracking: Der Schlüssel zu echtem Fortschritt',
-      level: 2,
+      level: 2
     },
     {
       type: 'paragraph',
-      html: 'In der Welt von Fitness und Bodybuilding gibt es ein fundamentales Prinzip, das diejenigen trennt, die erstaunliche Ergebnisse erzielen, von denen, die schnell stagnieren: <strong>progressive Überlastung</strong>. Es ist jedoch unmöglich, dieses Prinzip effektiv anzuwenden, wenn Sie keine detaillierten Aufzeichnungen über Ihre Hebungen führen. In diesem Leitfaden werden wir untersuchen, warum die Verfolgung Ihres Trainings lebenswichtig ist, wie Sie unseren <strong>Fitness-Tracker</strong> nutzen können, um Ihre Gewinne zu maximieren, und welche wissenschaftlichen Grundlagen diese Praxis unterstützen.',
+      html: 'In der Welt von Fitness und Bodybuilding gibt es ein fundamentales Prinzip, das diejenigen trennt, die erstaunliche Ergebnisse erzielen, von denen, die schnell stagnieren: <strong>progressive Überlastung</strong>. Es ist jedoch unmöglich, dieses Prinzip effektiv anzuwenden, wenn Sie keine detaillierten Aufzeichnungen über Ihre Hebungen führen. In diesem Leitfaden werden wir untersuchen, warum die Verfolgung Ihres Trainings lebenswichtig ist, wie Sie unseren <strong>Fitness-Tracker</strong> nutzen können, um Ihre Gewinne zu maximieren, und welche wissenschaftlichen Grundlagen diese Praxis unterstützen.'
     },
     {
       type: 'title',
       text: 'Was ist progressive Überlastung?',
-      level: 3,
+      level: 3
     },
     {
       type: 'paragraph',
-      html: 'Progressive Überlastung ist die allmähliche Steigerung der Belastung, die während körperlicher Betätigung auf den Körper ausgeübt wird. Damit ein Muskel wächst oder stärker wird, muss er einem Reiz ausgesetzt werden, der größer ist als der, an den er gewöhnt ist. Wenn Sie ins Fitnessstudio gehen und immer das gleiche Gewicht mit den gleichen Wiederholungen und der gleichen Ruhezeit heben, hat Ihr Körper keinen biologischen Grund, sich anzupassen und zu wachsen.',
+      html: 'Progressive Überlastung ist die allmähliche Steigerung der Belastung, die während körperlicher Betätigung auf den Körper ausgeübt wird. Damit ein Muskel wächst oder stärker wird, muss er einem Reiz ausgesetzt werden, der größer ist als der, an den er gewöhnt ist. Wenn Sie ins Fitnessstudio gehen und immer das gleiche Gewicht mit den gleichen Wiederholungen und der gleichen Ruhezeit heben, hat Ihr Körper keinen biologischen Grund, sich anzupassen und zu wachsen.'
     },
     {
       type: 'list',
@@ -133,48 +119,48 @@ export const content: ToolLocaleContent<GymTrackerUI & Record<string, string>> =
         'Volumensteigerung: Durchführung von insgesamt mehr Sätzen pro Muskelgruppe.',
         'Ruhereduktion: Die gleiche Arbeit in kürzerer Zeit erledigen.',
         'Formverbesserung: Ausführung der Übung mit überlegener Kontrolle und größerem Bewegungsspielraum.',
-      ],
+      ]
     },
     {
       type: 'title',
       text: 'Warum manuelles Protokollieren dem Gedächtnis überlegen ist',
-      level: 3,
+      level: 3
     },
     {
       type: 'paragraph',
-      html: 'Viele Sportler machen den Fehler, ihrem Gedächtnis zu vertrauen, um sich daran zu erinnern, wie viel sie letzte Woche gehoben haben. Bei einem typischen Training, das zwischen 5 und 10 verschiedene Übungen umfasst, vergisst man jedoch leicht, ob man beim Bankdrücken 80 kg oder 82,5 kg geschafft hat oder ob es 10 oder 12 Wiederholungen waren. Dieser Mangel an Präzision führt zur Mittelmäßigkeit.',
+      html: 'Viele Sportler machen den Fehler, ihrem Gedächtnis zu vertrauen, um sich daran zu erinnern, wie viel sie letzte Woche gehoben haben. Bei einem typischen Training, das zwischen 5 und 10 verschiedene Übungen umfasst, vergisst man jedoch leicht, ob man beim Bankdrücken 80 kg oder 82,5 kg geschafft hat oder ob es 10 oder 12 Wiederholungen waren. Dieser Mangel an Präzision führt zur Mittelmäßigkeit.'
     },
     {
       type: 'tip',
       title: 'Die Kraft der Visualisierung von Fortschritt',
-      html: 'Eine ansteigende Linie in einem Diagramm zu sehen, gibt Ihnen den nötigen Schub, um die zusätzliche Wiederholung zu versuchen, die den Unterschied zwischen Stagnation und konsistentem Muskelwachstum ausmacht.',
+      html: 'Eine ansteigende Linie in einem Diagramm zu sehen, gibt Ihnen den nötigen Schub, um die zusätzliche Wiederholung zu versuchen, die den Unterschied zwischen Stagnation und konsistentem Muskelwachstum ausmacht.'
     },
     {
       type: 'title',
       text: 'Grundübungen für das Tracking',
-      level: 3,
+      level: 3
     },
     {
       type: 'paragraph',
-      html: 'Obwohl alle Übungen wertvoll sind, bieten bestimmte Verbundübungen den besten Überblick über Ihre Gesamtkraft und körperliche Entwicklung. Diese sollten Sie bei Ihrem Tracking priorisieren: <strong>Bankdrücken</strong> für horizontales Drücken, <strong>Überkopfdrücken</strong> für vertikales Drücken, <strong>Klimmzüge</strong> für Zugübungen und <strong>Hip Thrusts</strong> für die Gesäßmuskulatur.',
+      html: 'Obwohl alle Übungen wertvoll sind, bieten bestimmte Verbundübungen den besten Überblick über Ihre Gesamtkraft und körperliche Entwicklung. Diese sollten Sie bei Ihrem Tracking priorisieren: <strong>Bankdrücken</strong> für horizontales Drücken, <strong>Überkopfdrücken</strong> für vertikales Drücken, <strong>Klimmzüge</strong> für Zugübungen und <strong>Hip Thrusts</strong> für die Gesäßmuskulatur.'
     },
     {
       type: 'title',
       text: 'So analysieren Sie Ihre Fortschrittsdiagramme',
-      level: 3,
+      level: 3
     },
     {
       type: 'paragraph',
-      html: 'Sobald Sie mehrere Trainingseinheiten aufgezeichnet haben, werden Sie Muster erkennen: eine <strong>konstant ansteigende Linie</strong> zeigt den richtigen Weg an, ein <strong>Plateau</strong> deutet darauf hin, dass Sie Ihr Volumen oder Ihre Ruhe anpassen müssen, und ein <strong>Abwärtstrend</strong> kann ein Zeichen für akkumulierte Ermüdung sein.',
+      html: 'Sobald Sie mehrere Trainingseinheiten aufgezeichnet haben, werden Sie Muster erkennen: eine <strong>konstant ansteigende Linie</strong> zeigt den richtigen Weg an, ein <strong>Plateau</strong> deutet darauf hin, dass Sie Ihr Volumen oder Ihre Ruhe anpassen müssen, und ein <strong>Abwärtstrend</strong> kann ein Zeichen für akkumulierte Ermüdung sein.'
     },
     {
       type: 'title',
       text: 'Die Psychologie des Erfolgs im Fitnessstudio',
-      level: 3,
+      level: 3
     },
     {
       type: 'paragraph',
-      html: 'Training ist sowohl eine mentale als auch eine körperliche Herausforderung. Durch die Verwendung eines visuellen Werkzeugs, das Ihnen zeigt, dass Sie heute 1 % stärker sind als vor vierzehn Tagen, füttern Sie Ihr Dopamin-Belohnungssystem. Dies schafft eine positive Rückkopplungsschleife, die das Training zu einer nachhaltigen Gewohnheit macht.',
+      html: 'Training ist sowohl eine mentale als auch eine körperliche Herausforderung. Durch die Verwendung eines visuellen Werkzeugs, das Ihnen zeigt, dass Sie heute 1 % stärker sind als vor vierzehn Tagen, füttern Sie Ihr Dopamin-Belohnungssystem. Dies schafft eine positive Rückkopplungsschleife, die das Training zu einer nachhaltigen Gewohnheit macht.'
     },
   ],
   ui: {
@@ -220,6 +206,6 @@ export const content: ToolLocaleContent<GymTrackerUI & Record<string, string>> =
     lunges: 'Ausfallschritte',
     gluteKick: 'Kickbacks am Kabel',
     hipAbduction: 'Abduktorenmaschine',
-    stepUp: 'Step Ups',
-  },
+    stepUp: 'Step Ups'
+  }
 };