@jjlmoya/utils-aquarium 1.69.0 → 1.70.0

package/src/tool/aquariumNitrateDilutionCalculator/bibliography.astro

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

package/src/tool/aquariumNitrateDilutionCalculator/bibliography.ts

@@ -0,0 +1,12 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Bridges Lab Protocols, Dilution Formula',
+    url: 'https://bridgeslab.sph.umich.edu/protocols/index.php/Dilution_Formula',
+  },
+  {
+    name: 'sera Ratgeber Aquariumpflege, Wasserwechsel',
+    url: 'https://www.sera.de/fileadmin/epapers/PDF/11102_RG_Aquariumpflege_D.pdf',
+  },
+];

package/src/tool/aquariumNitrateDilutionCalculator/component.astro

@@ -0,0 +1,120 @@
+---
+import type { AquariumNitrateDilutionCalculatorUI } from './ui';
+
+interface Props { ui?: Record<string, unknown>; }
+
+const { ui = {} } = Astro.props;
+const t = ui as AquariumNitrateDilutionCalculatorUI;
+---
+
+<div id="aquarium-nitrate-dilution-calculator" class="and-tool">
+  <script is:inline id="aquarium-nitrate-dilution-calculator-ui" type="application/json" set:html={JSON.stringify(t)}></script>
+  <div class="and-surface">
+    <header class="and-topline">
+      <div class="and-identity">
+        <span class="and-no3-mark" aria-hidden="true">NO3</span>
+        <div>
+          <p class="and-kicker">{t.toolKicker}</p>
+          <p class="and-intro">{t.inputInstruction}</p>
+        </div>
+      </div>
+      <fieldset class="and-unit-switch">
+        <legend>{t.unitSystemLabel}</legend>
+        <div class="and-unit-options" role="group" aria-label={t.unitSystemLabel}>
+          <button type="button" data-unit-choice="metric" aria-pressed="true"><strong>{t.metricLabel}</strong><small>{t.metricUnitSummary}</small></button>
+          <button type="button" data-unit-choice="imperial" aria-pressed="false"><strong>{t.imperialLabel}</strong><small>{t.imperialUnitSummary}</small></button>
+        </div>
+      </fieldset>
+    </header>
+
+    <div class="and-workspace">
+      <section class="and-readings" aria-labelledby="and-readings-title">
+        <div class="and-section-heading">
+          <span class="and-section-index">01</span>
+          <div><p class="and-kicker">{t.readingsTitle}</p><p id="and-readings-title" class="and-section-note">{t.inputsLegend}</p></div>
+        </div>
+        <div class="and-reading-list">
+          <label class="and-reading-row">
+            <span class="and-reading-index">A</span>
+            <span class="and-reading-copy"><strong>{t.volumeLabel}</strong><small>{t.volumeHint}</small></span>
+            <input data-input="volumeLitres" type="number" min="1" max="100000" step="1" inputmode="decimal" />
+            <em data-unit-label="volume">{t.volumeUnit}</em>
+          </label>
+          <label class="and-reading-row">
+            <span class="and-reading-index">B</span>
+            <span class="and-reading-copy"><strong>{t.currentLabel}</strong><small>{t.readingHint}</small></span>
+            <input data-input="currentNitrate" type="number" min="0" max="1000" step="0.1" inputmode="decimal" />
+            <em data-unit-label="nitrate">{t.nitrateUnit}</em>
+          </label>
+          <label class="and-reading-row">
+            <span class="and-reading-index">C</span>
+            <span class="and-reading-copy"><strong>{t.targetLabel}</strong><small>{t.readingHint}</small></span>
+            <input data-input="targetNitrate" type="number" min="0" max="1000" step="0.1" inputmode="decimal" />
+            <em data-unit-label="nitrate">{t.nitrateUnit}</em>
+          </label>
+          <label class="and-reading-row">
+            <span class="and-reading-index">D</span>
+            <span class="and-reading-copy"><strong>{t.sourceLabel}</strong><small>{t.sourceHint}</small></span>
+            <input data-input="sourceNitrate" type="number" min="0" max="1000" step="0.1" inputmode="decimal" />
+            <em data-unit-label="nitrate">{t.nitrateUnit}</em>
+          </label>
+        </div>
+        <button type="button" class="and-reset" data-action="reset">{t.resetLabel}</button>
+      </section>
+
+      <section class="and-decision" aria-live="polite" aria-labelledby="and-decision-title">
+        <div class="and-decision-heading">
+          <div><span class="and-section-index">02</span><p id="and-decision-title" class="and-kicker">{t.decisionTitle}</p></div>
+          <span class="and-status" data-result="status">{t.inputsLegend}</span>
+        </div>
+        <div class="and-answer-block">
+          <span class="and-answer-label">{t.actionLabel}</span>
+          <strong class="and-answer-number" data-result="required">-</strong>
+          <span class="and-answer-unit">{t.requiredChangeLabel}</span>
+        </div>
+        <aside class="and-safety-note" data-safety-note hidden role="note">
+          <strong data-result="safety-label"></strong>
+          <span data-result="safety-copy"></span>
+        </aside>
+        <div class="and-flow-scene" aria-hidden="true">
+          <div class="and-vessel">
+            <span class="and-vessel-lid"></span>
+            <div class="and-vessel-body"><div class="and-water-fill"></div><span class="and-marker and-marker-current"><i></i>{t.currentMarker}</span><span class="and-marker and-marker-target"><i></i>{t.targetMarker}</span></div>
+            <span class="and-vessel-foot"></span>
+          </div>
+          <div class="and-flow-arrow"><span>{t.sceneCaption}</span><i></i></div>
+          <div class="and-new-water"><span class="and-new-water-cap"></span><div class="and-new-water-body"><div class="and-new-water-fill"></div></div><small>{t.newWaterLabel}</small></div>
+        </div>
+        <p class="and-answer-copy" data-result="answer">{t.sourceHint}</p>
+        <div class="and-metrics">
+          <div><span>{t.requiredLitresLabel}</span><strong data-result="required-litres">-</strong></div>
+          <div><span>{t.afterChangeLabel}</span><strong data-result="after">-</strong></div>
+          <div><span data-result="scenario">{t.scenarioLabel}</span><strong data-result="repeat">-</strong></div>
+        </div>
+      </section>
+    </div>
+
+    <section class="and-scenarios" aria-labelledby="and-scenarios-title">
+      <div class="and-scenario-heading"><div><span class="and-section-index">03</span><p id="and-scenarios-title" class="and-kicker">{t.scenarioLabel}</p></div><small>{t.scenarioHint}</small></div>
+      <div class="and-scenario-choices" role="group" aria-label={t.scenarioLabel}>
+        <button type="button" data-scenario-choice="25" aria-pressed="true"><i></i>{t.scenarioTwentyFive}</button>
+        <button type="button" data-scenario-choice="40" aria-pressed="false"><i></i>{t.scenarioForty}</button>
+        <button type="button" data-scenario-choice="50" aria-pressed="false"><i></i>{t.scenarioFifty}</button>
+        <button type="button" data-scenario-choice="75" aria-pressed="false"><i></i>{t.scenarioSeventyFive}</button>
+      </div>
+      <ol class="and-scenario-list" data-scenario-list></ol>
+      <details class="and-plan">
+        <summary>{t.planLabel}</summary>
+        <p>{t.planHint}</p>
+        <ol class="and-plan-list" data-plan-list></ol>
+      </details>
+      <p class="and-biology-note">{t.biologyHint}</p>
+    </section>
+    <p class="and-error" data-error role="alert"></p>
+  </div>
+</div>
+
+<script>
+  import { initAquariumNitrateDilutionCalculator } from './controller';
+  initAquariumNitrateDilutionCalculator();
+</script>

package/src/tool/aquariumNitrateDilutionCalculator/controller.ts

@@ -0,0 +1,96 @@
+import { calculateNitrateDilution } from './logic';
+import { defaultNitrateState, loadNitrateState, saveNitrateState, type SavedNitrateState } from './storage';
+import { renderNitrateResults } from './dom-views';
+import type { AquariumNitrateDilutionCalculatorUI } from './ui';
+import { volumeFromDisplay, volumeToDisplay, type UnitSystem } from './units';
+
+interface ControllerContext {
+  root: HTMLElement;
+  ui: AquariumNitrateDilutionCalculatorUI;
+  state: SavedNitrateState;
+}
+
+const INPUT_FIELDS = ['volumeLitres', 'currentNitrate', 'targetNitrate', 'sourceNitrate'] as const;
+
+function getInput(root: HTMLElement, field: string): HTMLInputElement | null {
+  return root.querySelector<HTMLInputElement>(`[data-input="${field}"]`);
+}
+
+function writeState(context: ControllerContext): void {
+  const volumeInput = getInput(context.root, 'volumeLitres');
+  if (volumeInput !== null) volumeInput.value = String(Number(volumeToDisplay(context.state.input.volumeLitres, context.state.unitSystem).toFixed(2)));
+  INPUT_FIELDS.filter((field) => field !== 'volumeLitres').forEach((field) => {
+    const input = getInput(context.root, field);
+    if (input !== null) input.value = String(context.state.input[field]);
+  });
+  context.root.querySelectorAll<HTMLElement>('[data-scenario-choice]').forEach((button) => {
+    const active = Number(button.dataset.scenarioChoice) === context.state.scenarioPercent;
+    button.classList.toggle('is-active', active);
+    button.setAttribute('aria-pressed', String(active));
+  });
+  context.root.querySelectorAll<HTMLElement>('[data-unit-choice]').forEach((button) => {
+    const active = button.dataset.unitChoice === context.state.unitSystem;
+    button.setAttribute('aria-pressed', String(active));
+  });
+}
+
+function readState(context: ControllerContext): void {
+  INPUT_FIELDS.forEach((field) => {
+    const input = getInput(context.root, field);
+    const value = input === null ? Number.NaN : Number.parseFloat(input.value);
+    context.state.input[field] = field === 'volumeLitres' ? volumeFromDisplay(value, context.state.unitSystem) : value;
+  });
+}
+
+function render(context: ControllerContext, readInputs = true): void {
+  if (readInputs) readState(context);
+  saveNitrateState(context.state);
+  renderNitrateResults({ root: context.root, ui: context.ui, locale: 'en-US', scenarioPercent: context.state.scenarioPercent, unitSystem: context.state.unitSystem }, calculateNitrateDilution(context.state.input));
+}
+
+function reset(context: ControllerContext): void {
+  context.state = defaultNitrateState();
+  writeState(context);
+  render(context, false);
+}
+
+function bindInputs(context: ControllerContext): void {
+  context.root.querySelectorAll<HTMLInputElement>('[data-input]').forEach((input) => input.addEventListener('input', () => render(context)));
+}
+
+function bindScenarios(context: ControllerContext): void {
+  context.root.querySelectorAll<HTMLButtonElement>('[data-scenario-choice]').forEach((button) => {
+    button.addEventListener('click', () => {
+      context.state.scenarioPercent = Number(button.dataset.scenarioChoice);
+      writeState(context);
+      render(context);
+    });
+  });
+}
+
+function bindUnitSystem(context: ControllerContext): void {
+  context.root.querySelectorAll<HTMLButtonElement>('[data-unit-choice]').forEach((button) => {
+    button.addEventListener('click', () => {
+      const nextUnit = button.dataset.unitChoice;
+      if (nextUnit !== 'metric' && nextUnit !== 'imperial') return;
+      readState(context);
+      context.state.unitSystem = nextUnit as UnitSystem;
+      writeState(context);
+      render(context, false);
+    });
+  });
+}
+
+export function initAquariumNitrateDilutionCalculator(): void {
+  const root = document.querySelector<HTMLElement>('#aquarium-nitrate-dilution-calculator');
+  const uiElement = document.querySelector<HTMLScriptElement>('#aquarium-nitrate-dilution-calculator-ui');
+  if (root === null || uiElement === null) return;
+  const ui = JSON.parse(uiElement.textContent ?? '{}') as AquariumNitrateDilutionCalculatorUI;
+  const context: ControllerContext = { root, ui, state: loadNitrateState() };
+  writeState(context);
+  bindInputs(context);
+  bindScenarios(context);
+  bindUnitSystem(context);
+  root.querySelector<HTMLElement>('[data-action="reset"]')?.addEventListener('click', () => reset(context));
+  render(context, false);
+}

package/src/tool/aquariumNitrateDilutionCalculator/dom-views.ts

@@ -0,0 +1,151 @@
+import type { NitrateCalculation, NitrateResult } from './logic';
+import { evaluateNitrateCalculation } from './evaluator';
+import type { AquariumNitrateDilutionCalculatorUI } from './ui';
+import { nitrateUnit, volumeToDisplay, volumeUnit, type UnitSystem } from './units';
+
+interface RenderContext {
+  root: HTMLElement;
+  ui: AquariumNitrateDilutionCalculatorUI;
+  locale: string;
+  scenarioPercent: number;
+  unitSystem: UnitSystem;
+}
+
+function numberFormat(value: number, locale: string, maximumFractionDigits = 1): string {
+  return new Intl.NumberFormat(locale, { maximumFractionDigits }).format(value);
+}
+
+function setText(root: HTMLElement, key: string, value: string): void {
+  const element = root.querySelector<HTMLElement>(`[data-result="${key}"]`);
+  if (element !== null) element.textContent = value;
+}
+
+function setError(root: HTMLElement, message: string): void {
+  const error = root.querySelector<HTMLElement>('[data-error]');
+  if (error !== null) error.textContent = message;
+}
+
+function renderSafetyNote(context: RenderContext, requiredPercent: number): void {
+  const note = context.root.querySelector<HTMLElement>('[data-safety-note]');
+  context.root.classList.remove('is-high-change', 'is-critical-change');
+  if (note === null) return;
+  if (requiredPercent <= 50) {
+    note.hidden = true;
+    return;
+  }
+  const critical = requiredPercent > 75;
+  context.root.classList.add(critical ? 'is-critical-change' : 'is-high-change');
+  note.hidden = false;
+  setText(context.root, 'safety-label', critical ? context.ui.criticalSafetyLabel : context.ui.safetyLabel);
+  setText(context.root, 'safety-copy', critical ? context.ui.criticalSafetyHint : context.ui.safetyHint);
+}
+
+function setUnitLabels(context: RenderContext): void {
+  const displayVolumeUnit = volumeUnit(context.unitSystem);
+  const displayNitrateUnit = nitrateUnit(context.unitSystem);
+  context.root.querySelectorAll<HTMLElement>('[data-unit-label="volume"]').forEach((element) => { element.textContent = displayVolumeUnit; });
+  context.root.querySelectorAll<HTMLElement>('[data-unit-label="nitrate"]').forEach((element) => { element.textContent = displayNitrateUnit; });
+}
+
+function concentrationLevel(value: number): number {
+  return Math.min(100, Math.max(0.5, value));
+}
+
+function setMarkers(root: HTMLElement, calculation: NitrateCalculation, selectedAfter: number): void {
+  root.style.setProperty('--n-current-level', `${concentrationLevel(calculation.currentNitrate)}%`);
+  root.style.setProperty('--n-target-level', `${concentrationLevel(calculation.targetNitrate)}%`);
+  root.style.setProperty('--n-after-level', `${concentrationLevel(selectedAfter)}%`);
+  root.style.setProperty('--n-source-level', `${concentrationLevel(calculation.sourceNitrate)}%`);
+}
+
+function renderScenarioRows(context: RenderContext, calculation: NitrateCalculation): void {
+  const list = context.root.querySelector<HTMLOListElement>('[data-scenario-list]');
+  if (list === null) return;
+  list.replaceChildren();
+  calculation.scenarios.forEach((scenario) => {
+    const row = document.createElement('li');
+    const heading = document.createElement('span');
+    const result = document.createElement('strong');
+    const detail = document.createElement('small');
+    const repeat = scenario.reachesTargetAfter === null ? context.ui.notReached : `${scenario.reachesTargetAfter} ${context.ui.repeatLabel}`;
+    heading.textContent = `${scenario.percent}%`;
+    result.textContent = `${numberFormat(scenario.afterOne, context.locale)} ${nitrateUnit(context.unitSystem)}`;
+    detail.textContent = `${numberFormat(volumeToDisplay(scenario.litres, context.unitSystem), context.locale)} ${volumeUnit(context.unitSystem)}, ${repeat}`;
+    row.append(heading, result, detail);
+    list.append(row);
+  });
+}
+
+function renderPlan(context: RenderContext, scenario: NitrateCalculation['scenarios'][number] | undefined): void {
+  const list = context.root.querySelector<HTMLOListElement>('[data-plan-list]');
+  if (list === null) return;
+  list.replaceChildren();
+  if (scenario === undefined) return;
+  const stepCount = scenario.reachesTargetAfter ?? scenario.sequence.length;
+  scenario.sequence.slice(0, stepCount).forEach((value, index) => {
+    const row = document.createElement('li');
+    const label = document.createElement('span');
+    const result = document.createElement('strong');
+    label.textContent = `${context.ui.planChangeLabel} ${index + 1}`;
+    result.textContent = `${numberFormat(value, context.locale)} ${nitrateUnit(context.unitSystem)}`;
+    row.append(label, result);
+    list.append(row);
+  });
+}
+
+function renderReady(context: RenderContext, calculation: NitrateCalculation): void {
+  const evaluation = evaluateNitrateCalculation(calculation, context.scenarioPercent);
+  const scenario = calculation.scenarios.find((item) => item.percent === context.scenarioPercent) ?? calculation.scenarios[0];
+  const statusText = getStatusText(context, calculation.status);
+  const answer = getAnswerText(context, calculation.status);
+  setError(context.root, '');
+  setUnitLabels(context);
+  setText(context.root, 'status', statusText);
+  setText(context.root, 'required', `${numberFormat(calculation.requiredPercent, context.locale)}%`);
+  setText(context.root, 'required-litres', `${numberFormat(volumeToDisplay(calculation.requiredLitres, context.unitSystem), context.locale)} ${volumeUnit(context.unitSystem)}`);
+  setText(context.root, 'after', `${numberFormat(evaluation.selectedAfter, context.locale)} ${nitrateUnit(context.unitSystem)}`);
+  setText(context.root, 'answer', answer);
+  setText(context.root, 'scenario', `${context.ui.currentScenarioLabel} ${context.scenarioPercent}%`);
+  const repeat = scenario?.reachesTargetAfter;
+  setText(context.root, 'repeat', repeat === null || repeat === undefined ? context.ui.notReached : `${repeat} ${context.ui.repeatLabel}`);
+  renderSafetyNote(context, calculation.requiredPercent);
+  setMarkers(context.root, calculation, evaluation.selectedAfter);
+  renderScenarioRows(context, calculation);
+  renderPlan(context, scenario);
+}
+
+function getStatusText(context: RenderContext, status: NitrateCalculation['status']): string {
+  if (status === 'ready') return context.ui.targetReached;
+  if (status === 'already-below') return context.ui.alreadyBelow;
+  return context.ui.unreachable;
+}
+
+function getAnswerText(context: RenderContext, status: NitrateCalculation['status']): string {
+  if (status === 'unreachable') return context.ui.impossibleHint;
+  if (status === 'already-below') return context.ui.belowTargetHint;
+  return context.ui.measureAgainHint;
+}
+
+function renderError(context: RenderContext, result: Extract<NitrateResult, { ok: false }>): void {
+  const labels: Record<Extract<NitrateResult, { ok: false }>['error'], string> = {
+    volume: context.ui.volumeLabel,
+    current: context.ui.currentLabel,
+    target: context.ui.targetLabel,
+    source: context.ui.sourceLabel,
+  };
+  setText(context.root, 'status', context.ui.inputsLegend);
+  setError(context.root, `${labels[result.error]}: ${context.ui.sourceHint}`);
+  context.root.classList.remove('is-high-change', 'is-critical-change');
+  const note = context.root.querySelector<HTMLElement>('[data-safety-note]');
+  if (note !== null) note.hidden = true;
+  context.root.querySelector<HTMLOListElement>('[data-plan-list]')?.replaceChildren();
+}
+
+export function renderNitrateResults(context: RenderContext, result: NitrateResult): void {
+  setUnitLabels(context);
+  if (!result.ok) {
+    renderError(context, result);
+    return;
+  }
+  renderReady(context, result.value);
+}

package/src/tool/aquariumNitrateDilutionCalculator/entry.ts

@@ -0,0 +1,27 @@
+import type { AquariumToolEntry, ToolLocaleContent } from '../../types';
+import type { AquariumNitrateDilutionCalculatorUI } from './ui';
+
+export type { AquariumNitrateDilutionCalculatorUI };
+export type AquariumNitrateDilutionCalculatorLocaleContent = ToolLocaleContent<AquariumNitrateDilutionCalculatorUI>;
+
+export const aquariumNitrateDilutionCalculator: AquariumToolEntry<AquariumNitrateDilutionCalculatorUI> = {
+  id: 'aquarium-nitrate-dilution-calculator',
+  icons: { bg: 'mdi:water-outline', fg: 'mdi:test-tube' },
+  i18n: {
+    de: () => import('./i18n/de').then((module) => module.content),
+    en: () => import('./i18n/en').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};

package/src/tool/aquariumNitrateDilutionCalculator/evaluator.ts

@@ -0,0 +1,17 @@
+import type { NitrateCalculation } from './logic';
+
+export interface NitrateEvaluation {
+  markerPercent: number;
+  selectedAfter: number;
+}
+
+export function evaluateNitrateCalculation(
+  calculation: NitrateCalculation,
+  scenarioPercent: number,
+): NitrateEvaluation {
+  const scenario = calculation.scenarios.find((item) => item.percent === scenarioPercent) ?? calculation.scenarios[0];
+  return {
+    markerPercent: calculation.requiredPercent,
+    selectedAfter: scenario?.afterOne ?? calculation.afterRequired,
+  };
+}

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

@@ -0,0 +1,30 @@
+import { createAquariumNitrateContent } from '../localized-content';
+
+export const content = createAquariumNitrateContent({
+  locale: 'de', slug: 'aquarium-nitrat-verduennungs-wasserwechsel-rechner', title: 'Aquarium Nitrat Verdünnungs Rechner für Wasserwechsel', description: 'Berechne den nötigen Wasserwechsel, um den gemessenen Nitratwert mit deinem tatsächlichen Wasservolumen und dem Nitrat im Frischwasser zu senken.',
+  faq: [
+    { question: 'Was berechnet dieses Aquarium-Nitratwerkzeug?', answer: 'Es schätzt den Anteil und die Wassermenge, die ersetzt werden müssen, damit ein gemessener Nitratwert ein Ziel erreicht. Dabei wird auch Nitrat im Ersatzwasser berücksichtigt.' },
+    { question: 'Warum ist der Nitratwert des neuen Wassers wichtig?', answer: 'Wenn das Ersatzwasser selbst Nitrat enthält, kann eine Verdünnung den Zielwert nicht unterschreiten. Der Wert gehört deshalb zur Rechnung.' },
+    { question: 'Was zeigt der Schrittplan?', answer: 'Er zeigt den erwarteten Restwert nach mehreren gleichen Wasserwechseln. Das ist ein Rechenmodell und kein fester Pflegekalender.' },
+    { question: 'Was bedeutet ein Wechsel über 50 Prozent?', answer: 'Ein sehr großer einzelner Wechsel kann Tiere und Wasserchemie belasten. Teile ihn bei Bedarf auf und prüfe Temperatur und Wasserwerte.' },
+    { question: 'Werden meine Werte übertragen?', answer: 'Nein. Die Berechnung läuft im Browser; die letzten Eingaben können lokal in diesem Browser gespeichert werden.' },
+  ],
+  howTo: [
+    { name: 'Tatsächliches Wasservolumen eingeben', text: 'Verwende das Wasser, das wirklich im Becken ist, nicht die Herstellerangabe. Ziehe den Raum für Bodengrund und Dekoration gedanklich ab.' },
+    { name: 'Drei Nitratwerte eintragen', text: 'Gib den aktuellen Wert, dein Ziel und den Nitratwert des neuen Wassers ein. Verwende überall dieselbe Einheit.' },
+    { name: 'Vorgeschlagenen Wechsel prüfen', text: 'Lies Prozent und Wassermenge für den theoretisch nötigen Einzelwechsel ab. Bei großen Werten erscheint ein Sicherheitshinweis.' },
+    { name: 'Praktisches Szenario auswählen', text: 'Wähle 25, 40, 50 oder 75 Prozent und öffne den Schrittplan, um die erwarteten Restwerte zu vergleichen.' },
+  ],
+  seo: [
+    { type: 'title', text: 'Nitratwerte in eine Wasserwechselentscheidung übersetzen', level: 2 },
+    { type: 'paragraph', html: 'Ein Prozentwert allein sagt wenig aus. Dieses Werkzeug verbindet den aktuellen Messwert, den Zielwert, das tatsächliche Wasservolumen und Nitrat im neuen Wasser zu einer nachvollziehbaren Wassermenge.' },
+    { type: 'title', text: 'Warum das Ersatzwasser mitgerechnet wird', level: 2 },
+    { type: 'paragraph', html: 'Die Rechnung behandelt das Becken als gut durchmischtes Volumen. Enthält das neue Wasser bereits Nitrat, bleibt nach dem Wechsel ein entsprechender Restwert zurück.' },
+    { type: 'list', items: ['Miss das Arbeitsvolumen statt nur die Aufschrift des Beckens zu übernehmen.', 'Teste das Ersatzwasser aus derselben Quelle, die du verwenden wirst.', 'Vergleiche einen großen Einzelwechsel mit mehreren moderaten Wechseln.', 'Messe nach dem Durchmischen erneut.'] },
+    { type: 'tip', title: 'Große Wechsel aufteilen', html: '<p>Bei einem Ergebnis über 50 Prozent kann ein gestufter Ablauf schonender sein. Temperatur und Wasserchemie müssen trotzdem zu den Tieren passen.</p>' },
+    { type: 'table', headers: ['Ausgabe', 'Bedeutung'], rows: [['Erforderlicher Prozentsatz', 'Theoretischer Anteil des Arbeitsvolumens'], ['Zu ersetzendes Wasser', 'Menge für den errechneten Einzelwechsel'], ['Nach gewähltem Wechsel', 'Prognostizierter Nitratwert nach einem Szenario'], ['Schrittplan', 'Restwert nach mehreren gleichen Wechseln']] },
+  ],
+  ui: {
+    toolKicker: 'Nitratwechsel-Rezept', inputInstruction: 'Trage ein, was jetzt im Becken ist. Das Rezept übersetzt dein Ziel in eine Wassermenge.', unitSystemLabel: 'Anzeigen in', metricLabel: 'Metrisch', imperialLabel: 'Imperial', metricUnitSummary: 'L / mg/L', imperialUnitSummary: 'US gal / ppm', volumeHint: 'Tatsächliches Wasser, nicht Beckenangabe', readingHint: 'Aus deinem Test', readingsTitle: 'Deine Wasserprobe', decisionTitle: 'Der nötige Wechsel', actionLabel: 'Ersetzen', sceneCaption: 'Mischen und erneut testen', newWaterLabel: 'Neues Wasser', inputsLegend: 'Ein Volumen und drei Nitratwerte verwenden', volumeLabel: 'Arbeitsvolumen', volumeUnit: 'L', currentLabel: 'Aktuelles Nitrat', targetLabel: 'Ziel-Nitrat', sourceLabel: 'Nitrat im neuen Wasser', nitrateUnit: 'mg/L NO3', sourceHint: 'Verwende für alle Werte dieselbe Nitrat-Einheit. Teste das Ersatzwasser, wenn du seinen Wert nicht kennst.', currentMarker: 'Aktuell', targetMarker: 'Ziel', targetReached: 'Ziel erreichbar', alreadyBelow: 'Bereits unter dem Ziel', unreachable: 'Durch Verdünnung nicht erreichbar', requiredChangeLabel: 'des Arbeitsvolumens', requiredLitresLabel: 'Zu ersetzendes Wasser', afterChangeLabel: 'Nach gewähltem Wechsel', safetyLabel: 'Wechsel aufteilen', safetyHint: 'Ein einzelner Wechsel über 50 Prozent kann Aquarienbewohner belasten. Prüfe Temperatur und Wasserchemie und teile ihn bei Bedarf auf kleinere Wechsel auf.', criticalSafetyLabel: 'Keinen großen Einzelwechsel machen', criticalSafetyHint: 'Die Schätzung liegt über 75 Prozent. Verwende gestufte Wechsel und teste dazwischen erneut, statt fast das gesamte Wasser auf einmal zu ersetzen.', scenarioLabel: 'Wechselszenario', scenarioHint: 'Wähle einen praktischen Prozentsatz', planLabel: 'Schritt-für-Schritt-Plan', planHint: 'Das Modell zeigt den Restwert nach jedem gleichen Wechsel. Es ist kein Kalender und keine Garantie.', planChangeLabel: 'Nach Wechsel', biologyHint: 'Das Aquarium produziert zwischen den Wechseln weiter Nitrat. Deshalb können echte Messwerte von diesem reinen Verdünnungsmodell abweichen. Nach dem Mischen erneut testen.', impossibleHint: 'Das neue Wasser enthält zu viel Nitrat, um dieses Ziel allein durch Verdünnung zu erreichen.', belowTargetHint: 'Der aktuelle Messwert liegt bereits am oder unter dem Ziel. Nutze ihn als Referenz und teste nach deinem normalen Pflegeplan erneut.', measureAgainHint: 'Das ist eine Mischschätzung. Teste nach dem Durchmischen erneut, weil sich das Aquarium zwischen den Messungen weiter verändert.', resetLabel: 'Werte zurücksetzen', currentScenarioLabel: 'Gewählter Wechsel', repeatLabel: 'Wechsel', notReached: 'Nicht erreicht', scenarioTwentyFive: '25%', scenarioForty: '40%', scenarioFifty: '50%', scenarioSeventyFive: '75%',
+  },
+});

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

@@ -0,0 +1,124 @@
+import { bibliography } from '../bibliography';
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { AquariumNitrateDilutionCalculatorUI } from '../ui';
+
+const slug = 'aquarium-nitrate-dilution-calculator';
+const title = 'Aquarium Nitrate Dilution Water Change Calculator';
+const description = 'Calculate the aquarium water change needed to move a measured nitrate level toward your target, using your tank volume and fresh water nitrate reading.';
+
+const faq = [
+  { question: 'What does this aquarium nitrate calculator calculate?', answer: 'It estimates the fraction and litres of aquarium water to replace so a measured nitrate concentration reaches a target, assuming the replacement water mixes evenly and has the nitrate value you enter.' },
+  { question: 'Why does the nitrate level of replacement water matter?', answer: 'A water change mixes tank water with new water. If the new water already contains nitrate, the final concentration cannot fall below that source concentration through dilution alone.' },
+  { question: 'What does the repeated change scenario show?', answer: 'It applies the same percentage change more than once while keeping the same source-water reading. The step-by-step panel shows the predicted residual nitrate after each change; it is a model, not a maintenance schedule.' },
+  { question: 'Does this tell me what nitrate level is safe for my fish?', answer: 'No. The target is your chosen planning value. Species, life stage, salinity, acclimation and the rest of the water chemistry need separate husbandry guidance.' },
+  { question: 'Should I measure again after changing water?', answer: 'Yes. Test the aquarium after the new water has mixed. The result assumes the measured values are accurate and ignores nitrate production, plant uptake and other changes between tests.' },
+];
+
+const howTo = [
+  { name: 'Enter the working water volume', text: 'Use the water volume you are actually changing, not the advertised tank capacity. Include your best estimate after substrate and hardscape displacement.' },
+  { name: 'Add three nitrate readings', text: 'Enter the current aquarium reading, your target reading and the nitrate concentration in the replacement water. Keep the unit consistent across all three values.' },
+  { name: 'Read the required change', text: 'The calculator solves the mixing equation and shows the percentage and litres required for one theoretical change.' },
+  { name: 'Compare practical scenarios', text: 'Select a 25%, 40%, 50% or 75% change to see its first result, how many repeated changes the model needs and the residual nitrate after each step.' },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 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: 'USD' },
+  inLanguage: 'en',
+};
+
+export const content: ToolLocaleContent<AquariumNitrateDilutionCalculatorUI> = {
+  slug,
+  title,
+  description,
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'Turn a nitrate reading into a water change decision', level: 2 },
+    { type: 'paragraph', html: 'A water change percentage is only useful when it is connected to a measured starting value, a target and the nitrate already present in the replacement water. This calculator keeps those three concentrations visible and turns them into a practical volume for your aquarium.' },
+    { type: 'title', text: 'The mixing idea behind the estimate', level: 2 },
+    { type: 'paragraph', html: 'The model treats the aquarium as a well-mixed volume. After replacing a fraction of the water, the predicted concentration is the remaining tank concentration plus the replacement-water concentration, each weighted by its share of the final volume. This is the same conservation-of-concentration idea used in standard dilution calculations.' },
+    { type: 'list', items: ['Measure the aquarium before the change.', 'Use a replacement-water nitrate result from the same source you will add.', 'Compare the required percentage with a practical change size.', 'Test again after mixing and use the new reading for the next decision.'] },
+    { type: 'title', text: 'Why the source-water reading can stop the calculation', level: 2 },
+    { type: 'paragraph', html: 'If replacement water contains nitrate at or above your target, dilution alone cannot reach a lower target. The tool marks that boundary instead of returning a deceptively precise percentage. You may need a different water source or a separate nitrate-management approach, but this calculator does not prescribe one.' },
+    { type: 'title', text: 'How to read the repeated-change strip', level: 2 },
+    { type: 'paragraph', html: 'The scenario strip shows the first predicted reading for each change size. Open the step-by-step panel for the residual nitrate after each repeated change, up to eight steps. Repeated changes compound because each change acts on the lower concentration left by the previous one. Real aquariums may move differently as waste production, plants, substrate and timing change.' },
+    { type: 'tip', title: 'Use the result as a testable plan', html: '<p>Do not treat the output as a guarantee. Match temperature and other relevant water properties, make the change safely, allow the tank to mix, and measure again. The follow-up reading is the evidence that matters.</p>' },
+    { type: 'table', headers: ['Output', 'Meaning'], rows: [['Required percentage', 'The theoretical fraction of the working water volume to replace'], ['Required litres', 'The same fraction expressed using the volume you entered'], ['After selected change', 'The predicted nitrate reading after one chosen scenario'], ['Repeated changes', 'How many identical scenario changes the model needs, up to eight']] },
+  ],
+  ui: {
+    toolKicker: 'Nitrate change recipe',
+    inputInstruction: 'Enter what is in the tank now. The recipe turns your target into a water-change amount.',
+    unitSystemLabel: 'Display units',
+    metricLabel: 'Metric',
+    imperialLabel: 'Imperial',
+    metricUnitSummary: 'L / mg/L',
+    imperialUnitSummary: 'US gal / ppm',
+    volumeHint: 'Actual water, not tank label',
+    readingHint: 'From your test',
+    readingsTitle: 'Your water sample',
+    decisionTitle: 'The change to make',
+    actionLabel: 'Replace',
+    sceneCaption: 'Mix and re-test',
+    newWaterLabel: 'New water',
+    inputsLegend: 'Use one volume and three nitrate readings',
+    volumeLabel: 'Working water volume',
+    volumeUnit: 'L',
+    currentLabel: 'Current nitrate',
+    targetLabel: 'Target nitrate',
+    sourceLabel: 'New water nitrate',
+    nitrateUnit: 'mg/L NO3',
+    sourceHint: 'Use the same nitrate unit for all readings. Test the replacement water if you do not know its value.',
+    currentMarker: 'Current',
+    targetMarker: 'Target',
+    targetReached: 'Target reachable',
+    alreadyBelow: 'Already below target',
+    unreachable: 'Target not reachable by dilution',
+    requiredChangeLabel: 'of the working water',
+    requiredLitresLabel: 'Water to replace',
+    afterChangeLabel: 'After selected change',
+    safetyLabel: 'Stage this change',
+    safetyHint: 'A single change above 50% can stress aquarium inhabitants. Match temperature and water chemistry, and consider splitting it into smaller changes.',
+    criticalSafetyLabel: 'Avoid one large change',
+    criticalSafetyHint: 'This estimate is above 75%. Use staged changes and re-test between them rather than replacing almost all the water at once.',
+    scenarioLabel: 'Change scenario',
+    scenarioHint: 'Choose a practical percentage to inspect',
+    planLabel: 'Step-by-step plan',
+    planHint: 'The model below shows the residual nitrate after each identical change. It is not a calendar or a guarantee.',
+    planChangeLabel: 'After change',
+    biologyHint: 'Nitrate production continues between changes, so real readings will drift from this dilution-only model. Re-test after the water has mixed.',
+    impossibleHint: 'The new water is too high in nitrate to reach this target by dilution alone.',
+    belowTargetHint: 'Your current reading is already at or below the target. Keep the result as a reference, then test again on your normal schedule.',
+    measureAgainHint: 'This is a mixing estimate. Re-test after the water has mixed because the aquarium keeps changing between readings.',
+    resetLabel: 'Reset values',
+    currentScenarioLabel: 'Selected change',
+    repeatLabel: 'changes',
+    notReached: 'Not reached',
+    scenarioTwentyFive: '25%',
+    scenarioForty: '40%',
+    scenarioFifty: '50%',
+    scenarioSeventyFive: '75%',
+  },
+};