@jjlmoya/utils-tabletop 1.13.0 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-tabletop",
-    "version": "1.13.0",
+    "version": "1.15.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/i18n/fr.ts

@@ -2,7 +2,7 @@ import type { CategoryLocaleContent } from '../../types';
 
 const slug = 'jeux-de-societe';
 const title = 'Utilitaires et Outils pour Jeux de Société';
-const description = 'Outils gratuits pour jeux de société et de rôle : lancez des dés virtuels avec des statistiques en direct, gérez les temps de tour avec un chronomètre multijoueur et bien plus. Fonctionne dans votre navigateur, sans inscription, 100 % privé.';
+const description = 'Outils gratuits pour jeux de société et de rôle: lancez des dés virtuels avec des statistiques en direct, gérez les temps de tour avec un chronomètre multijoueur et bien plus. Fonctionne dans votre navigateur, sans inscription, 100 % privé.';
 
 export const content: CategoryLocaleContent = {
   slug,
@@ -14,8 +14,8 @@ export const content: CategoryLocaleContent = {
     { type: 'title', text: 'Lancez des Dés Virtuels avec des Statistiques en Temps Réel', level: 2 },
     { type: 'paragraph', html: 'Marre de chercher vos dés sous la table ou d\'attendre que quelqu\'un additionne ses résultats ? Le lanceur de dés virtuel vous permet de jeter n\'importe quelle combinaison de dés polyédriques instantanément, avec modificateurs, avantage, désavantage et un historique complet. L\'analyseur de probabilités intégré vous montre vos chances réelles avant de lancer. Parfait pour Dungeons & Dragons, Pathfinder, Call of Cthulhu, Shadowrun ou tout jeu reposant sur le hasard.' },
     { type: 'title', text: 'Gardez le Rythme avec un Chronomètre de Tour Intelligent', level: 2 },
-    { type: 'paragraph', html: 'On connaît tous ce joueur qui prend une éternité à chaque tour. Le chronomètre de jeu vous permet de fixer des limites de temps justes et amusantes, avec des modes qui s\'adaptent à chaque style : du simple compte à rebours partagé aux systèmes d\'échecs avec incrément Fischer ou délai Bronstein. Fonctionne pour les duels à deux en écran partagé ou pour les groupes jusqu\'à huit joueurs avec contrôle centralisé. Après la partie, consultez des statistiques détaillées sur les temps et le rythme de jeu.' },
-    { type: 'title', text: 'La Vie Privée Avant Tout : Vos Données Restent sur Votre Appareil', level: 2 },
+    { type: 'paragraph', html: 'On connaît tous ce joueur qui prend une éternité à chaque tour. Le chronomètre de jeu vous permet de fixer des limites de temps justes et amusantes, avec des modes qui s\'adaptent à chaque style: du simple compte à rebours partagé aux systèmes d\'échecs avec incrément Fischer ou délai Bronstein. Fonctionne pour les duels à deux en écran partagé ou pour les groupes jusqu\'à huit joueurs avec contrôle centralisé. Après la partie, consultez des statistiques détaillées sur les temps et le rythme de jeu.' },
+    { type: 'title', text: 'La Vie Privée Avant Tout: Vos Données Restent sur Votre Appareil', level: 2 },
     { type: 'paragraph', html: 'L\'un des grands atouts de cette bibliothèque est que tout le traitement s\'effectue dans votre navigateur. Aucune donnée n\'est envoyée à un serveur, pas de cookies de pistage, pas d\'email ni d\'inscription requis. Utilisez les outils hors ligne, partagez votre écran avec la table ou projetez sur un téléviseur - rien d\'autre à gérer que le jeu lui-même. Et d\'autres outils arrivent, toujours conçus pour simplifier la vie des joueurs de société.' },
     { type: 'stats', items: [
       { label: 'Outils', value: '2+', icon: 'mdi:tools' },

package/src/category/i18n/zh.ts

@@ -2,21 +2,21 @@
 
 const slug = 'tabletop';
 const title = '桌游工具与实用程序';
-const description = '免费的桌游和TRPG工具：虚拟骰子带实�-�统计，多人回合计�-�器等。在浏览器中运行，�-�需注册，100%隐私保护。';
+const description = '免费的桌游和TRPG工具：虚拟骰子带实时统计，多人回合计时器等。在浏览器中运行，无需注册，100%隐私保护。';
 
 export const content: CategoryLocaleContent = {
   slug,
   title,
   description,
   seo: [
-    { type: 'title', text: '桌游工具 | 在线掷骰子和回合计�-�器', level: 2 },
-    { type: 'paragraph', html: '游戏之夜本该充满乐趣，而不是到处找丢失的骰子或等待别人计�-结果。这款实用工具库为您和您的团队提供快速、精心设计的工具，即刻可用，�-�需任何回报。�-�论您是手忙脚乱的 dungeon master，还是只想轻松掷骰的玩家，这些工具都是为您打造的。' },
-    { type: 'title', text: '使用虚拟骰子进行实�-�统计分析', level: 2 },
+    { type: 'title', text: '桌游工具 | 在线掷骰子和回合计时器', level: 2 },
+    { type: 'paragraph', html: '游戏之夜本该充满乐趣，而不是到处找丢失的骰子或等待别人计算结果。这款实用工具库为您和您的团队提供快速、精心设计的工具，即刻可用，无需任何回报。无论您是手忙脚乱的 dungeon master，还是只想轻松掷骰的玩家，这些工具都是为您打造的。' },
+    { type: 'title', text: '使用虚拟骰子进行实时统计分析', level: 2 },
     { type: 'paragraph', html: '厌倦了在桌子下找骰子或等待别人加总结果？虚拟骰子掷投器让您立即投掷任何组合的多面骰子，支持调整值、优势、劣势和完整历史记录。内置概率分析器在投掷前显示您的真实成功率。非常适合 Dungeons & Dragons、Pathfinder、Call of Cthulhu、Shadowrun 或任何依赖运气的游戏。' },
-    { type: 'title', text: '使用智能回合计�-�器掌控游戏节奏', level: 2 },
-    { type: 'paragraph', html: '我们都知道那个每回合都要花上大量�-��-�的玩家。游戏计�-�器让您设定公平又有趣的�-��-�限制，提供适应各种风格的模式：从简单的共享倒计�-�到 Fischer 增量或 Bronstein 延迟等国际象棋系统。支持双人分屏对决和最多八人的中央控制模式。游戏结束后，可查看�-��-�和游戏节奏的详细统计数据。' },
+    { type: 'title', text: '使用智能回合计时器掌控游戏节奏', level: 2 },
+    { type: 'paragraph', html: '我们都知道那个每回合都要花上大量时间的玩家。游戏计时器让您设定公平又有趣的时间限制，提供适应各种风格的模式：从简单的共享倒计时到 Fischer 增量或 Bronstein 延迟等国际象棋系统。支持双人分屏对决和最多八人的中央控制模式。游戏结束后，可查看时间和游戏节奏的详细统计数据。' },
     { type: 'title', text: '隐私至上：所有数据保留在您的设备上', level: 2 },
-    { type: 'paragraph', html: '该库的最大优势之一是所有处理都在您的浏览器内完成。不会有数据发送到服务器，没有跟踪 Cookie，�-�需电子邮件或注册。可离线使用工具，与桌上玩家共享屏幕，或投影到电视上--除了游戏本身，�-�需担心任何事。更多的工具正在开发中，始终以方便桌游玩家为设计目标。' },
+    { type: 'paragraph', html: '该库的最大优势之一是所有处理都在您的浏览器内完成。不会有数据发送到服务器，没有跟踪 Cookie，无需电子邮件或注册。可离线使用工具，与桌上玩家共享屏幕，或投影到电视上，除了游戏本身，无需担心任何事。更多的工具正在开发中，始终以方便桌游玩家为设计目标。' },
     { type: 'stats', items: [
       { label: '工具', value: '2+', icon: 'mdi:tools' },
       { label: '玩家', value: '2-8', icon: 'mdi:account-group' },

package/src/layouts/PreviewLayout.astro

@@ -73,6 +73,7 @@ const { title, currentLocale = "es", localeUrls = {}, hasSidebar = false } = Ast
   body {
     background-color: var(--bg-page);
     color: var(--text-base);
+    font-family: Inter, sans-serif;
     margin: 0;
     min-height: 100vh;
     transition:

package/src/tests/diacritics_density.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+type LocaleWithDiacritics = keyof typeof DIACRITIC_RULES;
+
+const DIACRITIC_RULES = {
+  de: {
+    language: 'German',
+    expectedCharacters: 'ä ö ü ß',
+    characters: /[äöüÄÖÜß]/g,
+    minPerThousandLetters: 0.1,
+  },
+  es: {
+    language: 'Spanish',
+    expectedCharacters: 'á é í ó ú ü ñ',
+    characters: /[áéíóúüñÁÉÍÓÚÜÑ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  fr: {
+    language: 'French',
+    expectedCharacters: 'à â æ ç é è ê ë î ï ô œ ù û ü ÿ',
+    characters: /[àâæçéèêëîïôœùûüÿÀÂÆÇÉÈÊËÎÏÔŒÙÛÜŸ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  it: {
+    language: 'Italian',
+    expectedCharacters: 'à è é ì í î ò ó ù ú',
+    characters: /[àèéìíîòóùúÀÈÉÌÍÎÒÓÙÚ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  pl: {
+    language: 'Polish',
+    expectedCharacters: 'ą ć ę ł ń ó ś ź ż',
+    characters: /[ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  pt: {
+    language: 'Portuguese',
+    expectedCharacters: 'á â ã à ç é ê í ó ô õ ú ü',
+    characters: /[áâãàçéêíóôõúüÁÂÃÀÇÉÊÍÓÔÕÚÜ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  sv: {
+    language: 'Swedish',
+    expectedCharacters: 'å ä ö',
+    characters: /[åäöÅÄÖ]/g,
+    minPerThousandLetters: 0.1,
+  },
+  tr: {
+    language: 'Turkish',
+    expectedCharacters: 'ç ğ ı İ ö ş ü',
+    characters: /[çğıöşüÇĞİÖŞÜ]/g,
+    minPerThousandLetters: 0.1,
+  },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function normalizeText(value: unknown): string {
+  return collectStrings(value).join(' ').normalize('NFC');
+}
+
+function translatableContent(content: Record<string, unknown>) {
+  return TRANSLATABLE_KEYS.map((key) => content[key]);
+}
+
+function letterCount(text: string): number {
+  return text.match(LETTERS)?.length ?? 0;
+}
+
+function diacriticCount(text: string, locale: LocaleWithDiacritics): number {
+  return text.match(DIACRITIC_RULES[locale].characters)?.length ?? 0;
+}
+
+function diacriticsPerThousandLetters(text: string, locale: LocaleWithDiacritics): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return diacriticCount(text, locale) / letters * 1000;
+}
+
+describe('Diacritics density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(DIACRITIC_RULES).forEach((locale) => {
+        it(`${locale} keeps the expected accent and special-letter set`, async () => {
+          const typedLocale = locale as LocaleWithDiacritics;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const rule = DIACRITIC_RULES[typedLocale];
+          const letters = letterCount(text);
+          const matches = diacriticCount(text, typedLocale);
+          const density = diacriticsPerThousandLetters(text, typedLocale);
+
+          expect(
+            density,
+            [
+              `Possible spelling or encoding issue detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} special characters (${density.toFixed(2)} per 1000 letters, ${letters} letters analyzed).`,
+              `This locale should include some of these characters: ${rule.expectedCharacters}.`,
+              'If the count is 0 or near 0, accents, tildes, or special letters were probably stripped by encoding or normalization.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minPerThousandLetters);
+        });
+      });
+    });
+  });
+});

package/src/tests/inverted_punctuation.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const INVERTED_PUNCTUATION_LOCALES = {
+  es: {
+    language: 'Spanish',
+    questionStart: '¿',
+    questionEnd: '?',
+    exclamationStart: '¡',
+    exclamationEnd: '!',
+  },
+} as const;
+
+type InvertedPunctuationLocale = keyof typeof INVERTED_PUNCTUATION_LOCALES;
+
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function translatableStrings(content: Record<string, unknown>): string[] {
+  return TRANSLATABLE_KEYS.flatMap((key) => collectStrings(content[key]));
+}
+
+function sentenceStart(text: string, endIndex: number): string {
+  const beforeMark = text.slice(0, endIndex).trimEnd();
+  const boundary = Math.max(
+    beforeMark.lastIndexOf('.'),
+    beforeMark.lastIndexOf(':'),
+    beforeMark.lastIndexOf(';'),
+    beforeMark.lastIndexOf('\n'),
+  );
+
+  return beforeMark.slice(boundary + 1).trimStart();
+}
+
+function findMissingInvertedMarks(
+  text: string,
+  startMark: string,
+  endMark: string,
+): string[] {
+  return [...text.matchAll(new RegExp(`\\${endMark}`, 'g'))]
+    .map((match) => sentenceStart(text, match.index ?? 0))
+    .filter((segment) => segment.length > 0 && !segment.includes(startMark))
+    .map((segment) => `${segment}${endMark}`);
+}
+
+describe('Inverted punctuation validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(INVERTED_PUNCTUATION_LOCALES).forEach((locale) => {
+        it(`${locale} uses opening punctuation marks for questions and exclamations`, async () => {
+          const typedLocale = locale as InvertedPunctuationLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const rule = INVERTED_PUNCTUATION_LOCALES[typedLocale];
+          const content = await loader();
+          const strings = translatableStrings(content as Record<string, unknown>);
+          const missingQuestions = strings.flatMap((text) =>
+            findMissingInvertedMarks(text, rule.questionStart, rule.questionEnd)
+          );
+          const missingExclamations = strings.flatMap((text) =>
+            findMissingInvertedMarks(text, rule.exclamationStart, rule.exclamationEnd)
+          );
+          const failures = [...missingQuestions, ...missingExclamations];
+
+          expect(
+            failures,
+            [
+              `Missing opening punctuation marks in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `Questions must use ${rule.questionStart}...${rule.questionEnd} and exclamations must use ${rule.exclamationStart}...${rule.exclamationEnd}.`,
+              `Examples: ${failures.slice(0, 5).join(' | ')}`,
+            ].join(' '),
+          ).toHaveLength(0);
+        });
+      });
+    });
+  });
+});

package/src/tests/no_en_dash.test.ts

@@ -22,20 +22,49 @@ function getFiles(dir: string): string[] {
   return results;
 }
 
+function isContentFile(filePath: string): boolean {
+  return /\\i18n\\/.test(filePath) || filePath.endsWith('bibliography.ts');
+}
+
 const srcDir = path.join(process.cwd(), 'src');
 const scriptsDir = path.join(process.cwd(), 'scripts');
 const filesToTest = [
-  ...getFiles(srcDir),
-  ...getFiles(scriptsDir),
+  ...getFiles(srcDir).filter(isContentFile),
+  ...getFiles(scriptsDir).filter(isContentFile),
 ];
 
-describe('En-Dash Character Validation', () => {
+const aiTypographyGarbage = [
+  '\u2013',
+  '\u2014',
+  '\u2026',
+  '\u201C',
+  '\u201D',
+  '\u2018',
+  '\u2019',
+  '\u00AB',
+  '\u00BB',
+  '\u200B',
+  '\u201E',
+];
+
+describe('Typography Garbage Character Validation', () => {
   filesToTest.forEach((filePath) => {
     const relativePath = path.relative(process.cwd(), filePath);
-    it(`should not contain en-dash in ${relativePath}`, () => {
+    it(`should not contain typography garbage characters in ${relativePath}`, () => {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const hasAiPatterns = aiTypographyGarbage.some(char => content.includes(char));
+      expect(hasAiPatterns).toBe(false);
+    });
+
+    it(`should not contain space before colon in ${relativePath}`, () => {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const spaceBeforeColon = / : /.test(content);
+      expect(spaceBeforeColon).toBe(false);
+    });
+
+    it(`should not contain double hyphen in ${relativePath}`, () => {
       const content = fs.readFileSync(filePath, 'utf-8');
-      const hasEnDash = content.includes('\u2013') || content.includes('–');
-      expect(hasEnDash).toBe(false);
+      expect(content).not.toContain('--');
     });
   });
 });

package/src/tests/script_density.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+type ScriptLocale = keyof typeof SCRIPT_RULES;
+
+const SCRIPT_RULES = {
+  ja: {
+    language: 'Japanese',
+    scriptName: 'kana/kanji',
+    scriptCharacters: /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/gu,
+    minScriptRatio: 0.45,
+  },
+  ko: {
+    language: 'Korean',
+    scriptName: 'hangul',
+    scriptCharacters: /\p{Script=Hangul}/gu,
+    minScriptRatio: 0.55,
+  },
+  ru: {
+    language: 'Russian',
+    scriptName: 'cyrillic',
+    scriptCharacters: /\p{Script=Cyrillic}/gu,
+    minScriptRatio: 0.65,
+  },
+  zh: {
+    language: 'Chinese',
+    scriptName: 'han',
+    scriptCharacters: /\p{Script=Han}/gu,
+    minScriptRatio: 0.45,
+  },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function normalizeText(value: unknown): string {
+  return collectStrings(value).join(' ').normalize('NFC');
+}
+
+function translatableContent(content: Record<string, unknown>) {
+  return TRANSLATABLE_KEYS.map((key) => content[key]);
+}
+
+function letterCount(text: string): number {
+  return text.match(LETTERS)?.length ?? 0;
+}
+
+function scriptCount(text: string, locale: ScriptLocale): number {
+  return text.match(SCRIPT_RULES[locale].scriptCharacters)?.length ?? 0;
+}
+
+function scriptRatio(text: string, locale: ScriptLocale): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return scriptCount(text, locale) / letters;
+}
+
+describe('Native script density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(SCRIPT_RULES).forEach((locale) => {
+        it(`${locale} keeps most translated text in its native script`, async () => {
+          const typedLocale = locale as ScriptLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const rule = SCRIPT_RULES[typedLocale];
+          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const letters = letterCount(text);
+          const matches = scriptCount(text, typedLocale);
+          const ratio = scriptRatio(text, typedLocale);
+
+          expect(
+            ratio,
+            [
+              `Possible broken translation detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} ${rule.scriptName} characters out of ${letters} analyzed letters (${(ratio * 100).toFixed(1)}%).`,
+              `Most translatable content should be written in ${rule.scriptName} script.`,
+              'Non-translatable fields such as slug, bibliography, and schemas are ignored to avoid false positives.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minScriptRatio);
+        });
+      });
+    });
+  });
+});

package/src/tool/board-game-timer/board-game-timer.css

@@ -1603,6 +1603,100 @@
   animation: sparkle-float 4s ease-in-out infinite;
 }
 
+@media (max-width: 600px) {
+  main:has(.timer-main-wrapper),
+  .tool-page:has(.timer-main-wrapper),
+  .section-tool:has(.timer-main-wrapper),
+  .tool-page:has(.timer-main-wrapper) .utility-header,
+  .tool-page:has(.timer-main-wrapper) .utility-header-title,
+  .tool-page:has(.timer-main-wrapper) .utility-header-base,
+  .tool-page:has(.timer-main-wrapper) .utility-header-highlight,
+  .tool-page:has(.timer-main-wrapper) .utility-header-description {
+    min-width: 0;
+    max-width: 100%;
+    overflow-wrap: anywhere;
+  }
+
+  main:has(.timer-main-wrapper) {
+    overflow-x: hidden;
+  }
+
+  .tool-page:has(.timer-main-wrapper) .utility-header-title {
+    font-size: clamp(2rem, 12vw, 3rem);
+    letter-spacing: 0;
+  }
+
+  .timer-main-wrapper {
+    padding: 1rem;
+    gap: 1.25rem;
+    border-radius: 1rem;
+    min-width: 0;
+    overflow: hidden;
+  }
+
+  .timer-setup-panel,
+  .setup-card,
+  .settings-group,
+  .control-box,
+  .player-input-block {
+    min-width: 0;
+  }
+
+  .setup-card {
+    padding: 1rem;
+  }
+
+  .presets-grid,
+  .settings-grid,
+  .general-stats-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .player-input-row-nowrap,
+  .time-inputs-container,
+  .multiplayer-header-bar,
+  .game-meta-indicators,
+  .header-action-group {
+    flex-wrap: wrap;
+  }
+
+  .text-input,
+  .select-input,
+  .number-input-wrapper,
+  .time-adjuster-group {
+    min-width: 0;
+  }
+
+  .time-adjuster-group {
+    flex: 1 1 7.5rem;
+    justify-content: center;
+  }
+
+  .duel-controls-bar {
+    padding: 0.5rem;
+  }
+
+  .side-timer {
+    font-size: clamp(2.6rem, 16vw, 4rem);
+  }
+
+  .multiplayer-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .giant-next-btn {
+    min-width: 0;
+    width: 100%;
+    padding: 1rem;
+  }
+
+  .stats-modal-card,
+  .overlay-card {
+    width: calc(100% - 1.5rem);
+    padding: 1.25rem;
+  }
+}
+
 @keyframes sparkle-float {
   0%, 100% {
     opacity: 0;

package/src/tool/board-game-timer/i18n/fr.ts

@@ -99,7 +99,7 @@ export const content: ToolLocaleContent<BoardGameTimerUI> = {
     },
     {
       type: 'proscons',
-      title: 'Avantages et inconvénients : Incrément Fischer vs Retard Bronstein',
+      title: 'Avantages et inconvénients: Incrément Fischer vs Retard Bronstein',
       items: [
         {
           pro: 'L\'incrément Fischer récompense la rapidité en accumulant du temps pour les tours futurs.',
@@ -211,7 +211,7 @@ export const content: ToolLocaleContent<BoardGameTimerUI> = {
   howTo: [
     {
       name: 'Configurer la partie',
-      text: 'Sélectionnez un préréglage (Casual, Blitz, Stratégique, Sablier) ou définissez vos paramètres personnalisés : temps de base, incrément/retard, et seuil d\'alerte.',
+      text: 'Sélectionnez un préréglage (Casual, Blitz, Stratégique, Sablier) ou définissez vos paramètres personnalisés: temps de base, incrément/retard, et seuil d\'alerte.',
     },
     {
       name: 'Ajouter et organiser les joueurs',
@@ -285,7 +285,7 @@ export const content: ToolLocaleContent<BoardGameTimerUI> = {
         {
           '@type': 'HowToStep',
           'name': 'Configurer la partie',
-          'text': 'Sélectionnez un préréglage (Casual, Blitz, Stratégique, Sablier) ou définissez vos paramètres personnalisés : temps de base, incrément/retard, et seuil d\'alerte.'
+          'text': 'Sélectionnez un préréglage (Casual, Blitz, Stratégique, Sablier) ou définissez vos paramètres personnalisés: temps de base, incrément/retard, et seuil d\'alerte.'
         },
         {
           '@type': 'HowToStep',

package/src/tool/board-game-timer/i18n/zh.ts

@@ -219,7 +219,7 @@ export const content: ToolLocaleContent<BoardGameTimerUI> = {
     },
     {
       name: '启动并交替回合',
-      text: '开始游戏。在双人模式中，点击你的屏幕半区以结束回合。在多人模式中，点击中央巨大的“结束回合”按钮。',
+      text: '开始游戏。在双人模式中，点击你的屏幕半区以结束回合。在多人模式中，点击中央巨大的"结束回合"按钮。',
     },
   ],
   schemas: [
@@ -295,7 +295,7 @@ export const content: ToolLocaleContent<BoardGameTimerUI> = {
         {
           '@type': 'HowToStep',
           'name': '启动并交替回合',
-          'text': '开始游戏。在双人模式中，点击你的屏幕半区以结束回合。在多人模式中，点击中央巨大的“结束回合”按钮。'
+          'text': '开始游戏。在双人模式中，点击你的屏幕半区以结束回合。在多人模式中，点击中央巨大的"结束回合"按钮。'
         }
       ]
     }

package/src/tool/decision-wheel/decision-wheel.css

@@ -646,3 +646,92 @@
   font-size: 0.85rem;
   font-weight: 800;
 }
+
+@media (max-width: 600px) {
+  main:has(.wheel-dashboard),
+  .tool-page:has(.wheel-dashboard),
+  .section-tool:has(.wheel-dashboard),
+  .tool-page:has(.wheel-dashboard) .utility-header,
+  .tool-page:has(.wheel-dashboard) .utility-header-title,
+  .tool-page:has(.wheel-dashboard) .utility-header-base,
+  .tool-page:has(.wheel-dashboard) .utility-header-highlight,
+  .tool-page:has(.wheel-dashboard) .utility-header-description {
+    min-width: 0;
+    max-width: 100%;
+    overflow-wrap: anywhere;
+  }
+
+  main:has(.wheel-dashboard) {
+    overflow-x: hidden;
+  }
+
+  .tool-page:has(.wheel-dashboard) .utility-header-title {
+    font-size: clamp(2rem, 12vw, 3rem);
+    letter-spacing: 0;
+  }
+
+  .wheel-dashboard {
+    padding: 1rem;
+    gap: 1.5rem;
+    border-radius: 1rem;
+    min-width: 0;
+  }
+
+  .wheel-layout,
+  .canvas-card,
+  .wheel-canvas-section,
+  .wheel-canvas-container,
+  .tab-container,
+  .editor-card {
+    min-width: 0;
+  }
+
+  .canvas-card,
+  .tab-container {
+    padding: 1rem;
+    border-radius: 1rem;
+  }
+
+  .wheel-canvas {
+    width: min(320px, calc(100vw - 6rem));
+    height: min(320px, calc(100vw - 6rem));
+  }
+
+  .spin-button {
+    min-height: 3.5rem;
+    height: auto;
+    padding: 0.85rem;
+    font-size: 1rem;
+    white-space: normal;
+  }
+
+  .tab-headers,
+  .preset-group {
+    flex-wrap: wrap;
+  }
+
+  .tab-header {
+    flex: 1 1 7rem;
+    padding: 0.6rem 0.75rem;
+  }
+
+  .segment-row {
+    align-items: stretch;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+    padding: 0.75rem;
+  }
+
+  .segment-input {
+    flex: 1 1 calc(100% - 2.5rem);
+  }
+
+  .segment-weight {
+    flex: 1 1 6rem;
+    width: auto;
+  }
+
+  .btn-remove-segment {
+    flex: 1 1 5rem;
+  }
+}