@jjlmoya/utils-chrono 1.2.0

package/src/tool/wrist-presence-calculator/entry.ts

@@ -0,0 +1,59 @@
+import type { ChronoToolEntry, ToolLocaleContent } from '../../types';
+
+export type WristPresenceCalculatorUI = {
+  title: string;
+  wristCircumferenceLabel: string;
+  caseDiameterLabel: string;
+  lugToLugLabel: string;
+  wristWidthLabel: string;
+  autoEstimateWidthLabel: string;
+  unitCm: string;
+  unitInches: string;
+  unitMm: string;
+  fitAnalysisTitle: string;
+  caseWristRatioLabel: string;
+  wristCoverageLabel: string;
+  verdictLabel: string;
+  verdictOversized: string;
+  verdictBold: string;
+  verdictGolden: string;
+  verdictVintage: string;
+  coverageSafe: string;
+  coverageBold: string;
+  coverageOverhang: string;
+  sweetSpotTitle: string;
+  sweetSpotDesc: string;
+  minClassicLabel: string;
+  sweetSpotLabel: string;
+  maxBoldLabel: string;
+  maxLugToLugLabel: string;
+  idealSizesTitle: string;
+  visualizerTitle: string;
+  wristWidthHelp: string;
+  estimatedLabel: string;
+  customLabel: string;
+};
+
+export type WristPresenceCalculatorLocaleContent = ToolLocaleContent<WristPresenceCalculatorUI>;
+
+export const wristPresenceCalculator: ChronoToolEntry<WristPresenceCalculatorUI> = {
+  id: 'wrist-presence-calculator',
+  icons: { bg: 'mdi:ruler', fg: 'mdi:watch' },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/wrist-presence-calculator/helpers/canvas.ts

@@ -0,0 +1,189 @@
+interface DrawParams {
+  canvas: HTMLCanvasElement;
+  wristW: number;
+  caseD: number;
+  l2l: number;
+  unit: 'cm' | 'in';
+  ui: Record<string, string>;
+}
+
+interface RenderContext {
+  ctx: CanvasRenderingContext2D;
+  cx: number;
+  cy: number;
+  scale: number;
+  colors: CSSStyleDeclaration;
+  wristW: number;
+  caseD: number;
+  l2l: number;
+  unit: 'cm' | 'in';
+  ui: Record<string, string>;
+}
+
+export function drawFitVisualizer(params: DrawParams) {
+  const ctx = params.canvas.getContext('2d');
+  if (!ctx) return;
+  const rect = params.canvas.getBoundingClientRect();
+  const dpr = window.devicePixelRatio || 1;
+  params.canvas.width = rect.width * dpr;
+  params.canvas.height = rect.height * dpr;
+  ctx.scale(dpr, dpr);
+  const w = rect.width;
+  const h = rect.height;
+  ctx.clearRect(0, 0, w, h);
+  const scale = (w * 0.75) / Math.max(params.wristW, params.l2l, 80);
+  const r: RenderContext = {
+    ctx,
+    cx: w / 2,
+    cy: h / 2,
+    scale,
+    colors: getComputedStyle(params.canvas),
+    wristW: params.wristW,
+    caseD: params.caseD,
+    l2l: params.l2l,
+    unit: params.unit,
+    ui: params.ui
+  };
+  drawBackground(r);
+  drawWrist(r);
+  drawWatch(r);
+  drawDimensions(r);
+}
+
+function drawBackground(r: RenderContext) {
+  const outerCircle = r.colors.getPropertyValue('--visualizer-outer-circle').trim();
+  const outerStroke = r.colors.getPropertyValue('--visualizer-outer-stroke').trim();
+  const drawWristW = r.wristW * r.scale;
+  const drawL2l = r.l2l * r.scale;
+  r.ctx.fillStyle = outerCircle;
+  r.ctx.strokeStyle = outerStroke;
+  r.ctx.lineWidth = 1;
+  r.ctx.beginPath();
+  r.ctx.arc(r.cx, r.cy, Math.max(drawWristW, drawL2l) / 2 + 20, 0, Math.PI * 2);
+  r.ctx.fill();
+  r.ctx.stroke();
+}
+
+function drawWrist(r: RenderContext) {
+  const wristFill = r.colors.getPropertyValue('--visualizer-wrist-fill').trim();
+  const wristStroke = r.colors.getPropertyValue('--visualizer-wrist-stroke').trim();
+  const drawWristW = r.wristW * r.scale;
+  r.ctx.fillStyle = wristFill;
+  r.ctx.strokeStyle = wristStroke;
+  r.ctx.lineWidth = 2;
+  r.ctx.beginPath();
+  r.ctx.ellipse(r.cx, r.cy, drawWristW / 2, 35, 0, 0, Math.PI * 2);
+  r.ctx.fill();
+  r.ctx.stroke();
+}
+
+function drawWatch(r: RenderContext) {
+  const watchFace = r.colors.getPropertyValue('--visualizer-watch-face').trim();
+  const watchInner = r.colors.getPropertyValue('--visualizer-watch-inner').trim();
+  const isOverhang = r.l2l > r.wristW;
+  const watchColor = isOverhang ? 'rgba(239, 68, 68, 0.8)' : 'rgba(244, 63, 94, 0.8)';
+  const lugColor = isOverhang ? 'rgba(239, 68, 68, 0.6)' : 'rgba(244, 63, 94, 0.5)';
+  const drawCaseD = r.caseD * r.scale;
+  const drawL2l = r.l2l * r.scale;
+  drawLugs(r, drawCaseD, drawL2l, lugColor);
+  r.ctx.fillStyle = watchFace;
+  r.ctx.strokeStyle = watchColor;
+  r.ctx.lineWidth = 4;
+  r.ctx.beginPath();
+  r.ctx.arc(r.cx, r.cy, drawCaseD / 2, 0, Math.PI * 2);
+  r.ctx.fill();
+  r.ctx.stroke();
+  r.ctx.fillStyle = watchInner;
+  r.ctx.beginPath();
+  r.ctx.arc(r.cx, r.cy, drawCaseD / 2.3, 0, Math.PI * 2);
+  r.ctx.fill();
+  drawHands(r, drawCaseD, watchColor);
+}
+
+function drawLugs(r: RenderContext, drawCaseD: number, drawL2l: number, lugColor: string) {
+  r.ctx.strokeStyle = lugColor;
+  r.ctx.lineWidth = 6;
+  r.ctx.lineCap = 'round';
+  r.ctx.beginPath();
+  r.ctx.moveTo(r.cx - drawL2l / 2, r.cy - 8);
+  r.ctx.lineTo(r.cx - drawCaseD / 3, r.cy - 8);
+  r.ctx.moveTo(r.cx + drawCaseD / 3, r.cy - 8);
+  r.ctx.lineTo(r.cx + drawL2l / 2, r.cy - 8);
+  r.ctx.moveTo(r.cx - drawL2l / 2, r.cy + 8);
+  r.ctx.lineTo(r.cx - drawCaseD / 3, r.cy + 8);
+  r.ctx.moveTo(r.cx + drawCaseD / 3, r.cy + 8);
+  r.ctx.lineTo(r.cx + drawL2l / 2, r.cy + 8);
+  r.ctx.stroke();
+}
+
+function drawHands(r: RenderContext, drawCaseD: number, watchColor: string) {
+  const watchHands = r.colors.getPropertyValue('--visualizer-watch-hands').trim();
+  r.ctx.strokeStyle = watchHands;
+  r.ctx.lineWidth = 2;
+  r.ctx.beginPath();
+  r.ctx.moveTo(r.cx, r.cy);
+  r.ctx.lineTo(r.cx + drawCaseD / 4, r.cy - drawCaseD / 6);
+  r.ctx.moveTo(r.cx, r.cy);
+  r.ctx.lineTo(r.cx, r.cy - drawCaseD / 3);
+  r.ctx.stroke();
+  r.ctx.fillStyle = watchColor;
+  r.ctx.beginPath();
+  r.ctx.arc(r.cx, r.cy, 3, 0, Math.PI * 2);
+  r.ctx.fill();
+}
+
+function drawDimensions(r: RenderContext) {
+  const drawWristW = r.wristW * r.scale;
+  const drawL2l = r.l2l * r.scale;
+  drawWristDim(r, drawWristW);
+  drawWatchDim(r, drawL2l);
+}
+
+function drawWristDim(r: RenderContext, drawWristW: number) {
+  const dimensionLine = r.colors.getPropertyValue('--visualizer-dim-line').trim();
+  const dimensionText = r.colors.getPropertyValue('--visualizer-dim-text').trim();
+  r.ctx.strokeStyle = dimensionLine;
+  r.ctx.lineWidth = 1;
+  r.ctx.setLineDash([4, 4]);
+  r.ctx.beginPath();
+  r.ctx.moveTo(r.cx - drawWristW / 2, r.cy - 45);
+  r.ctx.lineTo(r.cx - drawWristW / 2, r.cy + 45);
+  r.ctx.moveTo(r.cx + drawWristW / 2, r.cy - 45);
+  r.ctx.lineTo(r.cx + drawWristW / 2, r.cy + 45);
+  r.ctx.stroke();
+  r.ctx.setLineDash([]);
+  r.ctx.beginPath();
+  r.ctx.moveTo(r.cx - drawWristW / 2, r.cy - 50);
+  r.ctx.lineTo(r.cx + drawWristW / 2, r.cy - 50);
+  r.ctx.stroke();
+  r.ctx.beginPath();
+  r.ctx.moveTo(r.cx - drawWristW / 2, r.cy - 53);
+  r.ctx.lineTo(r.cx - drawWristW / 2, r.cy - 47);
+  r.ctx.moveTo(r.cx + drawWristW / 2, r.cy - 53);
+  r.ctx.lineTo(r.cx + drawWristW / 2, r.cy - 47);
+  r.ctx.stroke();
+  r.ctx.fillStyle = dimensionText;
+  r.ctx.font = '10px sans-serif';
+  r.ctx.textAlign = 'center';
+  const valText = r.unit === 'in' ? `${(r.wristW / 25.4).toFixed(2)} in` : `${(r.wristW / 10).toFixed(1)} cm`;
+  r.ctx.fillText(`${valText} ${r.ui.customLabel || 'Wrist'}`, r.cx, r.cy - 58);
+}
+
+function drawWatchDim(r: RenderContext, drawL2l: number) {
+  const isOverhang = r.l2l > r.wristW;
+  const watchColor = isOverhang ? 'rgba(239, 68, 68, 0.8)' : 'rgba(244, 63, 94, 0.8)';
+  r.ctx.strokeStyle = watchColor;
+  r.ctx.beginPath();
+  r.ctx.moveTo(r.cx - drawL2l / 2, r.cy + 50);
+  r.ctx.lineTo(r.cx + drawL2l / 2, r.cy + 50);
+  r.ctx.stroke();
+  r.ctx.beginPath();
+  r.ctx.moveTo(r.cx - drawL2l / 2, r.cy + 47);
+  r.ctx.lineTo(r.cx - drawL2l / 2, r.cy + 53);
+  r.ctx.moveTo(r.cx + drawL2l / 2, r.cy + 47);
+  r.ctx.lineTo(r.cx + drawL2l / 2, r.cy + 53);
+  r.ctx.stroke();
+  r.ctx.fillStyle = watchColor;
+  const l2lText = r.unit === 'in' ? `${(r.l2l / 25.4).toFixed(2)} in` : `${(r.l2l / 10).toFixed(1)} cm`;
+  r.ctx.fillText(`${l2lText} L2L`, r.cx, r.cy + 62);
+}

package/src/tool/wrist-presence-calculator/helpers/results.ts

@@ -0,0 +1,78 @@
+export function getRatioText(ratioClass: string, ui: Record<string, string>): string {
+  if (ratioClass === 'verdict-golden') return ui.verdictGolden || 'Golden Fit';
+  if (ratioClass === 'verdict-bold') return ui.verdictBold || 'Bold Fit';
+  if (ratioClass === 'verdict-oversized') return ui.verdictOversized || 'Oversized';
+  return ui.verdictVintage || 'Vintage/Classic';
+}
+
+export function getCoverageText(coverageClass: string, ui: Record<string, string>): string {
+  if (coverageClass === 'coverage-safe') return ui.coverageSafe || 'Safe Fit';
+  if (coverageClass === 'coverage-bold') return ui.coverageBold || 'Bold Fit';
+  return ui.coverageOverhang || 'Overhang Warning';
+}
+
+function formatVerdict(title: string, desc: string): string {
+  return `<strong>${title}:</strong> ${desc}`;
+}
+
+function getGoldenVerdict(ui: Record<string, string>): string {
+  return formatVerdict(
+    ui.verdictGolden || 'Golden Ratio Fit',
+    ui.verdictDescGolden || 'Excellent aesthetic balance! The watch diameter is perfectly proportioned to your wrist circumference, following traditional horology guidelines.'
+  );
+}
+
+function getBoldVerdict(ui: Record<string, string>): string {
+  return formatVerdict(
+    ui.verdictBold || 'Bold Fit',
+    ui.verdictDescBold || 'A modern, sporty presence. The watch occupies a significant portion of the wrist but fits well without looking disproportionately massive.'
+  );
+}
+
+function getVintageVerdict(ui: Record<string, string>): string {
+  return formatVerdict(
+    ui.verdictVintage || 'Vintage/Classic Fit',
+    ui.verdictDescVintage || 'A understated, elegant look. Ideal for formal dress watches or vintage styles, offering excellent comfort and a discreet wrist profile.'
+  );
+}
+
+function getRegularVerdictHtml(ratio: number, ui: Record<string, string>): string {
+  if (ratio >= 4.5 && ratio <= 5.0) {
+    return getGoldenVerdict(ui);
+  }
+  if (ratio >= 4.0 && ratio < 4.5) {
+    return getBoldVerdict(ui);
+  }
+  return getVintageVerdict(ui);
+}
+
+export function getVerdictHtml(
+  coverage: number,
+  ratio: number,
+  ui: Record<string, string>
+): string {
+  if (coverage > 100) {
+    return formatVerdict(
+      ui.coverageOverhang || 'Lug Overhang Warning',
+      ui.verdictDescOverhang || 'The watch lugs exceed your flat wrist width. This watch will likely feel unstable, slide around, and visually look too large.'
+    );
+  }
+  if (ratio < 4.0) {
+    return formatVerdict(
+      ui.verdictOversized || 'Oversized Fit',
+      ui.verdictDescOversized || 'The case diameter is very large relative to your wrist size. This creates a commanding modern presence but make sure the lugs feel comfortable.'
+    );
+  }
+  return getRegularVerdictHtml(ratio, ui);
+}
+
+export function formatWristValue(mm: number, unit: 'cm' | 'in'): string {
+  if (unit === 'in') {
+    return `${(mm / 25.4).toFixed(2)} in`;
+  }
+  return `${(mm / 10).toFixed(1)} cm`;
+}
+
+export function formatRecValue(mm: number, unit: 'cm' | 'in'): string {
+  return formatWristValue(mm, unit);
+}

package/src/tool/wrist-presence-calculator/i18n/de.ts

@@ -0,0 +1,139 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { WristPresenceCalculatorUI } from '../entry';
+import { bibliography } from '../bibliography';
+
+export const content: ToolLocaleContent<WristPresenceCalculatorUI> = {
+  slug: 'uhrenpraesenz-rechner',
+  title: 'Uhren Handgelenkpräsenz & Größenrechner',
+  description: 'Berechnen Sie das Gehäuse-zu-Handgelenk-Verhältnis, die flache Handgelenkbreite und ermitteln Sie die ideale Uhrengröße für Ihr Handgelenk basierend auf ästhetischen Richtlinien.',
+  ui: {
+    title: 'Handgelenkmaße',
+    wristCircumferenceLabel: 'Handgelenkumfang',
+    caseDiameterLabel: 'Gehäusedurchmesser',
+    lugToLugLabel: 'Steg-zu-Steg',
+    wristWidthLabel: 'Flache Handgelenkbreite',
+    autoEstimateWidthLabel: 'Flache Handgelenkbreite automatisch schätzen (30%)',
+    unitCm: 'CM',
+    unitInches: 'IN',
+    unitMm: 'MM',
+    fitAnalysisTitle: 'Handgelenkpassform-Analyse',
+    caseWristRatioLabel: 'Gehäuse-zu-Handgelenk-Verhältnis',
+    wristCoverageLabel: 'Handgelenkabdeckung',
+    verdictLabel: 'Ergebnis',
+    verdictOversized: 'Zu großes Gehäuse',
+    verdictBold: 'Mutige / Moderne Passform',
+    verdictGolden: 'Goldene / Klassische Passform',
+    verdictVintage: 'Vintage / Zu klein',
+    coverageSafe: 'Sichere Passform',
+    coverageBold: 'Mutige Passform',
+    coverageOverhang: 'Überhang-Warnung',
+    sweetSpotTitle: 'Trageweite',
+    sweetSpotDesc: 'Der Sweet Spot steht für das ausgewogenste Erscheinungsbild.',
+    minClassicLabel: 'Vintage / Klassische Passform',
+    sweetSpotLabel: 'Ästhetischer Sweet Spot',
+    maxBoldLabel: 'Modern / Mutige Passform',
+    maxLugToLugLabel: 'Max. empfohlener Steg-zu-Steg',
+    idealSizesTitle: 'Ideale Größenrichtlinien',
+    visualizerTitle: 'Live-Passform-Simulator',
+    wristWidthHelp: 'Schätzung basierend auf der Handgelenkform.',
+    estimatedLabel: 'geschätzt',
+    customLabel: 'Handgelenk',
+  },
+  seo: [
+    { type: 'title', text: 'Die perfekte Uhrengröße finden: Der Proportions-Ratgeber', level: 2 },
+    { type: 'paragraph', html: 'Die richtige Uhrengröße zu finden ist eine Kombination aus Mathematik, Geometrie und persönlichem Stil. In der Uhrmacherei bezeichnet man das Erscheinungsbild einer Uhr am Arm als <strong>Handgelenkpräsenz</strong>. Eine Uhr sollte ausgewogen wirken – weder mit unschönem Überhang dominieren noch wie ein winziger Punkt verschwinden. Um diese Balance zu erreichen, analysieren Sammler drei Hauptmerkmale: Gehäusedurchmesser, Steg-zu-Steg-Abstand und Handgelenkform.' },
+    { type: 'title', text: 'Das Gehäuse-zu-Handgelenk-Verhältnis verstehen', level: 3 },
+    { type: 'paragraph', html: 'Eine klassische Methode zur Beurteilung von Uhrenproportionen ist das Gehäuse-zu-Handgelenk-Verhältnis. Dazu teilt man den Handgelenkumfang in Millimetern durch den Gehäusedurchmesser. Verhältnisse zwischen <strong>4,5 und 5,0</strong> gelten als klassischer Sweet Spot. Verhältnisse von <strong>4,0 bis 4,5</strong> wirken mutig und modern. Über 5,0 entsteht ein Vintage-Dresswatches-Feeling, unter 4,0 wirkt die Uhr überdimensioniert.' },
+    { type: 'title', text: 'Warum der Steg-zu-Steg-Abstand wichtiger ist als der Durchmesser', level: 3 },
+    { type: 'paragraph', html: 'Obwohl der Gehäusedurchmesser im Vordergrund steht, ist der <strong>Steg-zu-Steg-Abstand</strong> (die senkrechte Länge von Stegspitze zu Stegspitze) der eigentliche Maßstab für eine gute Passform. Die goldene Regel lautet: Der Steg-zu-Steg-Abstand darf die flache Handgelenkbreite nicht überschreiten. Stehen die Stege über, gleitet die Uhr, es entsteht ein Spalt zwischen Band und Haut, und das optische Erscheinungsbild leidet.' },
+    { type: 'title', text: 'Flache vs. runde Handgelenke: Größen je nach Anatomie', level: 3 },
+    { type: 'paragraph', html: 'Der Handgelenkumfang erzählt nur einen Teil der Geschichte. Handgelenke mit gleichem Umfang können unterschiedliche Querschnittsformen haben: flach oder rund. Flache Handgelenke bieten eine breitere Auflagefläche und vertragen längere Steg-zu-Steg-Abstände. Runde Handgelenke sind oben schmaler und erfordern kürzere Steg-zu-Steg-Maße, um Überhang zu vermeiden.' },
+  ],
+  faq: [
+    {
+      question: 'Was ist das ideale Gehäuse-zu-Handgelenk-Verhältnis?',
+      answer: 'Das ideale Verhältnis liegt zwischen 4,0 und 5,0. Ein Verhältnis von 4,5 gilt als klassischer uhrmacherischer Sweet Spot. Zwischen 4,0 und 4,5 entsteht eine moderne, auffällige Präsenz; über 5,0 eignet sich die Uhr eher für den Vintage-Dresswatches-Stil; unter 4,0 wirkt das Gehäuse überdimensioniert.',
+    },
+    {
+      question: 'Warum ist der Steg-zu-Steg-Abstand wichtiger als der Gehäusedurchmesser?',
+      answer: 'Der Gehäusedurchmesser misst nur die Breite des Zifferblatts. Der Steg-zu-Steg-Abstand bestimmt hingegen, wie weit die Uhr über das Handgelenk reicht. Überschreitet er die flache Handgelenkbreite, hängen die Stege über, das Band fällt senkrecht ab, und die Uhr wirkt instabil und unverhältnismäßig groß.',
+    },
+    {
+      question: 'Wie beeinflussen flache und runde Handgelenke die Passform?',
+      answer: 'Zwei Handgelenke mit gleichem Umfang (z. B. 17 cm) können Uhren sehr unterschiedlich tragen. Ein flaches Handgelenk hat eine breitere Auflagefläche und verträgt längere Steg-zu-Steg-Abstände ohne Überhang. Ein rundes Handgelenk ist oben schmaler und braucht kürzere Steg-zu-Steg-Maße für eine stabile Passform.',
+    },
+    {
+      question: 'Wie verändern Dicke und Lünettengröße das optische Erscheinungsbild einer Uhr?',
+      answer: 'Uhren mit sehr schmaler Lünette (wie Dresswatches) haben eine größere Zifferblattfläche und wirken am Handgelenk größer als ihr tatsächlicher Durchmesser vermuten lässt. Taucheruhren mit breiter Drehlünette haben ein kleineres Zifferblatt und tragen dadurch kompakter. Uhren mit mehr als 13 mm Höhe wirken zudem wuchtiger und optisch schwerer.',
+    },
+  ],
+  bibliography,
+  howTo: [
+    {
+      name: 'Handgelenk messen',
+      text: 'Legen Sie ein flexibles Maßband um Ihren Handgelenkknochen, um den Umfang in cm oder Zoll zu ermitteln.',
+    },
+    {
+      name: 'Uhrenmaße eingeben',
+      text: 'Tragen Sie den Gehäusedurchmesser und den Steg-zu-Steg-Abstand der zu prüfenden Uhr ein.',
+    },
+    {
+      name: 'Passform und Live-Simulator analysieren',
+      text: 'Prüfen Sie das Gehäuse-zu-Handgelenk-Verhältnis, die Steg-Überhang-Warnung und sehen Sie das Echtzeit-Diagramm.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      'mainEntity': [
+        {
+          '@type': 'Question',
+          'name': 'Was ist das ideale Gehäuse-zu-Handgelenk-Verhältnis?',
+          'acceptedAnswer': {
+            '@type': 'Answer',
+            'text': 'Das ideale Verhältnis liegt zwischen 4,0 und 5,0. Ein Verhältnis von 4,5 gilt als klassischer uhrmacherischer Sweet Spot. Zwischen 4,0 und 4,5 entsteht eine moderne, auffällige Präsenz; über 5,0 eignet sich die Uhr eher für den Vintage-Dresswatches-Stil; unter 4,0 wirkt das Gehäuse überdimensioniert.'
+          }
+        },
+        {
+          '@type': 'Question',
+          'name': 'Warum ist der Steg-zu-Steg-Abstand wichtiger als der Gehäusedurchmesser?',
+          'acceptedAnswer': {
+            '@type': 'Answer',
+            'text': 'Der Gehäusedurchmesser misst nur die Breite des Zifferblatts. Der Steg-zu-Steg-Abstand bestimmt hingegen, wie weit die Uhr über das Handgelenk reicht. Überschreitet er die flache Handgelenkbreite, hängen die Stege über, das Band fällt senkrecht ab, und die Uhr wirkt instabil und unverhältnismäßig groß.'
+          }
+        }
+      ]
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      'name': 'Uhren-Handgelenkpräsenz & Größenrechner',
+      'operatingSystem': 'All',
+      'applicationCategory': 'UtilitiesApplication',
+      'browserRequirements': 'Requires HTML5. Requires JavaScript.'
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      'name': 'Wie man die perfekte Uhrengröße bestimmt',
+      'step': [
+        {
+          '@type': 'HowToStep',
+          'name': 'Handgelenk messen',
+          'text': 'Legen Sie ein flexibles Maßband um Ihren Handgelenkknochen, um den Umfang in cm oder Zoll zu ermitteln.'
+        },
+        {
+          '@type': 'HowToStep',
+          'name': 'Uhrenmaße eingeben',
+          'text': 'Tragen Sie den Gehäusedurchmesser und den Steg-zu-Steg-Abstand der zu prüfenden Uhr ein.'
+        },
+        {
+          '@type': 'HowToStep',
+          'name': 'Passform und Live-Simulator analysieren',
+          'text': 'Prüfen Sie das Gehäuse-zu-Handgelenk-Verhältnis, die Steg-Überhang-Warnung und sehen Sie das Echtzeit-Diagramm.'
+        }
+      ]
+    }
+  ]
+};

package/src/tool/wrist-presence-calculator/i18n/en.ts

@@ -0,0 +1,155 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { WristPresenceCalculatorUI } from '../entry';
+import { bibliography } from '../bibliography';
+
+export const content: ToolLocaleContent<WristPresenceCalculatorUI> = {
+  slug: 'wrist-presence-calculator',
+  title: 'Watch Wrist Presence & Sizing Calculator',
+  description: 'Calculate the case-to-wrist ratio, flat wrist width coverage, and determine the ideal watch size for your wrist based on aesthetic guidelines.',
+  ui: {
+    title: 'Wrist Sizing Settings',
+    wristCircumferenceLabel: 'Wrist Circumference',
+    caseDiameterLabel: 'Case Diameter',
+    lugToLugLabel: 'Lug-to-Lug',
+    wristWidthLabel: 'Flat Wrist Width',
+    autoEstimateWidthLabel: 'Auto-estimate flat wrist width (30%)',
+    unitCm: 'CM',
+    unitInches: 'IN',
+    unitMm: 'MM',
+    fitAnalysisTitle: 'Wrist Fit Assessment',
+    caseWristRatioLabel: 'Case-to-Wrist Ratio',
+    wristCoverageLabel: 'Wrist Coverage',
+    verdictLabel: 'Verdict',
+    verdictOversized: 'Oversized Fit',
+    verdictBold: 'Bold / Modern Fit',
+    verdictGolden: 'Golden / Classic Fit',
+    verdictVintage: 'Vintage / Undersized',
+    coverageSafe: 'Safe Fit',
+    coverageBold: 'Bold Fit',
+    coverageOverhang: 'Overhang Warning',
+    sweetSpotTitle: 'Fit Style',
+    sweetSpotDesc: 'The sweet spot represents the most balanced visual appearance.',
+    minClassicLabel: 'Vintage / Classic Fit',
+    sweetSpotLabel: 'Aesthetic Sweet Spot',
+    maxBoldLabel: 'Modern / Bold Fit',
+    maxLugToLugLabel: 'Max Recommended Lug-to-Lug',
+    idealSizesTitle: 'Ideal Sizing Guidelines',
+    visualizerTitle: 'Live Fit Simulator',
+    wristWidthHelp: 'Estimated based on wrist shape.',
+    estimatedLabel: 'estimated',
+    customLabel: 'Wrist',
+  },
+  seo: [
+    { type: 'title', text: 'How to Choose the Perfect Watch Size: The Proportional Fit Guide', level: 2 },
+    { type: 'paragraph', html: 'Finding the right watch size is a blend of mathematics, geometry, and personal style. In horology, how a timepiece sits on your arm is called <strong>wrist presence</strong>. A watch should look balanced—neither dominating your arm with unsightly overhang nor disappearing like a tiny speck. To achieve this balance, watch collectors analyze three main metrics: case diameter, lug-to-lug distance, and wrist shape.' },
+    { type: 'title', text: 'Understanding the Case-to-Wrist Sizing Ratio', level: 3 },
+    { type: 'paragraph', html: 'A traditional method to gauge watch proportions is the case-to-wrist ratio. By converting your wrist circumference to millimeters and dividing it by the watch\'s case diameter, you get a ratio. Ratios between <strong>4.5 and 5.0</strong> represent the classic sweet spot. Ratios from <strong>4.0 to 4.5</strong> create a bold, sporty modern look. Ratios above 5.0 offer a vintage dress watch aesthetic, while ratios below 4.0 are considered oversized.' },
+    { type: 'title', text: 'Why Lug-to-Lug and Flat Wrist Width Define the Real Fit', level: 3 },
+    { type: 'paragraph', html: 'While case diameter gets all the attention, <strong>lug-to-lug distance</strong> (the vertical length from top lug tips to bottom lug tips) is the true test of fit. The golden rule of watch sizing is that the lug-to-lug distance should never exceed the flat width of your wrist. If the lugs extend past your wrist edges, it creates a lug overhang. This results in the watch sliding around, a gap between the strap and your skin, and a poor visual appearance.' },
+    { type: 'title', text: 'Flat vs. Round Wrists: Sizing for Your Specific Anatomy', level: 3 },
+    { type: 'paragraph', html: 'Wrist circumference only tells part of the story. Wrists with identical circumferences can have different cross-sectional shapes: flat or round. Flat wrists have a wider top surface, meaning they can wear watches with longer lug-to-lug spans safely. Round wrists are more cylindrical, meaning they have a narrower flat top surface and require shorter lug-to-lug distances to avoid overhang.' },
+  ],
+  faq: [
+    {
+      question: 'What is the ideal watch case-to-wrist ratio?',
+      answer: 'The ideal case-to-wrist ratio is between 4.0 and 5.0. Divided by wrist circumference, a ratio of 4.5 represents the traditional horology sweet spot. A ratio of 4.0 to 4.5 offers a modern, bold wrist presence, while ratios above 5.0 suit vintage dress watches, and ratios below 4.0 tend to look oversized.',
+    },
+    {
+      question: 'Why does watch lug-to-lug distance matter more than case diameter?',
+      answer: 'Case diameter only measures the width of the watch face, but lug-to-lug defines the total length of the watch across your wrist. If the lug-to-lug length exceeds your flat wrist width, the lugs will overhang, causing the strap to drape vertically. This makes the watch look unstable and disproportionately large.',
+    },
+    {
+      question: 'How do flat vs. round wrists affect watch sizing and fit?',
+      answer: 'Two wrists with the same circumference (e.g., 17 cm) can wear watches differently. A flat wrist has a wider top surface, allowing it to accommodate longer lug-to-lug watches without overhang. A round wrist is narrower on top, requiring shorter lug-to-lug lengths for a stable fit.',
+    },
+    {
+      question: 'How do thickness and bezel width change a watch\'s visual size?',
+      answer: 'Watches with very thin bezels (like dress watches) have a larger dial surface area and look larger on the wrist than their actual diameter. Dive watches with thick rotating bezels have a smaller dial, making them wear smaller. Similarly, watches thicker than 13mm appear chunkier and have greater visual weight.',
+    },
+  ],
+  bibliography,
+  howTo: [
+    {
+      name: 'Measure Your Wrist',
+      text: 'Wrap a flexible measuring tape around your wrist bone to find your circumference in cm or inches.',
+    },
+    {
+      name: 'Enter Watch Dimensions',
+      text: 'Input the case diameter and the lug-to-lug distance of the watch you are evaluating.',
+    },
+    {
+      name: 'Analyze Fit and Visual Simulator',
+      text: 'Check the Case-to-Wrist ratio, check the lug overhang alert, and view the real-time simulation diagram.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      'mainEntity': [
+        {
+          '@type': 'Question',
+          'name': 'What is the ideal watch case-to-wrist ratio?',
+          'acceptedAnswer': {
+            '@type': 'Answer',
+            'text': 'The ideal case-to-wrist ratio is between 4.0 and 5.0. Divided by wrist circumference, a ratio of 4.5 represents the traditional horology sweet spot. A ratio of 4.0 to 4.5 offers a modern, bold wrist presence, while ratios above 5.0 suit vintage dress watches, and ratios below 4.0 tend to look oversized.'
+          }
+        },
+        {
+          '@type': 'Question',
+          'name': 'Why does watch lug-to-lug distance matter more than case diameter?',
+          'acceptedAnswer': {
+            '@type': 'Answer',
+            'text': 'Case diameter only measures the width of the watch face, but lug-to-lug defines the total length of the watch across your wrist. If the lug-to-lug length exceeds your flat wrist width, the lugs will overhang, causing the strap to drape vertically. This makes the watch look unstable and disproportionately large.'
+          }
+        },
+        {
+          '@type': 'Question',
+          'name': 'How do flat vs. round wrists affect watch sizing and fit?',
+          'acceptedAnswer': {
+            '@type': 'Answer',
+            'text': 'Two wrists with the same circumference (e.g., 17 cm) can wear watches differently. A flat wrist has a wider top surface, allowing it to accommodate longer lug-to-lug watches without overhang. A round wrist is narrower on top, requiring shorter lug-to-lug lengths for a stable fit.'
+          }
+        },
+        {
+          '@type': 'Question',
+          'name': 'How do thickness and bezel width change a watch\'s visual size?',
+          'acceptedAnswer': {
+            '@type': 'Answer',
+            'text': 'Watches with very thin bezels (like dress watches) have a larger dial surface area and look larger on the wrist than their actual diameter. Dive watches with thick rotating bezels have a smaller dial, making them wear smaller. Similarly, watches thicker than 13mm appear chunkier and have greater visual weight.'
+          }
+        }
+      ]
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      'name': 'Watch Wrist Presence & Sizing Calculator',
+      'operatingSystem': 'All',
+      'applicationCategory': 'UtilitiesApplication',
+      'browserRequirements': 'Requires HTML5. Requires JavaScript.'
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      'name': 'How to Determine Perfect Watch Size',
+      'step': [
+        {
+          '@type': 'HowToStep',
+          'name': 'Measure Your Wrist',
+          'text': 'Wrap a flexible measuring tape around your wrist bone to find your circumference in cm or inches.'
+        },
+        {
+          '@type': 'HowToStep',
+          'name': 'Enter Watch Dimensions',
+          'text': 'Input the case diameter and the lug-to-lug distance of the watch you are evaluating.'
+        },
+        {
+          '@type': 'HowToStep',
+          'name': 'Analyze Fit and Visual Simulator',
+          'text': 'Check the Case-to-Wrist ratio, check the lug overhang alert, and view the real-time simulation diagram.'
+        }
+      ]
+    }
+  ]
+};