@jjlmoya/utils-sports 1.59.0 → 1.61.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-sports",
-    "version": "1.59.0",
+    "version": "1.61.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",
@@ -27,7 +27,8 @@
         "lint": "eslint src/ --max-warnings 0 && stylelint \"src/**/*.{css,astro}\"",
         "check": "astro check",
         "type-check": "astro check",
-        "test": "vitest run --reporter=verbose --testTimeout=30000",
+        "test": "vitest run --exclude src/tests/qa_*.test.ts --reporter=verbose --testTimeout=30000",
+        "qa:audit": "vitest run src/tests/qa_*.test.ts --reporter=verbose",
         "preversion": "npm run lint && npm run test && npm run build",
         "postversion": "git push && git push --tags",
         "patch": "npm version patch",

package/src/tests/mfe_assets_contract.test.ts

@@ -0,0 +1,48 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import { CATEGORY_OG_IMAGE, getUtilityOgImage } from '../mfe/assets';
+
+const categoryImageMatch = CATEGORY_OG_IMAGE.match(
+  /^(\/_utilities\/[^/]+\/images)\/([^/]+\.webp)\?version=(.+)$/,
+);
+
+if (!categoryImageMatch) {
+  throw new Error(`Unexpected CATEGORY_OG_IMAGE format: ${CATEGORY_OG_IMAGE}`);
+}
+
+const [, imageUrlRoot, categoryImage, assetVersion] = categoryImageMatch;
+const assetRoot = join(process.cwd(), 'public', imageUrlRoot.slice(1));
+const categorySlug = basename(categoryImage, '.webp');
+
+describe('MFE asset contract', () => {
+  it('has one non-empty English-slug OG image per category and registered tool', async () => {
+    const expectedSlugs = new Set([categorySlug]);
+
+    for (const { entry } of ALL_TOOLS) {
+      const englishLoader = entry.i18n.en;
+      if (!englishLoader) throw new Error(`Missing English locale for ${entry.id}`);
+
+      const englishContent = await englishLoader();
+      expectedSlugs.add(englishContent.slug);
+    }
+
+    const actualSlugs = new Set(
+      readdirSync(assetRoot)
+        .filter((filename) => filename.endsWith('.webp'))
+        .map((filename) => filename.slice(0, -'.webp'.length)),
+    );
+
+    expect(actualSlugs).toEqual(expectedSlugs);
+
+    for (const slug of expectedSlugs) {
+      const imagePath = join(assetRoot, `${slug}.webp`);
+      expect(existsSync(imagePath), `${imagePath} should exist`).toBe(true);
+      expect(statSync(imagePath).size, `${imagePath} should not be empty`).toBeGreaterThan(0);
+      expect(getUtilityOgImage(slug)).toBe(
+        `${imageUrlRoot}/${slug}.webp?version=${assetVersion}`,
+      );
+    }
+  }, 30000);
+});

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

@@ -0,0 +1,32 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+export const repositoryRoot = process.cwd();
+export const toolRoot = join(repositoryRoot, 'src', 'tool');
+
+export function listToolDirectories(): string[] {
+  return readdirSync(toolRoot)
+    .map((name) => join(toolRoot, name))
+    .filter((path) => statSync(path).isDirectory());
+}
+
+export function findFiles(directory: string, extensions: string[]): string[] {
+  const files: string[] = [];
+
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) files.push(...findFiles(path, extensions));
+    else if (extensions.some((extension) => entry.name.endsWith(extension))) files.push(path);
+  }
+
+  return files;
+}
+
+export function read(path: string): string {
+  return readFileSync(path, 'utf8');
+}
+
+export function displayPath(path: string): string {
+  return relative(repositoryRoot, path).replace(/\\/g, '/');
+}
+

package/src/tests/qa_bibliography_links.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+interface LinkFailure {
+  tool: string;
+  message: string;
+}
+
+function validateUrl(tool: string, rawUrl: string, seen: Set<string>): LinkFailure[] {
+  let url: URL;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    return [{ tool, message: `invalid URL: ${rawUrl}` }];
+  }
+
+  const failures: LinkFailure[] = [];
+  if (url.protocol !== 'https:') failures.push({ tool, message: `non-HTTPS URL: ${rawUrl}` });
+  if (url.pathname === '/' && !url.search && !url.hash) {
+    failures.push({ tool, message: `generic homepage, cite the exact document: ${rawUrl}` });
+  }
+  if (seen.has(url.href)) failures.push({ tool, message: `duplicate source URL: ${rawUrl}` });
+  seen.add(url.href);
+  return failures;
+}
+
+describe('QA: bibliography links are specific and usable', () => {
+  it('uses unique HTTPS links to exact source pages instead of generic homepages', async () => {
+    const failures: LinkFailure[] = [];
+
+    for (const tool of ALL_TOOLS) {
+      const loader = tool.entry.i18n.en;
+      if (!loader) {
+        failures.push({ tool: tool.entry.id, message: 'English locale loader is missing' });
+        continue;
+      }
+
+      const content = (await loader()) as ToolLocaleContent;
+      const seen = new Set<string>();
+
+      for (const entry of content.bibliography ?? []) {
+        failures.push(...validateUrl(tool.entry.id, entry.url, seen));
+      }
+    }
+
+    const messages = failures.map(({ tool, message }) => `${tool}: ${message}`);
+    expect(messages, `Bibliography hygiene failures:\n${messages.join('\n')}`).toEqual([]);
+  });
+});

package/src/tests/qa_claim_evidence.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { displayPath, listToolDirectories, read } from './qa-test-helpers';
+
+const evidenceClaims = [
+  /\bofficial algorithm\b/i,
+  /\balgoritmo oficial\b/i,
+  /\b(?:records|data|rates|tables) updated(?:\s+(?:to|through)\s+20\d{2})?\b/i,
+  /\b(?:registros|datos|tasas|tablas) actualizad[oa]s?(?:\s+(?:a|hasta)\s+20\d{2})?\b/i,
+  /\b(?:validated|verified) (?:method|algorithm|calculation)\b/i,
+  /\b(?:método|algoritmo|cálculo) (?:validado|verificado)\b/i,
+  /\b(?:guarantees|ensures)\b/i,
+  /\bgarantiza\b/i,
+  /\bofficial (?:data|rate|calculation)\b/i,
+  /\b(?:datos|tasa|cálculo) oficial(?:es)?\b/i,
+];
+
+const requiredEvidenceFields = [
+  'reviewedAt',
+  'methodology',
+  'sources',
+  'referenceCases',
+  'limitations',
+];
+
+describe('QA: strong factual claims are traceable', () => {
+  it('requires machine-readable validation evidence beside tools making strong claims', () => {
+    const failures: string[] = [];
+
+    for (const directory of listToolDirectories()) {
+      const localePaths = ['en', 'es']
+        .map((locale) => join(directory, 'i18n', `${locale}.ts`))
+        .filter(existsSync);
+      const claims = localePaths.flatMap((path) => {
+        const source = read(path);
+        return evidenceClaims
+          .filter((pattern) => pattern.test(source))
+          .map((pattern) => `${displayPath(path)} matches ${pattern.source}`);
+      });
+      if (claims.length === 0) continue;
+
+      const evidencePath = join(directory, 'validation.ts');
+      if (!existsSync(evidencePath)) {
+        failures.push(`${displayPath(evidencePath)} missing; claims: ${claims.join(' | ')}`);
+        continue;
+      }
+
+      const evidence = read(evidencePath);
+      const missingFields = requiredEvidenceFields.filter(
+        (field) => !new RegExp(`\\b${field}\\s*:`).test(evidence),
+      );
+      if (missingFields.length > 0) {
+        failures.push(`${displayPath(evidencePath)} missing fields: ${missingFields.join(', ')}`);
+      }
+    }
+
+    expect(
+      failures,
+      [
+        'Claims such as official, validated, guaranteed or updated need inspectable evidence.',
+        'Add validation.ts with reviewedAt, methodology, sources, referenceCases and limitations,',
+        'or weaken/remove the unsupported claim.',
+        ...failures,
+      ].join('\n'),
+    ).toEqual([]);
+  });
+});
+

package/src/tests/qa_logic_reference_coverage.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+import { basename, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import {
+  displayPath,
+  findFiles,
+  listToolDirectories,
+  read,
+  repositoryRoot,
+} from './qa-test-helpers';
+
+function hasDedicatedLogicTest(toolDirectory: string): boolean {
+  const localCandidates = [
+    join(toolDirectory, 'logic.test.ts'),
+    join(toolDirectory, 'logic.spec.ts'),
+    join(toolDirectory, '__tests__', 'logic.test.ts'),
+    join(toolDirectory, '__tests__', 'logic.spec.ts'),
+  ];
+  if (localCandidates.some(existsSync)) return true;
+
+  const toolName = basename(toolDirectory);
+  const centralTests = findFiles(join(repositoryRoot, 'src', 'tests'), ['.test.ts', '.spec.ts']);
+  return centralTests.some((testPath) => {
+    const source = read(testPath).replace(/\\/g, '/');
+    return source.includes(`/tool/${toolName}/logic`) || source.includes(`../tool/${toolName}/logic`);
+  });
+}
+
+describe('QA: calculation logic has reference tests', () => {
+  it('gives every public calculator logic module its own behavioral test suite', () => {
+    const failures = listToolDirectories()
+      .filter((directory) => existsSync(join(directory, 'logic.ts')))
+      .filter((directory) => !hasDedicatedLogicTest(directory))
+      .map((directory) => `${displayPath(join(directory, 'logic.ts'))} -> no test imports this module`);
+
+    expect(
+      failures,
+      [
+        'Add behavioral tests through each logic module public API.',
+        'At minimum cover a documented reference case, boundaries, invalid input and invariants.',
+        ...failures,
+      ].join('\n'),
+    ).toEqual([]);
+  });
+});
+

package/src/tests/qa_runtime_i18n.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+import { basename, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import {
+  displayPath,
+  findFiles,
+  listToolDirectories,
+  read,
+  repositoryRoot,
+} from './qa-test-helpers';
+
+interface VisibleLiteral {
+  line: number;
+  value: string;
+}
+
+const domTextAssignment = /\.(?:innerText|textContent|innerHTML)\s*=/;
+const quotedLiteral = /(['"`])((?:\\.|(?!\1).)*)\1/g;
+
+function visibleWords(value: string): string {
+  return value
+    .replace(/\$\{[^}]*\}/g, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&[a-z]+;/gi, ' ')
+    .replace(/[\d\p{P}\p{S}_]+/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function isTechnicalLiteral(value: string): boolean {
+  return ['.', '#', '['].some((prefix) => value.startsWith(prefix))
+    || /^data-[a-z0-9-]+$/i.test(value);
+}
+
+function hardcodedVisibleLiterals(source: string): VisibleLiteral[] {
+  const failures: VisibleLiteral[] = [];
+
+  source.split(/\r?\n/).forEach((line, index) => {
+    if (!domTextAssignment.test(line)) return;
+
+    const assignment = line.slice(line.search(domTextAssignment));
+    for (const match of assignment.matchAll(quotedLiteral)) {
+      const literal = match[2];
+      if (!literal || isTechnicalLiteral(literal)) continue;
+      const words = visibleWords(literal);
+      if (words && /\p{L}/u.test(words)) {
+        failures.push({ line: index + 1, value: literal });
+      }
+    }
+  });
+
+  return failures;
+}
+
+function runtimeSources(toolDirectory: string): string {
+  return findFiles(toolDirectory, ['.astro', '.ts', '.js'])
+    .filter((path) => !path.includes(`${join(toolDirectory, 'i18n')}`))
+    .filter((path) => basename(path) !== 'ui.ts')
+    .map(read)
+    .join('\n');
+}
+
+describe('QA: runtime copy is localized', () => {
+  const componentFiles = findFiles(join(repositoryRoot, 'src', 'tool'), ['.astro']);
+
+  it('does not write user-facing string literals directly into the DOM', () => {
+    const failures = componentFiles.flatMap((path) =>
+      hardcodedVisibleLiterals(read(path)).map(
+        ({ line, value }) => `${displayPath(path)}:${line} -> ${JSON.stringify(value)}`,
+      ),
+    );
+
+    expect(
+      failures,
+      `Move visible browser copy to the tool UI locale contract:\n${failures.join('\n')}`,
+    ).toEqual([]);
+  });
+
+  it('uses every string declared by each UI locale contract', () => {
+    const failures: string[] = [];
+
+    for (const directory of listToolDirectories()) {
+      const uiPath = join(directory, 'ui.ts');
+      if (!existsSync(uiPath)) continue;
+
+      const keys = Array.from(read(uiPath).matchAll(/^\s*(\w+)\??:\s*string\s*;/gm), (match) => match[1]);
+      const runtime = runtimeSources(directory);
+      const unused = keys.filter((key) => !new RegExp(`\\b${key}\\b`).test(runtime));
+
+      if (unused.length > 0) {
+        failures.push(`${displayPath(uiPath)} -> unused: ${unused.join(', ')}`);
+      }
+    }
+
+    expect(
+      failures,
+      `Unused locale keys are dead copy or may mean the browser bypasses translations:\n${failures.join('\n')}`,
+    ).toEqual([]);
+  });
+});

package/src/tool/rugbyScoreKeeper/component.astro

@@ -8,70 +8,82 @@ interface Props {
 }
 
 const { ui } = Astro.props;
-const t = (ui ?? {}) as RugbyScoreKeeperUI;
+const t = (ui ?? {}) as unknown as RugbyScoreKeeperUI;
 ---
 
 <div class="rg-app" id="rg-app" data-rg-ui={JSON.stringify(t)}>
 
   <div class="rg-main-card">
 
+  <div class="rg-save-status" id="rg-save-status" role="status">
+    <span class="rg-save-dot" aria-hidden="true"></span>
+    <span id="rg-save-status-text">{t.savedLocally}</span>
+  </div>
+
   <div class="rg-strip">
-    <div class="rg-team">
-      <input type="text" class="rg-name" id="rg-name-home" value={t.home} aria-label={t.home} />
-      <div class="rg-score" id="rg-score-home">0</div>
+    <div class="rg-team rg-team-home">
+      <input type="text" class="rg-name" id="rg-name-home" value={t.home} maxlength="40" aria-label={t.home} />
+      <div class="rg-score" id="rg-score-home" aria-live="polite">0</div>
       <div class="rg-bonus" id="rg-bonus-home"></div>
     </div>
     <div class="rg-divider">
       <span class="rg-vs">VS</span>
       <div class="rg-half-badge" id="rg-half-badge">{t.half1}</div>
     </div>
-    <div class="rg-team">
-      <input type="text" class="rg-name" id="rg-name-away" value={t.away} aria-label={t.away} />
-      <div class="rg-score" id="rg-score-away">0</div>
+    <div class="rg-team rg-team-away">
+      <input type="text" class="rg-name" id="rg-name-away" value={t.away} maxlength="40" aria-label={t.away} />
+      <div class="rg-score" id="rg-score-away" aria-live="polite">0</div>
       <div class="rg-bonus" id="rg-bonus-away"></div>
     </div>
   </div>
 
   <div class="rg-columns">
     <div class="rg-col" data-team="home">
-      <div class="rg-col-label">{t.home}</div>
-      <button class="rg-btn rg-btn-try" data-action="try">+5 {t.tryLabel}</button>
-      <button class="rg-btn rg-btn-conv" id="rg-conv-home" data-action="conv" disabled>+2 {t.conversion}</button>
-      <button class="rg-btn rg-btn-pen" data-action="pen">+3 {t.penalty}</button>
-      <button class="rg-btn rg-btn-drop" data-action="drop">+3 {t.dropGoal}</button>
+      <div class="rg-col-label" id="rg-col-label-home">{t.home}</div>
+      <button type="button" class="rg-btn rg-btn-try" data-action="try">{t.tryLabel}</button>
+      <button type="button" class="rg-btn rg-btn-conv" id="rg-conv-home" data-action="conv" disabled>{t.conversion}</button>
+      <button type="button" class="rg-btn rg-btn-pen" data-action="pen">{t.penalty}</button>
+      <button type="button" class="rg-btn rg-btn-drop" data-action="drop">{t.dropGoal}</button>
     </div>
     <div class="rg-col" data-team="away">
-      <div class="rg-col-label">{t.away}</div>
-      <button class="rg-btn rg-btn-try" data-action="try">+5 {t.tryLabel}</button>
-      <button class="rg-btn rg-btn-conv" id="rg-conv-away" data-action="conv" disabled>+2 {t.conversion}</button>
-      <button class="rg-btn rg-btn-pen" data-action="pen">+3 {t.penalty}</button>
-      <button class="rg-btn rg-btn-drop" data-action="drop">+3 {t.dropGoal}</button>
+      <div class="rg-col-label" id="rg-col-label-away">{t.away}</div>
+      <button type="button" class="rg-btn rg-btn-try" data-action="try">{t.tryLabel}</button>
+      <button type="button" class="rg-btn rg-btn-conv" id="rg-conv-away" data-action="conv" disabled>{t.conversion}</button>
+      <button type="button" class="rg-btn rg-btn-pen" data-action="pen">{t.penalty}</button>
+      <button type="button" class="rg-btn rg-btn-drop" data-action="drop">{t.dropGoal}</button>
     </div>
   </div>
 
   <div class="rg-mid-row">
     <div class="rg-clock-panel">
+      <div class="rg-panel-header">{t.matchClock}</div>
       <div class="rg-clock-ring">
         <svg class="rg-clock-svg" viewBox="0 0 120 120">
           <circle class="rg-clock-bg" cx="60" cy="60" r="54" />
-          <circle class="rg-clock-fill" id="rg-clock-fill" cx="60" cy="60" r="54" />
+          <circle class="rg-clock-fill" id="rg-clock-fill" cx="60" cy="60" r="54" aria-hidden="true" />
         </svg>
         <div class="rg-clock-inner">
-          <div class="rg-clock-time" id="rg-clock-time">00:00</div>
+          <div class="rg-clock-time" id="rg-clock-time" aria-live="polite">00:00</div>
           <div class="rg-clock-label">{t.half} <span id="rg-half-label">1</span></div>
         </div>
       </div>
-      <button class="rg-btn rg-btn-clock" id="rg-btn-clock">{t.startMatch}</button>
+      <button type="button" class="rg-btn rg-btn-clock" id="rg-btn-clock">{t.startMatch}</button>
     </div>
     <div class="rg-sinbin-panel">
-      <div class="rg-panel-header">{t.sinBin}</div>
+      <div class="rg-panel-header">{t.sinBinTitle}</div>
       <div class="rg-sinbin-form">
-        <input type="text" class="rg-input" id="rg-sinbin-input" placeholder={t.sinBinPlayer} aria-label={t.sinBinPlayer} />
-        <select class="rg-select" id="rg-sinbin-duration" aria-label={t.sinBin + " duration"}>
-          <option value="600">10 min</option>
-          <option value="300">5 min</option>
-        </select>
-        <button class="rg-btn rg-btn-yellow" id="rg-btn-sinbin">{t.sinBinAdd}</button>
+        <input type="text" class="rg-input" id="rg-sinbin-input" maxlength="80" placeholder={t.sinBinPlayer} aria-label={t.sinBinPlayer} />
+        <div class="rg-choice-row">
+          <div class="rg-choice-group" role="group" aria-label={t.teamLabel}>
+            <button type="button" class="rg-choice rg-choice-home is-active" data-sinbin-team="home" aria-pressed="true">{t.home}</button>
+            <button type="button" class="rg-choice rg-choice-away" data-sinbin-team="away" aria-pressed="false">{t.away}</button>
+          </div>
+          <div class="rg-choice-group" role="group" aria-label={t.durationLabel}>
+            <button type="button" class="rg-choice is-active" data-sinbin-duration="600" aria-pressed="true">10 {t.minutesShort}</button>
+            <button type="button" class="rg-choice" data-sinbin-duration="300" aria-pressed="false">5 {t.minutesShort}</button>
+          </div>
+        </div>
+        <button type="button" class="rg-btn rg-btn-yellow" id="rg-btn-sinbin">{t.sinBinAdd}</button>
       </div>
       <div class="rg-sinbin-list" id="rg-sinbin-list">
         <div class="rg-sinbin-empty">{t.sinBinEmpty}</div>
@@ -85,13 +97,13 @@ const t = (ui ?? {}) as RugbyScoreKeeperUI;
       <div class="rg-history-list" id="rg-history-list">
         <div class="rg-history-empty">{t.eventEmpty}</div>
       </div>
-      <button class="rg-btn rg-btn-undo" id="rg-btn-undo" disabled>{t.undoBtn}</button>
+      <button type="button" class="rg-btn rg-btn-undo" id="rg-btn-undo" disabled>{t.undoBtn}</button>
     </div>
     <div class="rg-summary">
       <div class="rg-panel-header">{t.scoringSummary}</div>
       <table class="rg-table">
         <thead>
-          <tr><th></th><th>{t.home}</th><th>{t.away}</th></tr>
+          <tr><th></th><th class="rg-th-home" id="rg-summary-home">{t.home}</th><th class="rg-th-away" id="rg-summary-away">{t.away}</th></tr>
         </thead>
         <tbody id="rg-summary-body">
           <tr><td>{t.tryScored}</td><td>0</td><td>0</td></tr>
@@ -110,28 +122,29 @@ const t = (ui ?? {}) as RugbyScoreKeeperUI;
     </div>
   </div>
 
-  <div id="rg-banner" class="rg-banner" style="display:none">
+  <div id="rg-banner" class="rg-banner" role="status" aria-live="polite" style="display:none">
     <div class="rg-banner-text" id="rg-banner-text"></div>
   </div>
 
-  <div class="rg-reset-modal" id="rg-modal">
+  <div class="rg-reset-modal" id="rg-modal" role="dialog" aria-modal="true" aria-hidden="true" aria-labelledby="rg-modal-title">
     <div class="rg-modal-content">
+      <h2 class="rg-modal-title" id="rg-modal-title">{t.resetMatch}</h2>
       <div class="rg-modal-text">{t.resetConfirm}</div>
       <div class="rg-modal-btns">
-        <button class="rg-btn rg-btn-modal-cancel" id="rg-modal-cancel">{t.cancel}</button>
-        <button class="rg-btn rg-btn-modal-confirm" id="rg-modal-confirm">{t.confirm}</button>
+        <button type="button" class="rg-btn rg-btn-modal-cancel" id="rg-modal-cancel">{t.cancel}</button>
+        <button type="button" class="rg-btn rg-btn-modal-confirm" id="rg-modal-confirm">{t.confirm}</button>
       </div>
     </div>
   </div>
 
   <div class="rg-actions">
-    <button class="rg-btn rg-btn-reset" id="rg-btn-reset">{t.resetMatch}</button>
+    <button type="button" class="rg-btn rg-btn-reset" id="rg-btn-reset">{t.resetMatch}</button>
   </div>
 
   </div>
 </div>
 
 <script>
-  import { initRugbyScorekeeper } from './ui-init';
+  import { initRugbyScorekeeper } from './ui-runtime';
   initRugbyScorekeeper();
 </script>

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

@@ -214,5 +214,11 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Letztes Rückgängig',
     timeOff: 'Zeit Gestoppt',
     timeOn: 'Zeit Läuft',
+    fullTime: 'Spielende',
+    minutesShort: 'Min.',
+    savedLocally: 'Auf diesem Gerät gespeichert',
+    saveUnavailable: 'Speichern nicht verfügbar',
+    teamLabel: 'Team',
+    durationLabel: 'Dauer',
   },
 };

package/src/tool/rugbyScoreKeeper/i18n/en.ts

@@ -214,5 +214,11 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Undo Last',
     timeOff: 'Time Off',
     timeOn: 'Time On',
+    fullTime: 'Full time',
+    minutesShort: 'min',
+    savedLocally: 'Saved on this device',
+    saveUnavailable: 'Saving unavailable',
+    teamLabel: 'Team',
+    durationLabel: 'Duration',
   },
 };

package/src/tool/rugbyScoreKeeper/i18n/es.ts

@@ -214,5 +214,11 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Deshacer Último',
     timeOff: 'Tiempo Detenido',
     timeOn: 'Tiempo en Marcha',
+    fullTime: 'Fin del partido',
+    minutesShort: 'min',
+    savedLocally: 'Guardado en este dispositivo',
+    saveUnavailable: 'No se puede guardar',
+    teamLabel: 'Equipo',
+    durationLabel: 'Duración',
   },
 };

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

@@ -214,5 +214,11 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Annuler le Dernier',
     timeOff: 'Temps Arrêté',
     timeOn: 'Temps en Marche',
+    fullTime: 'Fin du match',
+    minutesShort: 'min',
+    savedLocally: 'Enregistré sur cet appareil',
+    saveUnavailable: 'Enregistrement indisponible',
+    teamLabel: 'Équipe',
+    durationLabel: 'Durée',
   },
 };

package/src/tool/rugbyScoreKeeper/i18n/id.ts

@@ -214,5 +214,11 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Batalkan terakhir',
     timeOff: 'Waktu Berhenti',
     timeOn: 'Waktu Berjalan',
+    fullTime: 'Pertandingan Selesai',
+    minutesShort: 'mnt',
+    savedLocally: 'Tersimpan di perangkat ini',
+    saveUnavailable: 'Penyimpanan tidak tersedia',
+    teamLabel: 'Tim',
+    durationLabel: 'Durasi',
   },
 };

package/src/tool/rugbyScoreKeeper/i18n/it.ts

@@ -214,5 +214,11 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Annulla Ultimo',
     timeOff: 'Tempo Fermo',
     timeOn: 'Tempo in Gioco',
+    fullTime: 'Fine partita',
+    minutesShort: 'min',
+    savedLocally: 'Salvato su questo dispositivo',
+    saveUnavailable: 'Salvataggio non disponibile',
+    teamLabel: 'Squadra',
+    durationLabel: 'Durata',
   },
 };

package/src/tool/rugbyScoreKeeper/i18n/ja.ts

@@ -214,5 +214,11 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: '最後を元に戻す',
     timeOff: 'タイムオフ',
     timeOn: 'タイムオン',
+    fullTime: '試合終了',
+    minutesShort: '分',
+    savedLocally: 'この端末に保存済み',
+    saveUnavailable: '保存できません',
+    teamLabel: 'チーム',
+    durationLabel: '時間',
   },
 };

package/src/tool/rugbyScoreKeeper/i18n/ko.ts

@@ -214,5 +214,11 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: '마지막 실행 취소',
     timeOff: '타임 오프',
     timeOn: '타임 온',
+    fullTime: '경기 종료',
+    minutesShort: '분',
+    savedLocally: '이 기기에 저장됨',
+    saveUnavailable: '저장할 수 없음',
+    teamLabel: '팀',
+    durationLabel: '시간',
   },
 };

package/src/tool/rugbyScoreKeeper/i18n/nl.ts

@@ -214,5 +214,11 @@ export const content: RugbyScoreKeeperLocaleContent = {
     undoBtn: 'Ongedaan Maken Laatste',
     timeOff: 'Tijd Stil',
     timeOn: 'Tijd Loopt',
+    fullTime: 'Einde wedstrijd',
+    minutesShort: 'min',
+    savedLocally: 'Op dit apparaat opgeslagen',
+    saveUnavailable: 'Opslaan niet beschikbaar',
+    teamLabel: 'Team',
+    durationLabel: 'Duur',
   },
 };