@jjlmoya/utils-diy 1.13.0 → 1.15.0

package/package.json

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

package/src/entries.ts

@@ -15,6 +15,7 @@ export { stairCalculator } from './tool/stairCalculator/entry';
 export { thermalExpansionCalculator } from './tool/thermalExpansionCalculator/entry';
 export { voltageDropCalculator } from './tool/voltageDropCalculator/entry';
 export { workshopFractionConverter } from './tool/workshopFractionConverter/entry';
+export { pythagoreanRightAngleCalculator } from './tool/pythagoreanRightAngleCalculator/entry';
 export { diyCategory } from './category';
 import { balusterCalculator } from './tool/balusterCalculator/entry';
 import { clayCalculator } from './tool/clayCalculator/entry';
@@ -30,4 +31,5 @@ import { stairCalculator } from './tool/stairCalculator/entry';
 import { thermalExpansionCalculator } from './tool/thermalExpansionCalculator/entry';
 import { voltageDropCalculator } from './tool/voltageDropCalculator/entry';
 import { workshopFractionConverter } from './tool/workshopFractionConverter/entry';
-export const ALL_ENTRIES = [balusterCalculator, clayCalculator, concreteCalculator, cutOptimizer, drillCalculator, drillSharpener, epoxyCalculator, furnitureFit, mortarCalculator, passepartoutCalculator, stairCalculator, thermalExpansionCalculator, voltageDropCalculator, workshopFractionConverter];
+import { pythagoreanRightAngleCalculator } from './tool/pythagoreanRightAngleCalculator/entry';
+export const ALL_ENTRIES = [balusterCalculator, clayCalculator, concreteCalculator, cutOptimizer, drillCalculator, drillSharpener, epoxyCalculator, furnitureFit, mortarCalculator, passepartoutCalculator, stairCalculator, thermalExpansionCalculator, voltageDropCalculator, workshopFractionConverter, pythagoreanRightAngleCalculator];

package/src/index.ts

@@ -44,3 +44,5 @@ export { STAIR_CALCULATOR_TOOL } from './tool/stairCalculator/index';
 export { DRILL_SHARPENER_TOOL } from './tool/drillSharpener/index';
 
 export { WORKSHOP_FRACTION_CONVERTER_TOOL } from './tool/workshopFractionConverter/index';
+
+export { PYTHAGOREAN_RIGHT_ANGLE_CALCULATOR_TOOL } from './tool/pythagoreanRightAngleCalculator/index';

package/src/tests/locale_completeness.test.ts

@@ -33,8 +33,8 @@ describe('Locale Completeness Validation', () => {
     });
   });
 
-  it('all 14 tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(14);
+  it('all 15 tools registered', () => {
+    expect(ALL_TOOLS.length).toBe(15);
   });
 });
 

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { diyCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 14 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(14);
+    it('should have 15 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(15);
     });
 
     it('diyCategory should be defined', () => {

package/src/tool/pythagoreanRightAngleCalculator/bibliography.astro

@@ -0,0 +1,6 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { bibliography } from './bibliography';
+---
+
+<SharedBibliography links={bibliography} />

package/src/tool/pythagoreanRightAngleCalculator/bibliography.ts

@@ -0,0 +1,12 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Pythagorean Theorem',
+    url: 'https://mathworld.wolfram.com/PythagoreanTheorem.html',
+  },
+  {
+    name: '3-4-5 Rule in Construction',
+    url: 'https://en.wikipedia.org/wiki/Pythagorean_triple',
+  }
+];

package/src/tool/pythagoreanRightAngleCalculator/component.astro

@@ -0,0 +1,243 @@
+---
+import { Icon } from 'astro-icon/components';
+import type { PythagoreanRightAngleCalculatorUI } from './ui';
+
+interface Props { ui?: PythagoreanRightAngleCalculatorUI; }
+const { ui } = Astro.props;
+const t = (ui ?? {}) as PythagoreanRightAngleCalculatorUI;
+---
+
+<div class="prac-root" data-prac-root data-ui={JSON.stringify(t)}>
+  <div class="prac-container">
+    <aside class="prac-inputs">
+      <div class="prac-input-group">
+        <label>{t.labelUnitSelection || 'Units'}</label>
+        <div class="prac-unit-selector">
+          <button class="prac-unit-btn active" data-unit="in">{t.btnUnitInches}</button>
+          <button class="prac-unit-btn" data-unit="ft">{t.btnUnitFeet}</button>
+          <button class="prac-unit-btn" data-unit="cm">{t.btnUnitCentimeters}</button>
+        </div>
+      </div>
+
+      <div class="prac-input-group">
+        <label for="prac-a">{t.labelSideA}</label>
+        <input type="number" id="prac-a" inputmode="decimal" placeholder="0" step="0.1">
+      </div>
+
+      <div class="prac-input-group">
+        <label for="prac-b">{t.labelSideB}</label>
+        <input type="number" id="prac-b" inputmode="decimal" placeholder="0" step="0.1">
+      </div>
+
+      <div class="prac-input-group">
+        <label for="prac-d">{t.labelMeasuredDiagonal}</label>
+        <input type="number" id="prac-d" inputmode="decimal" placeholder="0" step="0.1">
+      </div>
+
+      <div class="prac-button-group">
+        <button id="prac-clear" class="prac-btn prac-btn-icon" title={t.btnClear}>
+          <Icon name="mdi:delete" />
+        </button>
+        <button id="prac-copy" class="prac-btn prac-btn-icon" title={t.btnCopyResults}>
+          <Icon name="mdi:content-copy" />
+        </button>
+      </div>
+
+      <div class="prac-presets">
+        <button class="prac-preset" data-preset="0">3-4-5</button>
+        <button class="prac-preset" data-preset="1">6-8-10</button>
+        <button class="prac-preset" data-preset="2">30-40-50</button>
+        <button class="prac-preset" data-preset="3">15-20-25</button>
+      </div>
+    </aside>
+
+    <main class="prac-display">
+      <div id="prac-status" class="prac-status idle">
+        <div class="prac-status-indicator"></div>
+        <div class="prac-status-content">
+          <span class="prac-status-title" id="prac-status-title">Ready</span>
+          <span class="prac-status-value" id="prac-status-value">--</span>
+        </div>
+      </div>
+
+      <div class="prac-results-grid">
+        <div class="prac-result-box">
+          <span class="prac-result-label">{t.labelIdealDiagonal}</span>
+          <span class="prac-result-value" id="prac-ideal">--</span>
+          <span id="prac-unit" class="prac-result-unit">in</span>
+        </div>
+        <div class="prac-result-box">
+          <span class="prac-result-label">{t.labelDeviation}</span>
+          <span class="prac-result-value" id="prac-dev">--</span>
+          <span id="prac-unit-dev" class="prac-result-unit">in</span>
+        </div>
+      </div>
+
+      <svg id="prac-svg" viewBox="0 0 280 220" preserveAspectRatio="xMidYMid meet" class="prac-svg">
+        <path id="prac-tri" d="" fill="rgba(99, 102, 241, 0.08)" stroke="#6366f1" stroke-width="2"></path>
+        <text id="prac-lbl-a" x="0" y="0" class="prac-label">A</text>
+        <text id="prac-lbl-b" x="0" y="0" class="prac-label">B</text>
+        <text id="prac-lbl-c" x="0" y="0" class="prac-label prac-label-hyp">C</text>
+        <path id="prac-corner" d="" fill="none" stroke="#6366f1" stroke-width="1"></path>
+      </svg>
+
+      <div id="prac-message" class="prac-message"></div>
+    </main>
+  </div>
+</div>
+
+<style>
+  @import './pythagorean-right-angle-calculator.css';
+</style>
+
+<script>
+  import { calculateSquaring, PRESET_RULES } from './logic';
+  import type { SquaringCalculation } from './logic';
+
+  const root = document.querySelector('.prac-root') as HTMLElement | null;
+  const ui = root ? JSON.parse((root as HTMLElement).dataset.ui || '{}') : {};
+
+  const inputA = document.getElementById('prac-a') as HTMLInputElement;
+  const inputB = document.getElementById('prac-b') as HTMLInputElement;
+  const inputD = document.getElementById('prac-d') as HTMLInputElement;
+  const unitBtns = document.querySelectorAll('.prac-unit-btn');
+  const presetBtns = document.querySelectorAll('.prac-preset');
+  const clearBtn = document.getElementById('prac-clear') as HTMLButtonElement;
+  const copyBtn = document.getElementById('prac-copy') as HTMLButtonElement;
+
+  const statusEl = document.getElementById('prac-status') as HTMLElement;
+  const statusTitle = document.getElementById('prac-status-title') as HTMLElement;
+  const statusValue = document.getElementById('prac-status-value') as HTMLElement;
+  const resultIdeal = document.getElementById('prac-ideal') as HTMLElement;
+  const resultDev = document.getElementById('prac-dev') as HTMLElement;
+  const unitDisplay = document.getElementById('prac-unit') as HTMLElement;
+  const unitDevDisplay = document.getElementById('prac-unit-dev') as HTMLElement;
+  const msgEl = document.getElementById('prac-message') as HTMLElement;
+
+  const triPath = document.getElementById('prac-tri')!;
+  const lblA = document.getElementById('prac-lbl-a')!;
+  const lblB = document.getElementById('prac-lbl-b')!;
+  const lblC = document.getElementById('prac-lbl-c')!;
+  const corner = document.getElementById('prac-corner')!;
+
+  let currentUnit = 'in';
+
+  function setUnit(unit: string) {
+    currentUnit = unit;
+    unitDisplay.textContent = unit;
+    unitDevDisplay.textContent = unit;
+    unitBtns.forEach(btn => (btn as HTMLElement).classList.toggle('active', (btn as HTMLElement).getAttribute('data-unit') === unit));
+    calculate();
+  }
+
+  function updateStatus(calc: SquaringCalculation) {
+    statusEl.className = `prac-status ${calc.status}`;
+    statusTitle.textContent = calc.message || ui.statusReady || 'Ready';
+
+    if (calc.deviationPercent !== null) {
+      statusValue.textContent = `${calc.deviationPercent.toFixed(2)}%`;
+    } else {
+      statusValue.textContent = '--';
+    }
+
+    msgEl.textContent = calc.correction;
+  }
+
+  function drawTriangle(a: number, b: number) {
+    if (a <= 0 || b <= 0) {
+      triPath.setAttribute('d', '');
+      lblA.textContent = '';
+      lblB.textContent = '';
+      lblC.textContent = '';
+      corner.setAttribute('d', '');
+      return;
+    }
+
+    const scale = Math.min(180 / Math.max(a, b), 150 / Math.max(a, b));
+    const x1 = 20;
+    const y1 = 20 + a * scale;
+    const x2 = 20 + b * scale;
+    const y2 = 20 + a * scale;
+    const x3 = 20;
+    const y3 = 20;
+
+    triPath.setAttribute('d', `M ${x1} ${y1} L ${x2} ${y2} L ${x3} ${y3} Z`);
+
+    lblA.setAttribute('x', `${x1 - 15}`);
+    lblA.setAttribute('y', `${(y1 + y3) / 2}`);
+    lblA.textContent = `${a.toFixed(1)}`;
+
+    lblB.setAttribute('x', `${(x1 + x2) / 2}`);
+    lblB.setAttribute('y', `${y1 + 18}`);
+    lblB.textContent = `${b.toFixed(1)}`;
+
+    const c = Math.sqrt(a * a + b * b);
+    lblC.setAttribute('x', `${(x2 + x3) / 2 + 8}`);
+    lblC.setAttribute('y', `${(y2 + y3) / 2 - 8}`);
+    lblC.textContent = `${c.toFixed(1)}`;
+
+    const cornerSize = 10;
+    corner.setAttribute('d', `M ${x1 - cornerSize} ${y1 - cornerSize} L ${x1 - cornerSize} ${y1} L ${x1} ${y1}`);
+  }
+
+  function calculate() {
+    const a = parseFloat(inputA.value) || 0;
+    const b = parseFloat(inputB.value) || 0;
+    const d = parseFloat(inputD.value) || null;
+    const calc = calculateSquaring(a, b, d, { unit: currentUnit, ui });
+
+    if (calc.hypotenuse > 0) {
+      resultIdeal.textContent = calc.hypotenuse.toFixed(2);
+      resultDev.textContent = calc.deviation !== null ? Math.abs(calc.deviation).toFixed(2) : '--';
+    } else {
+      resultIdeal.textContent = '--';
+      resultDev.textContent = '--';
+    }
+
+    updateStatus(calc);
+    drawTriangle(a, b);
+  }
+
+  function applyPreset(idx: number) {
+    const p = PRESET_RULES[idx];
+    if (p) {
+      inputA.value = p.a.toString();
+      inputB.value = p.b.toString();
+      inputD.value = '';
+      calculate();
+    }
+  }
+
+  unitBtns.forEach(btn => {
+    btn.addEventListener('click', () => setUnit((btn as HTMLElement).getAttribute('data-unit') || 'in'));
+  });
+
+  [inputA, inputB, inputD].forEach(inp => {
+    inp.addEventListener('input', calculate);
+  });
+
+  presetBtns.forEach((btn, idx) => {
+    btn.addEventListener('click', () => applyPreset(idx));
+  });
+
+  clearBtn.addEventListener('click', () => {
+    inputA.value = '';
+    inputB.value = '';
+    inputD.value = '';
+    calculate();
+  });
+
+  copyBtn.addEventListener('click', () => {
+    let unitText = ui.unitInches;
+    if (currentUnit === 'ft') unitText = ui.unitFeet;
+    else if (currentUnit === 'cm') unitText = ui.unitCentimeters;
+    const text = `${ui.labelIdealDiagonal || 'Ideal'}: ${resultIdeal.textContent}${unitText}, ${ui.labelDeviation || 'Deviation'}: ${resultDev.textContent}${unitText}`;
+    navigator.clipboard.writeText(text).then(() => {
+      const originalHTML = copyBtn.innerHTML;
+      copyBtn.innerHTML = '<svg viewBox="0 0 24 24" width="20" height="20" fill="currentColor"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"/></svg>';
+      setTimeout(() => (copyBtn.innerHTML = originalHTML), 1500);
+    });
+  });
+
+  calculate();
+</script>

package/src/tool/pythagoreanRightAngleCalculator/entry.ts

@@ -0,0 +1,24 @@
+import type { DiyToolEntry } from '../../types';
+import type { PythagoreanRightAngleCalculatorUI } from './ui';
+
+export const pythagoreanRightAngleCalculator: DiyToolEntry<PythagoreanRightAngleCalculatorUI> = {
+  id: 'pythagorean-right-angle-calculator-3-4-5-rule',
+  icons: { bg: 'mdi:square-outline', fg: 'mdi:ruler-square' },
+  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/pythagoreanRightAngleCalculator/i18n/de.ts

@@ -0,0 +1,129 @@
+import type { WithContext, FAQPage, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { PythagoreanRightAngleCalculatorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'satz-des-pythagoras-rechter-winkel-rechner-3-4-5-regel';
+const title = 'Pythagoras Rechter Winkel Rechner: 3 4 5 Regel für perfekte Winkel';
+const description = 'Prüfen Sie mit dem Satz des Pythagoras und der 3-4-5-Regel, ob Strukturen perfekt im 90°-Winkel stehen. Unverzichtbares Tool für Bau, Zimmerei und DIY-Projekte.';
+
+const faqData = [
+  {
+    question: 'Was ist die 3-4-5-Regel?',
+    answer: 'Die 3-4-5-Regel ist ein einfaches pythagoreisches Tripel. Wenn ein rechtwinkliges Dreieck Seiten von 3, 4 und 5 Einheiten in beliebigem Maßstab hat, beträgt der Winkel zwischen den kürzeren Seiten genau 90 Grad. Diese praxiserprobte Methode wird seit Jahrhunderten im Bauwesen angewendet.',
+  },
+  {
+    question: 'Wie benutze ich diesen Rechner?',
+    answer: 'Geben Sie die Längen der beiden Wände (Seiten A und B) ein, die die Ecke bilden. Der Rechner zeigt an, wie groß die Diagonale für einen perfekten 90-Grad-Winkel sein muss. Messen Sie dann Ihre tatsächliche Diagonale und geben Sie diese ein, um zu prüfen, ob Ihre Ecke wirklich rechtwinklig ist.',
+  },
+  {
+    question: 'Was ist, wenn meine Diagonale abweicht?',
+    answer: 'Wenn Ihre gemessene Diagonale vom Idealwert abweicht, zeigt der Rechner die Abweichung an. Grün bedeutet perfekt, Gelb akzeptabel, Rot nicht rechtwinklig. Er gibt Ihnen auch an, ob Sie den Winkel öffnen oder schließen müssen.',
+  },
+  {
+    question: 'Ist dies genau genug für den Bau?',
+    answer: 'Ja. Der Satz des Pythagoras ist mathematisch exakt. Mit einem Maßband können Sie Bau-Präzision ohne Spezialwerkzeug oder Fachkenntnisse erreichen.',
+  },
+  {
+    question: 'Kann ich zwischen Zoll und Fuß wechseln?',
+    answer: 'Ja. Wählen Sie Zoll für kleine Projekte oder Fuß für größere Strukturen. Alle Werte werden sofort umgerechnet, ohne dass Daten verloren gehen.',
+  },
+];
+
+const howToData = [
+  { name: 'Einheit wählen', text: 'Wählen Sie Zoll für Detailarbeiten oder Fuß für größere Strukturen. Sie können jederzeit wechseln.' },
+  { name: 'Beide Seiten messen', text: 'Messen Sie die Länge der beiden Wände (Seiten A und B), die die zu prüfende Ecke bilden.' },
+  { name: 'Ideale Diagonale prüfen', text: 'Der Rechner zeigt Ihnen, wie groß die Diagonale für einen perfekten 90-Grad-Winkel sein muss.' },
+  { name: 'Diagonale messen', text: 'Messen Sie Ihre tatsächliche Diagonale mit einem Maßband. Geben Sie den Wert im optionalen Feld ein.' },
+  { name: 'Status ablesen', text: 'Grün = perfekt rechtwinklig. Gelb = akzeptabel. Rot = nicht rechtwinklig. Passen Sie wie vorgeschlagen an.' },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<any> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<PythagoreanRightAngleCalculatorUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Häufig gestellte Fragen',
+  faq: faqData,
+  bibliography,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'Der Satz des Pythagoras in der Praxis', level: 2 },
+    { type: 'paragraph', html: 'Ein perfekter 90-Grad-Winkel ist die Grundlage für Qualitätsbau. Wände müssen senkrecht stehen, Fundamente müssen rechtwinklig sein und Rahmen müssen fluchten. Der Satz des Pythagoras bietet eine mathematisch garantierte Methode: a² + b² = c².' },
+    { type: 'title', text: 'Warum die 3-4-5-Regel funktioniert', level: 3 },
+    { type: 'paragraph', html: 'Die 3-4-5-Regel ist das einfachste pythagoreische Tripel. Egal, ob Sie in Zoll, Fuß oder einer anderen Einheit messen: Seiten von 3, 4 und 5 Einheiten garantieren einen 90-Grad-Winkel. Dies ist mathematisch bewiesen und seit Jahrhunderten im Bauwesen erprobt.' },
+    { type: 'title', text: 'Präzision ohne Spezialwerkzeug', level: 3 },
+    { type: 'paragraph', html: 'Im Gegensatz zu Wasserwaagen oder Winkeln, die brechen oder sich verstellen können, ist der Satz des Pythagoras unveränderlich. Mit nur einem Maßband können Sie jede Ecke in jedem Maßstab prüfen. Dieser Rechner macht Kopfrechnen überflüssig und sorgt für Genauigkeit.' },
+    { type: 'title', text: 'Von der Theorie zur praktischen Anleitung', level: 3 },
+    { type: 'paragraph', html: 'Dieser Rechner wandelt abstrakte Mathematik in praktische Anweisungen für die Baustelle um. Wenn Ihre Diagonale nicht stimmt, sagt er Ihnen genau, um wie viel und in welche Richtung Sie korrigieren müssen. Machen Sie Theorie zu echten Ergebnissen vor Ort.' },
+  ],
+  ui: {
+    titleMain: 'Winkel-Rechner (Pythagoras)',
+    labelInputData: 'Messungen',
+    labelUnitSelection: 'Einheit',
+    btnUnitInches: 'Zoll',
+    btnUnitFeet: 'Fuß',
+    btnUnitCentimeters: 'Zentimeter',
+    labelSideA: 'Seite A',
+    labelSideB: 'Seite B',
+    labelMeasuredDiagonal: 'Gemessene Diagonale (optional)',
+    labelResults: 'Ergebnisse',
+    labelIdealDiagonal: 'Ideale Diagonale',
+    labelDeviation: 'Abweichung',
+    labelStatus: 'Status',
+    labelVerification: 'Winkel-Prüfung',
+    btnClear: 'Löschen',
+    btnCopyResults: 'Ergebnisse kopieren',
+    labelPresets: 'Schnellwahl',
+    unitInches: 'in',
+    unitFeet: 'ft',
+    unitCentimeters: 'cm',
+    tooltipOptional: 'Geben Sie Ihre gemessene Diagonale ein, um den 90-Grad-Winkel zu prüfen',
+    tooltipPresets: '3-4-5-Regel in verschiedenen Maßstäben',
+    statusPerfect: 'Perfekter 90-Grad-Winkel',
+    statusAcceptable: 'Akzeptable Abweichung',
+    statusWarning: 'Geringe Abweichung',
+    statusError: 'Nicht rechtwinklig',
+    statusReady: 'Bereit',
+    msgIdealCalculated: 'Ideale Diagonale berechnet',
+    actionOpen: 'Öffnen',
+    actionClose: 'Schließen',
+    descLarger: 'größer',
+    descSmaller: 'kleiner',
+    descCorrection: 'Korrektur erforderlich',
+  },
+};

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

@@ -0,0 +1,129 @@
+import type { WithContext, FAQPage, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { PythagoreanRightAngleCalculatorUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'pythagorean-right-angle-calculator-3-4-5-rule';
+const title = 'Pythagorean Right Angle Calculator: 3 4 5 Rule for Perfect Squares';
+const description = 'Verify if structures are perfectly squared at 90° using the Pythagorean theorem and 3-4-5 rule. Essential tool for construction, carpentry, and DIY projects.';
+
+const faqData = [
+  {
+    question: 'What is the 3-4-5 rule?',
+    answer: 'The 3-4-5 rule is a simple Pythagorean triple. If a right triangle has sides of 3, 4, and 5 units in any scale, the angle between the shorter sides is exactly 90 degrees. This field-tested method has been used in construction for centuries.',
+  },
+  {
+    question: 'How do I use this calculator?',
+    answer: 'Enter the lengths of the two walls (sides A and B) that form the corner. The calculator shows what the diagonal should be for a perfect 90-degree angle. Then measure your actual diagonal and enter it to verify if your corner is truly square.',
+  },
+  {
+    question: 'What if my diagonal is different?',
+    answer: 'If your measured diagonal differs from the ideal, the calculator shows the deviation. Green means perfect, yellow means acceptable, red means out of square. It also tells you whether to open or close the angle.',
+  },
+  {
+    question: 'Is this accurate enough for construction?',
+    answer: 'Yes. The Pythagorean theorem is mathematically exact. With a tape measure, you can achieve construction-grade accuracy without specialized tools or skill.',
+  },
+  {
+    question: 'Can I switch between inches and feet?',
+    answer: 'Yes. Choose inches for small projects or feet for larger structures. All values convert instantly without losing data.',
+  },
+];
+
+const howToData = [
+  { name: 'Select your unit', text: 'Choose inches for detailed work or feet for larger structures. You can switch anytime without losing data.' },
+  { name: 'Measure both sides', text: 'Measure the length of the two walls (sides A and B) that form the corner you want to check.' },
+  { name: 'Check the ideal diagonal', text: 'The calculator shows you what the diagonal must be for a perfect 90-degree angle.' },
+  { name: 'Measure your diagonal', text: 'Use a tape measure to measure your actual diagonal. Enter it in the optional field.' },
+  { name: 'Read the status', text: 'Green = perfect square. Yellow = acceptable. Red = out of square. Adjust as suggested.' },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<any> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'en',
+};
+
+export const content: ToolLocaleContent<PythagoreanRightAngleCalculatorUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Frequently Asked Questions',
+  faq: faqData,
+  bibliography,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'The Pythagorean Theorem in Practice', level: 2 },
+    { type: 'paragraph', html: 'A perfect 90-degree angle is fundamental to quality construction. Walls must be perpendicular, foundations must be square, and frames must be true. The Pythagorean theorem provides a mathematically guaranteed method: a² + b² = c².' },
+    { type: 'title', text: 'Why the 3-4-5 Rule Works', level: 3 },
+    { type: 'paragraph', html: 'The 3-4-5 rule is the simplest Pythagorean triple. Whether you measure in inches, feet, or any other unit, sides of 3, 4, and 5 units guarantee a 90-degree angle. This has been proven mathematically and tested in construction for centuries.' },
+    { type: 'title', text: 'Precision Without Specialized Tools', level: 3 },
+    { type: 'paragraph', html: 'Unlike levels or squares that can break or fall out of adjustment, the Pythagorean theorem is immutable. With only a tape measure, you can verify any corner at any scale. This calculator eliminates mental math and ensures accuracy.' },
+    { type: 'title', text: 'From Theory to Actionable Guidance', level: 3 },
+    { type: 'paragraph', html: 'This calculator converts abstract mathematics into practical field instructions. If your diagonal is off, it tells you exactly how much and which direction to adjust. Transform theory into on-site results.' },
+  ],
+  ui: {
+    titleMain: 'Pythagorean Right Angle Calculator',
+    labelInputData: 'Measurements',
+    labelUnitSelection: 'Unit',
+    btnUnitInches: 'inches',
+    btnUnitFeet: 'feet',
+    btnUnitCentimeters: 'centimeters',
+    labelSideA: 'Side A',
+    labelSideB: 'Side B',
+    labelMeasuredDiagonal: 'Measured diagonal (optional)',
+    labelResults: 'Results',
+    labelIdealDiagonal: 'Ideal diagonal',
+    labelDeviation: 'Deviation',
+    labelStatus: 'Status',
+    labelVerification: 'Square verification',
+    btnClear: 'Clear',
+    btnCopyResults: 'Copy results',
+    labelPresets: 'Quick presets',
+    unitInches: 'in',
+    unitFeet: 'ft',
+    unitCentimeters: 'cm',
+    tooltipOptional: 'Enter your measured diagonal to verify perfect 90 degrees',
+    tooltipPresets: '3-4-5 rule in different scales',
+    statusPerfect: 'Perfect 90 degree angle',
+    statusAcceptable: 'Acceptable deviation',
+    statusWarning: 'Minor deviation',
+    statusError: 'Out of square',
+    statusReady: 'Ready',
+    msgIdealCalculated: 'Diagonal ideal calculated',
+    actionOpen: 'Open',
+    actionClose: 'Close',
+    descLarger: 'larger',
+    descSmaller: 'smaller',
+    descCorrection: 'Correction needed',
+  },
+};