@jjlmoya/utils-chrono 1.18.0 → 1.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-chrono",
-    "version": "1.18.0",
+    "version": "1.19.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -20,6 +20,7 @@ import { perpetualCalendar } from '../tool/perpetual-calendar/entry';
 import { tourbillonVisualizer } from '../tool/tourbillon-visualizer/entry';
 import { gmtWorldTimer } from '../tool/gmt-world-timer/entry';
 import { quartzBatteryHealth } from '../tool/quartz-battery-health/entry';
+import { mainspringFinder } from '../tool/mainspring-finder/entry';
 
 export const chronoCategory: ChronoCategoryEntry = {
   icon: 'mdi:clock-outline',
@@ -45,6 +46,7 @@ export const chronoCategory: ChronoCategoryEntry = {
     tourbillonVisualizer,
     gmtWorldTimer,
     quartzBatteryHealth,
+    mainspringFinder,
   ],
   i18n: {
     de: () => import('./i18n/de').then((m) => m.content),

package/src/entries.ts

@@ -42,6 +42,8 @@ export { gmtWorldTimer } from './tool/gmt-world-timer/entry';
 export type { GMTWorldTimerUI, GMTWorldTimerLocaleContent } from './tool/gmt-world-timer/entry';
 export { quartzBatteryHealth } from './tool/quartz-battery-health/entry';
 export type { QuartzBatteryHealthUI, QuartzBatteryHealthLocaleContent } from './tool/quartz-battery-health/entry';
+export { mainspringFinder } from './tool/mainspring-finder/entry';
+export type { MainspringFinderUI, MainspringFinderLocaleContent } from './tool/mainspring-finder/entry';
 export { chronoCategory } from './category';
 
 import { watchAccuracyTracker } from './tool/watch-accuracy-tracker/entry';
@@ -66,6 +68,7 @@ import { perpetualCalendar } from './tool/perpetual-calendar/entry';
 import { tourbillonVisualizer } from './tool/tourbillon-visualizer/entry';
 import { gmtWorldTimer } from './tool/gmt-world-timer/entry';
 import { quartzBatteryHealth } from './tool/quartz-battery-health/entry';
+import { mainspringFinder } from './tool/mainspring-finder/entry';
 
-export const ALL_ENTRIES = [watchAccuracyTracker, wristPresenceCalculator, demagnetizingTimer, watchSavingsPlanner, crownReferenceGuide, powerReserveEstimator, beatRateConverter, waterResistanceConverter, strapTaperCalculator, watchSizeComparator, lumeColorSimulator, moonPhaseVisualizer, tachymeterCalculator, serviceIntervalTracker, strapLengthCalculator, telemeterCalculator, siderealTimeTracker, gearTrainExplorer, perpetualCalendar, tourbillonVisualizer, gmtWorldTimer, quartzBatteryHealth];
+export const ALL_ENTRIES = [watchAccuracyTracker, wristPresenceCalculator, demagnetizingTimer, watchSavingsPlanner, crownReferenceGuide, powerReserveEstimator, beatRateConverter, waterResistanceConverter, strapTaperCalculator, watchSizeComparator, lumeColorSimulator, moonPhaseVisualizer, tachymeterCalculator, serviceIntervalTracker, strapLengthCalculator, telemeterCalculator, siderealTimeTracker, gearTrainExplorer, perpetualCalendar, tourbillonVisualizer, gmtWorldTimer, quartzBatteryHealth, mainspringFinder];
 

package/src/index.ts

@@ -16,6 +16,7 @@ export { tachymeterCalculator, TACHYMETER_CALCULATOR_TOOL } from './tool/tachyme
 export { serviceIntervalTracker, SERVICE_INTERVAL_TRACKER_TOOL } from './tool/service-interval-tracker';
 export { strapLengthCalculator, STRAP_LENGTH_CALCULATOR_TOOL } from './tool/strap-length-calculator';
 export { quartzBatteryHealth, QUARTZ_BATTERY_HEALTH_TOOL } from './tool/quartz-battery-health';
+export { mainspringFinder, MAINSPRING_FINDER_TOOL } from './tool/mainspring-finder';
 
 export type {
   KnownLocale,

package/src/tests/locale_completeness.test.ts

@@ -22,7 +22,7 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(22);
+    expect(ALL_TOOLS.length).toBe(23);
   });
 
 });

package/src/tests/tool_validation.test.ts

@@ -5,7 +5,7 @@ import { chronoCategory } from '../data';
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
     it('should have tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(22);
+      expect(ALL_TOOLS.length).toBe(23);
     });
 
 

package/src/tool/mainspring-finder/bibliography.astro

@@ -0,0 +1,16 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { mainspringFinder } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props as Props;
+const loader = mainspringFinder.i18n[locale] || mainspringFinder.i18n.en;
+const content = await loader?.();
+if (!content) return null;
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/mainspring-finder/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Mainspring Dimensions & Specifications - Ranfft',
+    url: 'https://ranfft.org/caliber/5755-FHF-76-2',
+  },
+  {
+    name: 'Watch Mainspring Guide',
+    url: 'https://www.vintagewatchstraps.com/mainsprings.php',
+  },
+  {
+    name: 'Mainspring Sizing Chart - Cousins UK',
+    url: 'https://www.cousinsuk.com/category/filter/mainsprings-by-size-search-watch-pocket',
+  },
+];

package/src/tool/mainspring-finder/client.ts

@@ -0,0 +1,89 @@
+import { calculateMainspring, fmt } from './helpers';
+
+const el = document.querySelector('.msf') as HTMLElement;
+const UI = JSON.parse(el.dataset.ui || '{}');
+
+const barrelIn = document.getElementById('msf-barrel') as HTMLInputElement;
+const arborIn = document.getElementById('msf-arbor') as HTMLInputElement;
+const heightIn = document.getElementById('msf-height') as HTMLInputElement;
+const turnsIn = document.getElementById('msf-turns') as HTMLInputElement;
+const unitBtns = document.querySelectorAll('.msf-u-btn') as NodeListOf<HTMLElement>;
+const result = document.getElementById('msf-result') as HTMLElement;
+const thickV = document.getElementById('msf-thick') as HTMLElement;
+const heightV = document.getElementById('msf-h') as HTMLElement;
+const lenV = document.getElementById('msf-len') as HTMLElement;
+const strengthB = document.getElementById('msf-strength') as HTMLElement;
+const commV = document.getElementById('msf-comm') as HTMLElement;
+
+const sLabels = [UI.strengthWeak || 'Light', UI.strengthMedium || 'Medium', UI.strengthStrong || 'Strong'];
+const sColors = ['#10b981', '#f59e0b', '#ef4444'];
+const KEY = 'jjlmoya_chrono_msf';
+let cur: 'mm' | 'in' = 'mm';
+
+interface S { b: string; a: string; h: string; t: string; u: string }
+
+function parseNum(v: string): number {
+  return parseFloat(v.replace(',', '.')) || 0;
+}
+
+function save() {
+  try { localStorage.setItem(KEY, JSON.stringify({ b: barrelIn.value, a: arborIn.value, h: heightIn.value, t: turnsIn.value, u: cur } as S)); } catch {}
+}
+
+function load() {
+  try {
+    const r = localStorage.getItem(KEY);
+    if (!r) return;
+    const s: S = JSON.parse(r);
+    const pairs: [string | undefined, HTMLInputElement][] = [[s.b, barrelIn], [s.a, arborIn], [s.h, heightIn], [s.t, turnsIn]];
+    for (const [v, el] of pairs) { if (v) el.value = v; }
+    if (s.u === 'in' || s.u === 'mm') cur = s.u;
+  } catch {}
+}
+
+function convertVal(v: number, from: 'mm' | 'in', to: 'mm' | 'in'): number {
+  if (from === to) return v;
+  return to === 'in' ? v / 25.4 : v * 25.4;
+}
+
+function setUnit(u: 'mm' | 'in') {
+  if (u === cur) return;
+  const b = parseNum(barrelIn.value);
+  const a = parseNum(arborIn.value);
+  const h = parseNum(heightIn.value);
+  barrelIn.value = convertVal(b, cur, u).toFixed(u === 'in' ? 2 : 1);
+  arborIn.value = convertVal(a, cur, u).toFixed(u === 'in' ? 3 : 1);
+  heightIn.value = convertVal(h, cur, u).toFixed(u === 'in' ? 3 : 2);
+  barrelIn.step = ''; arborIn.step = ''; heightIn.step = '';
+  cur = u;
+  unitBtns.forEach(b => b.classList.toggle('msf-u-on', b.dataset.unit === u));
+  calc();
+}
+
+function calc() {
+  const barrelId = parseNum(barrelIn.value);
+  const arborD = parseNum(arborIn.value);
+  const height = parseNum(heightIn.value);
+  const turns = parseInt(turnsIn.value, 10) || 6;
+  const r = calculateMainspring({ barrelId, barrelH: height, arborD, turns, unit: cur });
+  if (!r) { result.style.display = 'none'; return; }
+
+  const ul = cur;
+  thickV.textContent = `${fmt(r.thickness, cur, cur === 'in' ? 4 : 3)} ${ul}`;
+  heightV.textContent = `${fmt(r.height, cur, 2)} ${ul}`;
+  lenV.textContent = `${fmt(r.length, cur, 1)} ${ul}`;
+  strengthB.textContent = sLabels[r.strengthIndex];
+  strengthB.style.background = sColors[r.strengthIndex];
+  commV.textContent = `${fmt(r.height, cur, 2)} x ${fmt(r.thickness, cur, cur === 'in' ? 4 : 3)} x ${fmt(r.length, cur, 1)} ${ul}`;
+  result.style.display = 'flex';
+  save();
+}
+
+unitBtns.forEach(b => b.addEventListener('click', () => setUnit(b.dataset.unit as 'mm' | 'in')));
+barrelIn.addEventListener('input', calc);
+arborIn.addEventListener('input', calc);
+heightIn.addEventListener('input', calc);
+turnsIn.addEventListener('input', calc);
+load();
+setUnit(cur);
+calc();

package/src/tool/mainspring-finder/component.astro

@@ -0,0 +1,72 @@
+---
+interface Props { ui: Record<string, string> }
+const { ui } = Astro.props;
+---
+
+<div class="msf" data-ui={JSON.stringify(ui)}>
+  <div class="msf-top">
+    <div class="msf-u">
+      <button class="msf-u-btn msf-u-on" data-unit="mm" type="button">{ui.mm || "mm"}</button>
+      <button class="msf-u-btn" data-unit="in" type="button">{ui.inch || "in"}</button>
+    </div>
+  </div>
+
+  <div class="msf-grid">
+    <label class="msf-f">
+      <span class="msf-f-l">{ui.barrelLabel || "Barrel ID"}</span>
+      <input class="msf-f-i" id="msf-barrel" type="text" inputmode="decimal" value="14.0" />
+    </label>
+    <label class="msf-f">
+      <span class="msf-f-l">{ui.arborLabel || "Arbor OD"}</span>
+      <input class="msf-f-i" id="msf-arbor" type="text" inputmode="decimal" value="3.5" />
+    </label>
+    <label class="msf-f">
+      <span class="msf-f-l">{ui.heightLabel || "Height"}</span>
+      <input class="msf-f-i" id="msf-height" type="text" inputmode="decimal" value="1.50" />
+    </label>
+    <label class="msf-f">
+      <span class="msf-f-l">{ui.turnsLabel || "Turns"}</span>
+      <input class="msf-f-i" id="msf-turns" type="text" inputmode="numeric" value="6" />
+    </label>
+  </div>
+
+  <div class="msf-r" id="msf-result">
+    <div class="msf-r-grid">
+      <div class="msf-r-c">
+        <span class="msf-r-c-l">{ui.resultThickness || "Thickness"}</span>
+        <span class="msf-r-c-v" id="msf-thick">--</span>
+      </div>
+      <div class="msf-r-c">
+        <span class="msf-r-c-l">{ui.resultHeight || "Height"}</span>
+        <span class="msf-r-c-v" id="msf-h">--</span>
+      </div>
+      <div class="msf-r-c">
+        <span class="msf-r-c-l">{ui.resultLength || "Length"}</span>
+        <span class="msf-r-c-v" id="msf-len">--</span>
+      </div>
+    </div>
+    <div class="msf-r-bot">
+      <div class="msf-r-bot-i">
+        <span class="msf-r-bot-l">{ui.resultStrength || "Strength"}</span>
+        <span class="msf-badge" id="msf-strength">--</span>
+      </div>
+      <div class="msf-r-bot-i">
+        <span class="msf-r-bot-l">{ui.commercial || "Size"}</span>
+        <span class="msf-r-bot-v" id="msf-comm">--</span>
+      </div>
+    </div>
+  </div>
+
+  <div class="msf-steps">
+    <div class="msf-step"><span class="msf-step-n">1</span><span>{ui.step1 || "Measure barrel ID, arbor OD, and height."}</span></div>
+    <div class="msf-step"><span class="msf-step-n">2</span><span>{ui.step2 || "Set winding turns (5-8 manual, 6-10 auto)."}</span></div>
+    <div class="msf-step"><span class="msf-step-n">3</span><span>{ui.step3 || "Toggle mm/in for your unit."}</span></div>
+  </div>
+
+  <div class="msf-tip">
+    <svg viewBox="0 0 24 24" width="14" height="14" style="flex-shrink:0;margin-top:0.05rem"><path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-2 15l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z" fill="currentColor"/></svg>
+    <span>{ui.tipContent || "Always verify against manufacturer specs before ordering."}</span>
+  </div>
+</div>
+
+<script src="./client.ts"></script>

package/src/tool/mainspring-finder/entry.ts

@@ -0,0 +1,50 @@
+import type { ChronoToolEntry, ToolLocaleContent } from '../../types';
+
+export type MainspringFinderUI = {
+  title: string;
+  barrelLabel: string;
+  arborLabel: string;
+  heightLabel: string;
+  turnsLabel: string;
+  calculate: string;
+  resultThickness: string;
+  resultHeight: string;
+  resultLength: string;
+  resultStrength: string;
+  strengthWeak: string;
+  strengthMedium: string;
+  strengthStrong: string;
+  commercial: string;
+  unitLabel: string;
+  mm: string;
+  inch: string;
+  step1: string;
+  step2: string;
+  step3: string;
+  tipTitle: string;
+  tipContent: string;
+};
+
+export type MainspringFinderLocaleContent = ToolLocaleContent<MainspringFinderUI>;
+
+export const mainspringFinder: ChronoToolEntry<MainspringFinderUI> = {
+  id: 'mainspring-finder',
+  icons: { bg: 'mdi:ruler', fg: 'mdi:cog-clockwise' },
+  i18n: {
+    en: () => import('./i18n/en').then((m) => m.content),
+    de: () => import('./i18n/de').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/mainspring-finder/helpers.ts

@@ -0,0 +1,52 @@
+export interface MainspringInput {
+  barrelId: number;
+  barrelH: number;
+  arborD: number;
+  turns: number;
+  unit: 'mm' | 'in';
+}
+
+export interface MainspringResult {
+  thickness: number;
+  height: number;
+  length: number;
+  strengthIndex: number;
+}
+
+export function toMm(val: number, unit: 'mm' | 'in'): number {
+  return unit === 'in' ? val * 25.4 : val;
+}
+
+export function fmt(val: number, unit: 'mm' | 'in', dec: number): string {
+  const v = unit === 'in' ? val / 25.4 : val;
+  return v.toFixed(dec);
+}
+
+function getStrengthIndex(thickness: number): number {
+  if (thickness <= 0.10) return 0;
+  if (thickness <= 0.18) return 1;
+  return 2;
+}
+
+export function calculateMainspring(input: MainspringInput): MainspringResult | null {
+  let { barrelId, barrelH, arborD } = input;
+  const { turns, unit } = input;
+  barrelId = toMm(barrelId, unit);
+  barrelH = toMm(barrelH, unit);
+  arborD = toMm(arborD, unit);
+
+  if (barrelId <= 0 || arborD <= 0 || barrelH <= 0 || arborD >= barrelId) return null;
+
+  const clearance = 0.1;
+  const height = barrelH - clearance;
+
+  const thickness = (barrelId - arborD) / (4 * Math.PI * turns);
+  const length = (Math.PI * turns * (barrelId + arborD)) / 2;
+
+  return {
+    thickness: Math.round(thickness * 1000) / 1000,
+    height: Math.round(height * 100) / 100,
+    length: Math.round(length * 10) / 10,
+    strengthIndex: getStrengthIndex(thickness),
+  };
+}

package/src/tool/mainspring-finder/i18n/de.ts

@@ -0,0 +1,212 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { MainspringFinderUI } from '../entry';
+import { bibliography } from '../bibliography';
+
+export const content: ToolLocaleContent<MainspringFinderUI> = {
+  slug: 'zugfeder-rechner',
+    title: 'Zugfeder Rechner',
+  description: 'Berechnen Sie Zugfederabmessungen aus Federhausmessungen für Vintage-Uhrwerke.',
+  ui: {
+  title: 'Zugfeder Rechner',
+    barrelLabel: 'Federhaus-ID',
+    arborLabel: 'Wellen-AD',
+    heightLabel: 'Federhaushöhe',
+    turnsLabel: 'Umdrehungen',
+    calculate: 'Berechnen',
+    resultThickness: 'Stärke',
+    resultHeight: 'Höhe',
+    resultLength: 'Länge',
+    resultStrength: 'Federkraft',
+    strengthWeak: 'Leicht',
+    strengthMedium: 'Mittel',
+    strengthStrong: 'Stark',
+    commercial: 'Handelsgröße',
+    unitLabel: 'Einheit',
+    mm: 'mm',
+    inch: 'Zoll',
+    step1: 'Messen Sie Federhaus-ID, Wellen-AD und innere Höhe mit einem Messschieber.',
+    step2: 'Stellen Sie die erwartete Anzahl Aufzugsumdrehungen ein (5-8 Handaufzug, 6-10 Automatik).',
+    step3: 'Wechseln Sie zwischen mm/Zoll für Ihr bevorzugtes Einheitensystem.',
+    tipTitle: 'Tipp',
+    tipContent: 'Überprüfen Sie die berechneten Maße immer mit den Herstellerangaben. Gleichen Sie sie vor der Bestellung mit Lieferantenkatalogen ab.',
+  },
+  seo: [
+    { type: 'title', text: 'Zugfeder-Rechner: Federabmessungen für Uhrwerke berechnen', level: 2 },
+    {
+      type: 'stats',
+      items: [
+        { value: '0.08-0.18 mm', label: 'Typische Federstärke' },
+        { value: '5-10 Umdrehungen', label: 'Üblicher Aufzugsbereich' },
+        { value: '150-450 mm', label: 'Übliche Federlänge' },
+      ],
+      columns: 3,
+    },
+    { type: 'paragraph', html: 'Bei der Restaurierung eines Vintage-Uhrwerks beginnt die Arbeit oft mit der Identifizierung der richtigen Zugfeder. Der <strong>Zugfeder-Rechner</strong> hilft Ihnen, die theoretischen Abmessungen der Zugfeder anhand der Federhausgeometrie zu berechnen. Durch Eingabe des Federhausinnendurchmessers, des Wellendurchmessers, der Federhaushöhe und der erwarteten Anzahl Umdrehungen ermittelt das Werkzeug Federstärke, Höhe und Länge. Die Ergebnisse werden auch als ungefähre Handelsgrößen in metrischen und imperialen Einheiten angezeigt, was den Abgleich mit Lieferantenkatalogen erleichtert.' },
+    { type: 'title', text: 'Wie Zugfederabmessungen berechnet werden', level: 3 },
+    { type: 'paragraph', html: 'Die Zugfeder nimmt den Ringraum zwischen Federhauswand und Welle ein. Die <strong>Federstärke</strong> wird geschätzt als <strong>(Federhaus-ID - Wellen-AD) / (2x Umdrehungen + 1,5)</strong>, wobei die zusätzlichen 1,5 den Federendanschluss und den Platz berücksichtigen, den die Feder gegen sich selbst einnimmt. Die <strong>Federlänge</strong> folgt <strong>L = pi x Umdrehungen x (Federhaus-ID + Wellen-AD) / 2</strong>, was die Gesamtlänge des Bandes in ausgelegtem Zustand ergibt. Die <strong>Federhöhe</strong> entspricht der inneren Federhaushöhe abzüglich eines kleinen Spiels (typischerweise 0,1 mm), um Reibung am Federhausdeckel zu vermeiden.' },
+    { type: 'title', text: 'So messen Sie ein Federhaus für die Zugfederauswahl', level: 3 },
+    {
+      type: 'glossary',
+      items: [
+        { term: 'Federhausinnendurchmesser', definition: 'Der Innendurchmesser der Federhaustrommel, gemessen mit einem Messschieber. Dies ist der größte Kreis, den die Zugfeder einnehmen kann. Typischer Bereich: 8-30 mm.' },
+        { term: 'Wellendurchmesser', definition: 'Der Durchmesser der Federhauswelle an ihrer breitesten Stelle, wo die innere Windung der Zugfeder einhakt. Kleinere Wellen ermöglichen längere Federn bei gleichem Federhaus.' },
+        { term: 'Federhaushöhe', definition: 'Die innere Höhe der Federhaustrommel. Die Zugfederhöhe muss geringfügig kleiner sein (0,05-0,15 mm), um freie Drehung ohne Reibung am Deckel zu ermöglichen.' },
+        { term: 'Anzahl Umdrehungen', definition: 'Die Anzahl vollständiger Aufzugsumdrehungen des Werks. Handaufzugskaliber bieten typischerweise 5-8 Umdrehungen, Automatikwerke 6-10 Umdrehungen.' },
+      ],
+    },
+    { type: 'title', text: 'Federkraft und was sie für Ihr Uhrwerk bedeutet', level: 3 },
+    { type: 'paragraph', html: 'Die <strong>Federstärke</strong> ist der wichtigste Faktor für das auf das Räderwerk übertragene Drehmoment. Eine dickere Feder (über 0,14 mm) liefert ein hohes Drehmoment, geeignet für Werke mit Komplikationen wie Chronographen oder Schlagwerken. Mittlere Federn (0,10-0,14 mm) sind Standard für die meisten Werke mit reiner Zeit- und Datumsanzeige. Dünne Federn (unter 0,10 mm) finden sich in kleinen Damenuhren oder ultraflachen Kalibern. Verwenden Sie immer die ursprüngliche Herstellerspezifikation, sofern verfügbar; eine zu starke Feder kann die Federhauswelle oder die Räderwerkszapfen beschädigen.' },
+    {
+      type: 'diagnostic',
+      variant: 'warning',
+      title: 'Die falsche Zugfeder kann Ihr Uhrwerk beschädigen',
+      html: 'Der Einbau einer <strong>zu dicken</strong> Feder erhöht Reibung und Drehmoment über die Auslegungsgrenzen, was möglicherweise das Federhauswellenloch ausweitet, den Zentrumsradzapfen verbiegt oder sogar das Federhaus bricht. Eine <strong>zu dünne</strong> Feder liefert nicht genug Amplitude, was dazu führt, dass die Uhr zu langsam läuft oder vor Erreichen der vollen Gangreserve stehen bleibt. Gleichen Sie die berechneten Maße vor der Bestellung immer mit bekannten Lieferantenkatalogen ab.',
+    },
+    { type: 'title', text: 'Kommerzielle Zugfedergrößensysteme', level: 3 },
+    { type: 'paragraph', html: 'Zugfederlieferanten katalogisieren Federn nach <strong>Länge x Höhe x Stärke</strong> in Millimetern. Übliche metrische Größen folgen dem General Resources oder GR-System. Zollbasierte Systeme werden noch von einigen amerikanischen und britischen Lieferanten verwendet. Das Werkzeug zeigt beide Systeme an, damit Sie unabhängig vom Lieferanten in Katalogen suchen können. Wenn die exakte berechnete Größe nicht verfügbar ist, wählen Sie die nächstgelegene Handelsgröße, die in der Höhe exakt und in der Stärke auf 0,005 mm genau übereinstimmt, und passen Sie dann die Länge durch Auswahl einer Feder aus derselben Höhen- und Stärkefamilie an.' },
+    { type: 'title', text: 'Besonderheiten bei Vintage-Kalibern', level: 3 },
+    {
+      type: 'list',
+      items: [
+        '<strong>Schweizer Kaliber (ETA, FHF, AS, Unitas)</strong> - im GR-System gut dokumentiert. Die meisten haben bekannte Zugfederreferenzen.',
+        '<strong>Französische Kaliber (LIP, France Ebauches)</strong> - verwenden oft nicht standardmäßige Federhausproportionen. Sorgfältig messen.',
+        '<strong>Amerikanische Kaliber (Waltham, Elgin, Illinois)</strong> - zollbasierte Systeme. Verwenden Sie die imperialen Angaben zum Abgleich.',
+        '<strong>Japanische Kaliber (Seiko, Citizen, Miyota)</strong> - metrisches System mit guter Katalogabdeckung für Werke ab 1960.',
+        '<strong>Chinesische Kaliber (Sea-Gull, DG, Tongji)</strong> - oft Klone von Schweizer Konstruktionen. Die Schweizer GR-Referenz gilt meist.',
+      ],
+    },
+    {
+      type: 'summary',
+      title: 'Wichtige Erkenntnisse zur Zugfederauswahl',
+      items: [
+        'Federhaus-ID, Wellen-AD und Federhaushöhe genau mit einem Präzisionsmessschieber messen',
+        'Die berechneten Maße als Ausgangspunkt verwenden, nicht als absolute Vorgabe',
+        'Mit technischen Datenblättern des Herstellers oder bekannten Lieferantenkatalogen abgleichen',
+        'Die Federhöhe genau der Federhaushöhe minus 0,05-0,15 mm Spiel anpassen',
+        'Die Stärke auf 0,005 mm des berechneten Werts genau wählen für optimale Leistung',
+        'Sicherstellen, dass die Federlänge für die erwartete Anzahl Aufzugsumdrehungen ausreicht',
+      ],
+    },
+  ],
+  faq: [
+    {
+      question: 'Wie genau sind die berechneten Zugfederabmessungen?',
+      answer: 'Die Berechnungen basieren auf standardmäßigen uhrmacherischen Formeln, die eine ideale Federhausgeometrie annehmen. Tatsächliche Maße können aufgrund von Fertigungstoleranzen, Federendkonfigurationen (Anker, Öse oder T-Ende) und der verwendeten Legierung um bis zu 5-10 % abweichen. Verwenden Sie die berechneten Werte als starken Referenzpunkt, gleichen Sie sie aber vor der Bestellung mit Datenblättern der Hersteller oder kommerziellen Lieferantenkatalogen ab.',
+    },
+    {
+      question: 'Was tun, wenn ich die exakte Handelsgröße nicht finde?',
+      answer: 'Wenn die exakte Größe nicht verfügbar ist, priorisieren Sie zuerst die genaue Federhöhe, dann die Stärke auf 0,005 mm genau. Die Länge kann durch Auswahl einer anderen Feder aus derselben Höhen- und Stärkefamilie angepasst werden. Eine etwas längere Feder funktioniert, wenn das Federhaus genügend Platz hat, aber eine kürzere Feder reduziert die Gangreserve.',
+    },
+    {
+      question: 'Wie messe ich die Federhausmaße, ohne die Zugfeder zu entfernen?',
+      answer: 'Wenn das Federhaus noch die alte Feder enthält, können Sie den Außendurchmesser des Federhauses von außen messen (dann die Wandstärke abziehen, typischerweise 0,2-0,4 mm) und die Gesamthöhe (dann die Deckelstärke abziehen). Für die genauesten Ergebnisse entfernen Sie die alte Feder und reinigen Sie das Federhaus vor dem Messen.',
+    },
+    {
+      question: 'Was ist der Unterschied zwischen einem Anker- und einem Ösen-Federende?',
+      answer: 'Ein Ankerende (auch T-Ende genannt) hat eine kleine T-förmige Lasche, die in die Federhauswand einhakt. Die meisten modernen Schweizer und japanischen Kaliber verwenden diesen Typ. Ein Ösenende hat ein kleines Loch, das über einen Stift auf der Welle passt. Dieses Werkzeug berechnet nur die Bandabmessungen; Sie müssen vor der Bestellung überprüfen, ob der Endtyp zu Ihrem Federhaus passt.',
+    },
+    {
+      question: 'Kann ich dieses Werkzeug für Chronographen- oder Automatikwerke verwenden?',
+      answer: 'Ja, aber beachten Sie, dass Automatikwerke oft eine höhere Anzahl Umdrehungen haben (8-10) und eine etwas dünnere Feder benötigen, um das zusätzliche Aufzugsmodul unterzubringen. Chronographenwerke benötigen typischerweise dickere Federn, um das Chronographenwerk anzutreiben. Passen Sie den Umdrehungswert entsprechend an und überprüfen Sie ihn mit den Herstellerspezifikationen.',
+    },
+  ],
+  bibliography,
+  howTo: [
+    {
+      name: 'Federhausinnendurchmesser messen',
+      text: 'Messen Sie mit einem Präzisionsmessschieber den Innendurchmesser der Federhaustrommel. Messen Sie an zwei um 90 Grad versetzten Stellen und mitteln Sie die Werte. Notieren Sie das Ergebnis in Millimetern.',
+    },
+    {
+      name: 'Wellendurchmesser messen',
+      text: 'Messen Sie den Durchmesser der Federhauswelle an der breitesten Stelle, an der die innere Windung der Zugfeder ansetzt. Dies ist typischerweise nahe der Wellenmitte, nicht am Vierkantende.',
+    },
+    {
+      name: 'Innere Federhaushöhe messen',
+      text: 'Messen Sie die Tiefe des Federhauses vom Boden bis zur Oberkante. Wenn der Deckel abnehmbar ist, beziehen Sie die Deckelstärke in Ihre Messung ein. Die Federhöhe wird etwa 0,1 mm geringer sein.',
+    },
+    {
+      name: 'Anzahl Umdrehungen einstellen',
+      text: 'Ermitteln Sie, wie viele volle Umdrehungen die Zugfeder bei vollständigem Aufzug macht. Bei Handaufzugskalibern sind dies typischerweise 5-8 Umdrehungen. Automatikwerke können 6-10 Umdrehungen haben. Prüfen Sie die Werksspezifikationen, falls verfügbar.',
+    },
+    {
+      name: 'Berechnete Maße ablesen',
+      text: 'Das Werkzeug zeigt die empfohlene Federstärke, Höhe und Länge an. Es schätzt auch die Federkraftkategorie und gibt Handelsäquivalente in metrischen und imperialen Einheiten an.',
+    },
+    {
+      name: 'Mit Katalogen abgleichen',
+      text: 'Verwenden Sie die angezeigten Handelsgrößen, um in Lieferantenkatalogen zu suchen. Geben Sie die metrischen oder imperialen Maße bei Cousins UK, Jules Borel oder Ihrem bevorzugten Lieferanten ein. Passen Sie die Suche an, falls die exakte Größe nicht verfügbar ist.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      'mainEntity': [
+        {
+          '@type': 'Question',
+          'name': 'Wie genau sind die berechneten Zugfederabmessungen?',
+          'acceptedAnswer': { '@type': 'Answer', 'text': 'Die Berechnungen basieren auf standardmäßigen uhrmacherischen Formeln, die eine ideale Federhausgeometrie annehmen. Tatsächliche Maße können aufgrund von Fertigungstoleranzen, Federendkonfigurationen und der verwendeten Legierung um bis zu 5-10 % abweichen. Gleichen Sie die Werte vor der Bestellung mit Datenblättern der Hersteller oder kommerziellen Katalogen ab.' },
+        },
+        {
+          '@type': 'Question',
+          'name': 'Was tun, wenn ich die exakte Handelsgröße nicht finde?',
+          'acceptedAnswer': { '@type': 'Answer', 'text': 'Zuerst die Federhöhe exakt anpassen, dann die Stärke auf 0,005 mm genau. Die Länge aus derselben Höhen-/Stärkefamilie anpassen.' },
+        },
+        {
+          '@type': 'Question',
+          'name': 'Wie messe ich das Federhaus, ohne die Zugfeder zu entfernen?',
+          'acceptedAnswer': { '@type': 'Answer', 'text': 'Den äußeren Federhausdurchmesser messen und die Wandstärke abziehen (0,2-0,4 mm). Für beste Ergebnisse zuerst die alte Feder entfernen.' },
+        },
+        {
+          '@type': 'Question',
+          'name': 'Was ist der Unterschied zwischen Anker- und Ösenenden?',
+          'acceptedAnswer': { '@type': 'Answer', 'text': 'Anker (T-Ende) hakt in die Federhauswand ein. Ösenende hat ein Loch über einem Wellenstift. Moderne Schweizer/japanische Kaliber verwenden Ankerenden.' },
+        },
+        {
+          '@type': 'Question',
+          'name': 'Kann ich dies für Chronographen- oder Automatikwerke verwenden?',
+          'acceptedAnswer': { '@type': 'Answer', 'text': 'Ja. Automatikwerke benötigen oft mehr Umdrehungen (8-10) und dünnere Federn. Chronographen benötigen dickere Federn. Umdrehungen anpassen und überprüfen.' },
+        },
+      ],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      'name': 'Zugfeder-Rechner',
+      'operatingSystem': 'Alle',
+      'applicationCategory': 'UtilitiesApplication',
+      'applicationSubCategory': 'Uhrmacher-Zugfederrechner',
+      'description': 'Berechnen Sie theoretische Zugfederabmessungen aus Federhausmessungen für Vintage-Uhrwerke.',
+      'softwareVersion': '1.0',
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'TechArticle',
+      'name': 'Berechnung von Zugfederabmessungen',
+      'proficiencyLevel': 'Intermediate',
+      'abstract': 'Erfahren Sie, wie Zugfederabmessungen aus Federhausinnendurchmesser, Wellengröße und Aufzugsumdrehungen berechnet werden.',
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      'name': 'Die richtige Zugfeder finden',
+      'description': 'Schritt-für-Schritt-Anleitung zum Messen eines Federhauses und Berechnen der korrekten Zugfederabmessungen.',
+      'step': [
+        { '@type': 'HowToStep', 'name': 'Federhaus-ID messen', 'text': 'Messen Sie mit einem Präzisionsmessschieber den Innendurchmesser der Federhaustrommel.' },
+        { '@type': 'HowToStep', 'name': 'Wellen-AD messen', 'text': 'Messen Sie den Federhauswellendurchmesser an seiner breitesten Stelle.' },
+        { '@type': 'HowToStep', 'name': 'Federhaushöhe messen', 'text': 'Messen Sie die innere Tiefe. Die Federhöhe ist etwa 0,1 mm geringer.' },
+        { '@type': 'HowToStep', 'name': 'Umdrehungen einstellen', 'text': '5-8 für Handaufzug, 6-10 für Automatikwerke einstellen.' },
+        { '@type': 'HowToStep', 'name': 'Ergebnisse ablesen', 'text': 'Federstärke, Höhe, Länge und Handelsäquivalente anzeigen.' },
+      ],
+      'totalTime': 'PT5M',
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'Product',
+      'name': 'Zugfeder-Rechner',
+      'description': 'Ein Werkzeug für Uhrmacher zur Berechnung von Zugfederabmessungen aus Federhausmessungen.',
+      'category': 'Uhrmacherwerkzeug',
+      'audience': { '@type': 'Audience', 'audienceType': 'Uhrmacher und Uhrenliebhaber' },
+    },
+  ],
+};