@jjlmoya/utils-aquarium 1.69.0 → 1.70.0

package/src/tool/aquariumNitrateDilutionCalculator/localized-content.ts

@@ -0,0 +1,138 @@
+import type { FAQPage, HowTo, SoftwareApplication, Thing, WithContext } from 'schema-dts';
+import { bibliography } from './bibliography';
+import type { ToolLocaleContent } from '../../types';
+import type { AquariumNitrateDilutionCalculatorUI } from './ui';
+
+export interface AquariumNitrateLocaleCopy {
+  locale: string;
+  slug: string;
+  title: string;
+  description: string;
+  faq: { question: string; answer: string }[];
+  howTo: { name: string; text: string }[];
+  seo: ToolLocaleContent['seo'];
+  ui: AquariumNitrateDilutionCalculatorUI;
+}
+
+const additionalSeoByLocale: Record<string, ToolLocaleContent['seo']> = {
+  de: [
+    { type: 'title', text: 'So liest du wiederholte Wechsel', level: 2 },
+    { type: 'paragraph', html: 'Die Szenarien zeigen, wie der Nitratwert nach jedem identischen Wechsel rechnerisch sinkt. Jeder Schritt beginnt mit dem niedrigeren Restwert des vorherigen Schritts.' },
+    { type: 'title', text: 'Warum Nachmessen wichtig bleibt', level: 2 },
+    { type: 'paragraph', html: 'Das Becken produziert zwischen den Wechseln weiter Nitrat. Nutze die nächste Messung deshalb als neue Grundlage und nicht nur die Modellzahl.' },
+  ],
+  es: [
+    { type: 'title', text: 'Cómo leer los cambios repetidos', level: 2 },
+    { type: 'paragraph', html: 'Los escenarios muestran cómo bajaría el nitrato después de cada cambio idéntico. Cada paso empieza con el valor residual del paso anterior.' },
+    { type: 'title', text: 'Por qué sigue siendo necesario medir', level: 2 },
+    { type: 'paragraph', html: 'El acuario continúa produciendo nitratos entre cambios. Usa la próxima medición como nueva base y no solo la cifra del modelo.' },
+  ],
+  fr: [
+    { type: 'title', text: 'Lire les changements répétés', level: 2 },
+    { type: 'paragraph', html: 'Les scénarios montrent la baisse calculée après chaque changement identique. Chaque étape part de la concentration résiduelle de la précédente.' },
+    { type: 'title', text: 'Pourquoi il faut toujours remesurer', level: 2 },
+    { type: 'paragraph', html: "L'aquarium continue de produire des nitrates entre les changements. Utilisez donc la prochaine mesure comme nouvelle base, plutôt que le seul modèle." },
+  ],
+  id: [
+    { type: 'title', text: 'Cara membaca penggantian berulang', level: 2 },
+    { type: 'paragraph', html: 'Skenario menunjukkan penurunan nitrat yang diperkirakan setelah setiap penggantian yang sama. Setiap langkah dimulai dari nilai sisa langkah sebelumnya.' },
+    { type: 'title', text: 'Mengapa pengukuran ulang tetap penting', level: 2 },
+    { type: 'paragraph', html: 'Akuarium terus menghasilkan nitrat di antara penggantian air. Jadikan hasil pengukuran berikutnya sebagai dasar baru, bukan hanya angka model.' },
+  ],
+  it: [
+    { type: 'title', text: 'Come leggere i cambi ripetuti', level: 2 },
+    { type: 'paragraph', html: 'Gli scenari mostrano la riduzione stimata dopo ogni cambio identico. Ogni fase parte dalla concentrazione residua della fase precedente.' },
+    { type: 'title', text: 'Perché serve sempre una nuova misura', level: 2 },
+    { type: 'paragraph', html: "L'acquario continua a produrre nitrati tra un cambio e l'altro. Usa quindi la prossima misurazione come nuova base, non solo il numero del modello." },
+  ],
+  ja: [
+    { type: 'title', text: '繰り返す水換えの見方', level: 2 },
+    { type: 'paragraph', html: 'シナリオでは、同じ割合の水換えを繰り返した場合の硝酸塩の残り方を示します。各段階は前の段階で残った値から始まります。' },
+    { type: 'title', text: '再測定が必要な理由', level: 2 },
+    { type: 'paragraph', html: '水換えの間も水槽では硝酸塩が増え続けます。次の測定値を新しい基準として使い、モデルの数値だけで判断しないでください。' },
+  ],
+  ko: [
+    { type: 'title', text: '반복 물갈이 결과 읽기', level: 2 },
+    { type: 'paragraph', html: '시나리오는 같은 비율의 물갈이를 반복했을 때 예상되는 질산염 잔량을 보여 줍니다. 각 단계는 이전 단계에서 남은 값으로 시작합니다.' },
+    { type: 'title', text: '다시 측정해야 하는 이유', level: 2 },
+    { type: 'paragraph', html: '물갈이 사이에도 수조에서는 질산염이 계속 만들어집니다. 다음 측정값을 새로운 기준으로 삼고 모델의 숫자만으로 판단하지 마세요.' },
+  ],
+  nl: [
+    { type: 'title', text: 'Herhaalde wissels lezen', level: 2 },
+    { type: 'paragraph', html: "De scenario's tonen de berekende daling na elke identieke wissel. Elke stap begint met de restwaarde van de vorige stap." },
+    { type: 'title', text: 'Waarom opnieuw meten nodig blijft', level: 2 },
+    { type: 'paragraph', html: 'Het aquarium blijft tussen wissels nitraat produceren. Gebruik daarom de volgende meting als nieuwe basis en niet alleen het modelgetal.' },
+  ],
+  pl: [
+    { type: 'title', text: 'Jak czytać powtarzane podmiany', level: 2 },
+    { type: 'paragraph', html: 'Scenariusze pokazują obliczany spadek azotanów po każdej identycznej podmianie. Każdy etap zaczyna się od wartości pozostałej po poprzednim.' },
+    { type: 'title', text: 'Dlaczego trzeba ponownie mierzyć', level: 2 },
+    { type: 'paragraph', html: 'Akwarium nadal wytwarza azotany pomiędzy podmianami. Kolejny pomiar traktuj więc jako nową podstawę, a nie jako potwierdzenie samego modelu.' },
+  ],
+  pt: [
+    { type: 'title', text: 'Como ler as trocas repetidas', level: 2 },
+    { type: 'paragraph', html: 'Os cenários mostram a descida estimada dos nitratos após cada troca igual. Cada etapa começa com o valor residual da etapa anterior.' },
+    { type: 'title', text: 'Porque é importante medir de novo', level: 2 },
+    { type: 'paragraph', html: 'O aquário continua a produzir nitratos entre trocas. Use a medição seguinte como nova referência, e não apenas o número do modelo.' },
+  ],
+  ru: [
+    { type: 'title', text: 'Как читать повторные подмены', level: 2 },
+    { type: 'paragraph', html: 'Сценарии показывают расчетное снижение нитратов после каждой одинаковой подмены. Каждый этап начинается с остаточного значения предыдущего этапа.' },
+    { type: 'title', text: 'Почему важно измерять снова', level: 2 },
+    { type: 'paragraph', html: 'Между подменами аквариум продолжает вырабатывать нитраты. Поэтому используйте следующий замер как новую основу, а не только число из модели.' },
+  ],
+  sv: [
+    { type: 'title', text: 'Så läser du upprepade byten', level: 2 },
+    { type: 'paragraph', html: 'Scenarierna visar den beräknade minskningen efter varje identiskt vattenbyte. Varje steg börjar med restvärdet från föregående steg.' },
+    { type: 'title', text: 'Varför du fortfarande måste mäta igen', level: 2 },
+    { type: 'paragraph', html: 'Akvariet fortsätter att bilda nitrat mellan vattenbytena. Använd därför nästa mätning som ny grund och inte bara modellens siffra.' },
+  ],
+  tr: [
+    { type: 'title', text: 'Tekrarlanan değişimleri okuma', level: 2 },
+    { type: 'paragraph', html: 'Senaryolar, aynı değişim tekrarlandığında nitratın tahmini olarak nasıl azaldığını gösterir. Her adım önceki adımda kalan değerden başlar.' },
+    { type: 'title', text: 'Neden yeniden ölçüm gerekir', level: 2 },
+    { type: 'paragraph', html: 'Akvaryum değişimler arasında nitrat üretmeye devam eder. Bu nedenle sonraki ölçümü yeni temel olarak kullanın ve yalnızca model sayısına güvenmeyin.' },
+  ],
+  zh: [
+    { type: 'title', text: '如何阅读重复换水结果', level: 2 },
+    { type: 'paragraph', html: '情景会显示重复进行相同比例换水后预计剩余的硝酸盐。每一步都从上一步留下的数值开始计算。' },
+    { type: 'title', text: '为什么仍然要重新检测', level: 2 },
+    { type: 'paragraph', html: '换水之间鱼缸仍会产生硝酸盐。因此请把下一次检测值作为新的依据，不要只依赖模型数字。' },
+  ],
+};
+
+function createFaqSchema(copy: AquariumNitrateLocaleCopy): WithContext<FAQPage> {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: copy.faq.map((item) => ({ '@type': 'Question', name: item.question, acceptedAnswer: { '@type': 'Answer', text: item.answer } })),
+  };
+}
+
+function createHowToSchema(copy: AquariumNitrateLocaleCopy): WithContext<HowTo> {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: copy.title,
+    description: copy.description,
+    step: copy.howTo.map((step, index) => ({ '@type': 'HowToStep', position: index + 1, name: step.name, text: step.text })),
+  };
+}
+
+function createAppSchema(copy: AquariumNitrateLocaleCopy): WithContext<SoftwareApplication> {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: copy.title,
+    description: copy.description,
+    applicationCategory: 'UtilityApplication',
+    operatingSystem: 'All',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+    inLanguage: copy.locale,
+  };
+}
+
+export function createAquariumNitrateContent(copy: AquariumNitrateLocaleCopy): ToolLocaleContent<AquariumNitrateDilutionCalculatorUI> {
+  const schemas: WithContext<Thing>[] = [createFaqSchema(copy), createHowToSchema(copy), createAppSchema(copy)];
+  return { ...copy, seo: [...copy.seo, ...(additionalSeoByLocale[copy.locale] ?? [])], schemas, bibliography };
+}

package/src/tool/aquariumNitrateDilutionCalculator/logic.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { calculateNitrateDilution, DEFAULT_NITRATE_INPUT } from './logic';
+
+describe('calculateNitrateDilution', () => {
+  it('calculates the exact change needed to reach the target', () => {
+    const result = calculateNitrateDilution(DEFAULT_NITRATE_INPUT);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.requiredPercent).toBeCloseTo(57.142857, 5);
+    expect(result.value.requiredLitres).toBeCloseTo(68.571428, 5);
+    expect(result.value.afterRequired).toBeCloseTo(20, 5);
+  });
+
+  it('models repeated partial changes against the same source water', () => {
+    const result = calculateNitrateDilution(DEFAULT_NITRATE_INPUT);
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const scenario = result.value.scenarios.find((item) => item.percent === 50);
+    expect(scenario?.afterOne).toBeCloseTo(22.5, 5);
+    expect(scenario?.afterTwo).toBeCloseTo(13.75, 5);
+    expect(scenario?.sequence).toHaveLength(8);
+    expect(scenario?.sequence[2]).toBeCloseTo(9.375, 5);
+    expect(scenario?.reachesTargetAfter).toBe(2);
+  });
+
+  it('marks a target at or below the source concentration as unreachable', () => {
+    const result = calculateNitrateDilution({ ...DEFAULT_NITRATE_INPUT, sourceNitrate: 25 });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.status).toBe('unreachable');
+  });
+
+  it('recognizes when the current reading is already below target', () => {
+    const result = calculateNitrateDilution({ ...DEFAULT_NITRATE_INPUT, currentNitrate: 15 });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.value.status).toBe('already-below');
+    expect(result.value.requiredLitres).toBe(0);
+  });
+
+  it('rejects missing or out of range measurements', () => {
+    expect(calculateNitrateDilution({ ...DEFAULT_NITRATE_INPUT, volumeLitres: 0 })).toEqual({ ok: false, error: 'volume' });
+    expect(calculateNitrateDilution({ ...DEFAULT_NITRATE_INPUT, currentNitrate: -1 })).toEqual({ ok: false, error: 'current' });
+    expect(calculateNitrateDilution({ ...DEFAULT_NITRATE_INPUT, targetNitrate: 1001 })).toEqual({ ok: false, error: 'target' });
+    expect(calculateNitrateDilution({ ...DEFAULT_NITRATE_INPUT, sourceNitrate: Number.NaN })).toEqual({ ok: false, error: 'source' });
+  });
+});

package/src/tool/aquariumNitrateDilutionCalculator/logic.ts

@@ -0,0 +1,122 @@
+export interface NitrateDilutionInput {
+  volumeLitres: number;
+  currentNitrate: number;
+  targetNitrate: number;
+  sourceNitrate: number;
+}
+
+export interface NitrateScenario {
+  percent: number;
+  litres: number;
+  afterOne: number;
+  afterTwo: number;
+  afterThree: number;
+  sequence: number[];
+  reachesTargetAfter: number | null;
+}
+
+export type NitrateError = 'volume' | 'current' | 'target' | 'source';
+
+export type NitrateResult =
+  | { ok: true; value: NitrateCalculation }
+  | { ok: false; error: NitrateError };
+
+export interface NitrateCalculation {
+  status: 'ready' | 'already-below' | 'unreachable';
+  currentNitrate: number;
+  targetNitrate: number;
+  sourceNitrate: number;
+  requiredPercent: number;
+  requiredLitres: number;
+  afterRequired: number;
+  scenarios: NitrateScenario[];
+}
+
+export const DEFAULT_NITRATE_INPUT: NitrateDilutionInput = {
+  volumeLitres: 120,
+  currentNitrate: 40,
+  targetNitrate: 20,
+  sourceNitrate: 5,
+};
+
+export const SCENARIO_PERCENTAGES = [25, 40, 50, 75] as const;
+
+function isValid(value: number, maximum: number): boolean {
+  return Number.isFinite(value) && value >= 0 && value <= maximum;
+}
+
+function validateInput(input: NitrateDilutionInput): NitrateError | null {
+  if (!Number.isFinite(input.volumeLitres) || input.volumeLitres <= 0 || input.volumeLitres > 100000) return 'volume';
+  if (!isValid(input.currentNitrate, 1000)) return 'current';
+  if (!isValid(input.targetNitrate, 1000)) return 'target';
+  if (!isValid(input.sourceNitrate, 1000)) return 'source';
+  return null;
+}
+
+function concentrationAfterChange(current: number, source: number, fraction: number): number {
+  return current * (1 - fraction) + source * fraction;
+}
+
+function repeatsToTarget(input: NitrateDilutionInput, fraction: number): number | null {
+  for (let count = 1; count <= 8; count += 1) {
+    const totalFraction = 1 - (1 - fraction) ** count;
+    const after = concentrationAfterChange(input.currentNitrate, input.sourceNitrate, totalFraction);
+    if (after <= input.targetNitrate + 0.000001) return count;
+  }
+  return null;
+}
+
+function repeatedConcentrations(input: NitrateDilutionInput, fraction: number): number[] {
+  return Array.from({ length: 8 }, (_, index) => {
+    const totalFraction = 1 - (1 - fraction) ** (index + 1);
+    return concentrationAfterChange(input.currentNitrate, input.sourceNitrate, totalFraction);
+  });
+}
+
+function makeScenario(input: NitrateDilutionInput, percent: number): NitrateScenario {
+  const fraction = percent / 100;
+  const sequence = repeatedConcentrations(input, fraction);
+  return {
+    percent,
+    litres: input.volumeLitres * fraction,
+    afterOne: sequence[0]!,
+    afterTwo: sequence[1]!,
+    afterThree: sequence[2]!,
+    sequence,
+    reachesTargetAfter: repeatsToTarget(input, fraction),
+  };
+}
+
+function requiredFraction(input: NitrateDilutionInput): number {
+  if (input.currentNitrate <= input.targetNitrate) return 0;
+  if (input.sourceNitrate === input.targetNitrate) return 1;
+  if (input.sourceNitrate > input.targetNitrate) return Number.NaN;
+  return (input.currentNitrate - input.targetNitrate) / (input.currentNitrate - input.sourceNitrate);
+}
+
+function calculationStatus(input: NitrateDilutionInput, fraction: number): NitrateCalculation['status'] {
+  if (Number.isNaN(fraction)) return 'unreachable';
+  if (input.currentNitrate <= input.targetNitrate) return 'already-below';
+  return 'ready';
+}
+
+export function calculateNitrateDilution(input: NitrateDilutionInput): NitrateResult {
+  const error = validateInput(input);
+  if (error !== null) return { ok: false, error };
+  const fraction = requiredFraction(input);
+  const status = calculationStatus(input, fraction);
+  const safeFraction = Number.isNaN(fraction) ? 0 : Math.min(1, Math.max(0, fraction));
+  return {
+    ok: true,
+    value: {
+      status,
+      currentNitrate: input.currentNitrate,
+      targetNitrate: input.targetNitrate,
+      sourceNitrate: input.sourceNitrate,
+      requiredPercent: safeFraction * 100,
+      requiredLitres: input.volumeLitres * safeFraction,
+      afterRequired: concentrationAfterChange(input.currentNitrate, input.sourceNitrate, safeFraction),
+      scenarios: SCENARIO_PERCENTAGES.map((percent) => makeScenario(input, percent)),
+    },
+  };
+}

package/src/tool/aquariumNitrateDilutionCalculator/seo.astro

@@ -0,0 +1,13 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { aquariumNitrateDilutionCalculator } from './entry';
+import type { KnownLocale } from '../../types';
+
+interface Props { locale?: KnownLocale; }
+
+const { locale = 'en' } = Astro.props;
+const loader = aquariumNitrateDilutionCalculator.i18n[locale] ?? aquariumNitrateDilutionCalculator.i18n.en;
+const content = loader === undefined ? undefined : await loader();
+---
+
+{content && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/aquariumNitrateDilutionCalculator/storage.ts

@@ -0,0 +1,36 @@
+import { DEFAULT_NITRATE_INPUT, type NitrateDilutionInput } from './logic';
+import type { UnitSystem } from './units';
+
+const STORAGE_KEY = 'aquarium-nitrate-dilution-calculator';
+
+export interface SavedNitrateState {
+  input: NitrateDilutionInput;
+  scenarioPercent: number;
+  unitSystem: UnitSystem;
+}
+
+export function defaultNitrateState(): SavedNitrateState {
+  return { input: { ...DEFAULT_NITRATE_INPUT }, scenarioPercent: 25, unitSystem: 'metric' };
+}
+
+export function loadNitrateState(): SavedNitrateState {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (raw === null) return defaultNitrateState();
+    const parsed = JSON.parse(raw) as Partial<SavedNitrateState>;
+    if (parsed.input === undefined) return defaultNitrateState();
+    return {
+      input: { ...DEFAULT_NITRATE_INPUT, ...parsed.input },
+      scenarioPercent: typeof parsed.scenarioPercent === 'number' ? parsed.scenarioPercent : 25,
+      unitSystem: parsed.unitSystem === 'imperial' ? 'imperial' : 'metric',
+    };
+  } catch {
+    return defaultNitrateState();
+  }
+}
+
+export function saveNitrateState(state: SavedNitrateState): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(state));
+  } catch {}
+}

package/src/tool/aquariumNitrateDilutionCalculator/ui.ts

@@ -0,0 +1,53 @@
+export interface AquariumNitrateDilutionCalculatorUI extends Record<string, string> {
+  toolKicker: string;
+  inputInstruction: string;
+  unitSystemLabel: string;
+  metricLabel: string;
+  imperialLabel: string;
+  metricUnitSummary: string;
+  imperialUnitSummary: string;
+  volumeHint: string;
+  readingHint: string;
+  readingsTitle: string;
+  decisionTitle: string;
+  actionLabel: string;
+  sceneCaption: string;
+  newWaterLabel: string;
+  inputsLegend: string;
+  volumeLabel: string;
+  volumeUnit: string;
+  currentLabel: string;
+  targetLabel: string;
+  sourceLabel: string;
+  nitrateUnit: string;
+  sourceHint: string;
+  currentMarker: string;
+  targetMarker: string;
+  targetReached: string;
+  alreadyBelow: string;
+  unreachable: string;
+  requiredChangeLabel: string;
+  requiredLitresLabel: string;
+  afterChangeLabel: string;
+  safetyLabel: string;
+  safetyHint: string;
+  criticalSafetyLabel: string;
+  criticalSafetyHint: string;
+  scenarioLabel: string;
+  scenarioHint: string;
+  planLabel: string;
+  planHint: string;
+  planChangeLabel: string;
+  biologyHint: string;
+  impossibleHint: string;
+  belowTargetHint: string;
+  measureAgainHint: string;
+  resetLabel: string;
+  currentScenarioLabel: string;
+  repeatLabel: string;
+  notReached: string;
+  scenarioTwentyFive: string;
+  scenarioForty: string;
+  scenarioFifty: string;
+  scenarioSeventyFive: string;
+}

package/src/tool/aquariumNitrateDilutionCalculator/units.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { nitrateUnit, volumeFromDisplay, volumeToDisplay, volumeUnit } from './units';
+
+describe('aquarium nitrate dilution units', () => {
+  it('converts displayed imperial volume without changing the physical volume', () => {
+    const gallons = volumeToDisplay(120, 'imperial');
+    expect(gallons).toBeCloseTo(31.7006, 3);
+    expect(volumeFromDisplay(gallons, 'imperial')).toBeCloseTo(120, 8);
+  });
+
+  it('labels both unit systems consistently', () => {
+    expect(volumeUnit('metric')).toBe('L');
+    expect(nitrateUnit('metric')).toBe('mg/L NO3');
+    expect(volumeUnit('imperial')).toBe('US gal');
+    expect(nitrateUnit('imperial')).toBe('ppm NO3');
+  });
+});

package/src/tool/aquariumNitrateDilutionCalculator/units.ts

@@ -0,0 +1,19 @@
+export type UnitSystem = 'metric' | 'imperial';
+
+const LITRES_PER_US_GALLON = 3.785411784;
+
+export function volumeToDisplay(volumeLitres: number, unitSystem: UnitSystem): number {
+  return unitSystem === 'imperial' ? volumeLitres / LITRES_PER_US_GALLON : volumeLitres;
+}
+
+export function volumeFromDisplay(volume: number, unitSystem: UnitSystem): number {
+  return unitSystem === 'imperial' ? volume * LITRES_PER_US_GALLON : volume;
+}
+
+export function volumeUnit(unitSystem: UnitSystem): string {
+  return unitSystem === 'imperial' ? 'US gal' : 'L';
+}
+
+export function nitrateUnit(unitSystem: UnitSystem): string {
+  return unitSystem === 'imperial' ? 'ppm NO3' : 'mg/L NO3';
+}

package/src/tools.ts

@@ -1,39 +1,18 @@
 export { ALL_ENTRIES } from './entries';
-import { aquariumTankVolumeWaterChangeCalculator } from './tool/aquariumTankVolumeWaterChangeCalculator/entry';
-import { aquariumFilterTurnoverStockingPlanner } from './tool/aquariumFilterTurnoverStockingPlanner/entry';
-import { aquariumLightingPhotoperiodPlanner } from './tool/aquariumLightingPhotoperiodPlanner/entry';
-import { aquariumEvaporationTopOffPlanner } from './tool/aquariumEvaporationTopOffPlanner/entry';
-import { aquariumSaltDosingCalculator } from './tool/aquariumSaltDosingCalculator/entry';
-import { aquariumCalciumAlkalinityDosingCalculator } from './tool/aquariumCalciumAlkalinityDosingCalculator/entry';
+import { AQUARIUM_CALCIUM_ALKALINITY_DOSING_CALCULATOR_TOOL } from './tool/aquariumCalciumAlkalinityDosingCalculator/index';
+import { AQUARIUM_EVAPORATION_TOP_OFF_PLANNER_TOOL } from './tool/aquariumEvaporationTopOffPlanner/index';
+import { AQUARIUM_FILTER_TURNOVER_STOCKING_PLANNER_TOOL } from './tool/aquariumFilterTurnoverStockingPlanner/index';
+import { AQUARIUM_LIGHTING_PHOTOPERIOD_PLANNER_TOOL } from './tool/aquariumLightingPhotoperiodPlanner/index';
+import { AQUARIUM_NITRATE_DILUTION_CALCULATOR_TOOL } from './tool/aquariumNitrateDilutionCalculator/index';
+import { AQUARIUM_SALT_DOSING_CALCULATOR_TOOL } from './tool/aquariumSaltDosingCalculator/index';
+import { AQUARIUM_TANK_VOLUME_WATER_CHANGE_CALCULATOR_TOOL } from './tool/aquariumTankVolumeWaterChangeCalculator/index';
 
-export const ALL_TOOLS = [{
-  entry: aquariumTankVolumeWaterChangeCalculator,
-  Component: () => import('./tool/aquariumTankVolumeWaterChangeCalculator/component.astro'),
-  SEOComponent: () => import('./tool/aquariumTankVolumeWaterChangeCalculator/seo.astro'),
-  BibliographyComponent: () => import('./tool/aquariumTankVolumeWaterChangeCalculator/bibliography.astro'),
-}, {
-  entry: aquariumFilterTurnoverStockingPlanner,
-  Component: () => import('./tool/aquariumFilterTurnoverStockingPlanner/component.astro'),
-  SEOComponent: () => import('./tool/aquariumFilterTurnoverStockingPlanner/seo.astro'),
-  BibliographyComponent: () => import('./tool/aquariumFilterTurnoverStockingPlanner/bibliography.astro'),
-}, {
-  entry: aquariumLightingPhotoperiodPlanner,
-  Component: () => import('./tool/aquariumLightingPhotoperiodPlanner/component.astro'),
-  SEOComponent: () => import('./tool/aquariumLightingPhotoperiodPlanner/seo.astro'),
-  BibliographyComponent: () => import('./tool/aquariumLightingPhotoperiodPlanner/bibliography.astro'),
-}, {
-  entry: aquariumEvaporationTopOffPlanner,
-  Component: () => import('./tool/aquariumEvaporationTopOffPlanner/component.astro'),
-  SEOComponent: () => import('./tool/aquariumEvaporationTopOffPlanner/seo.astro'),
-  BibliographyComponent: () => import('./tool/aquariumEvaporationTopOffPlanner/bibliography.astro'),
-}, {
-  entry: aquariumSaltDosingCalculator,
-  Component: () => import('./tool/aquariumSaltDosingCalculator/component.astro'),
-  SEOComponent: () => import('./tool/aquariumSaltDosingCalculator/seo.astro'),
-  BibliographyComponent: () => import('./tool/aquariumSaltDosingCalculator/bibliography.astro'),
-}, {
-  entry: aquariumCalciumAlkalinityDosingCalculator,
-  Component: () => import('./tool/aquariumCalciumAlkalinityDosingCalculator/component.astro'),
-  SEOComponent: () => import('./tool/aquariumCalciumAlkalinityDosingCalculator/seo.astro'),
-  BibliographyComponent: () => import('./tool/aquariumCalciumAlkalinityDosingCalculator/bibliography.astro'),
-}];
+export const ALL_TOOLS = [
+  AQUARIUM_CALCIUM_ALKALINITY_DOSING_CALCULATOR_TOOL,
+  AQUARIUM_EVAPORATION_TOP_OFF_PLANNER_TOOL,
+  AQUARIUM_FILTER_TURNOVER_STOCKING_PLANNER_TOOL,
+  AQUARIUM_LIGHTING_PHOTOPERIOD_PLANNER_TOOL,
+  AQUARIUM_NITRATE_DILUTION_CALCULATOR_TOOL,
+  AQUARIUM_SALT_DOSING_CALCULATOR_TOOL,
+  AQUARIUM_TANK_VOLUME_WATER_CHANGE_CALCULATOR_TOOL,
+];