@jjlmoya/utils-nature 1.20.0 → 1.22.0

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

@@ -0,0 +1,162 @@
+import type { CompostBinVolumeRatioCalculatorUI } from "./ui";
+import type {
+  CompostInputs,
+  CompostResult,
+  MoistureLevel,
+  UnitSystem,
+} from "./logic";
+import { getDiagnostics } from "./evaluator";
+
+function number(value: number, maximumFractionDigits = 1): string {
+  return new Intl.NumberFormat("en-US", { maximumFractionDigits }).format(
+    value,
+  );
+}
+
+function unitLabels(
+  unitSystem: UnitSystem,
+  ui: CompostBinVolumeRatioCalculatorUI,
+): { volume: string; dimension: string } {
+  return unitSystem === "metric"
+    ? { volume: ui.volumeUnitLiters, dimension: ui.dimensionUnitCm }
+    : { volume: ui.volumeUnitGallons, dimension: ui.dimensionUnitIn };
+}
+
+function displayVolume(valueLiters: number, unitSystem: UnitSystem): number {
+  return unitSystem === "imperial" ? valueLiters / 3.785411784 : valueLiters;
+}
+
+function moistureLabel(
+  level: MoistureLevel,
+  ui: CompostBinVolumeRatioCalculatorUI,
+): string {
+  if (level === "dry") return ui.moistureAdviceDry;
+  if (level === "wet") return ui.moistureAdviceWet;
+  return ui.moistureAdviceSponge;
+}
+
+function statusLabel(
+  key: string,
+  ui: CompostBinVolumeRatioCalculatorUI,
+): string {
+  const labels: Record<string, string> = {
+    balanced: ui.statusBalanced,
+    "too-green": ui.statusTooGreen,
+    "too-brown": ui.statusTooBrown,
+    "no-greens": ui.statusNoGreens,
+    overfilled: ui.statusOverfilled,
+    dry: ui.statusDry,
+    wet: ui.statusWet,
+  };
+  return labels[key] ?? ui.statusGoodMoisture;
+}
+
+function layerMarkup(result: CompostResult): string {
+  const total = result.materialsLiters;
+  if (total <= 0)
+    return '<text class="compost-scene-empty" x="300" y="218">Add materials to build the pile</text>';
+  const brownShare =
+    result.ratio === null ? 0.5 : result.ratio / (result.ratio + 1);
+  const layers = 8;
+  const bottom = 358;
+  const layerHeight = 34;
+  return Array.from({ length: layers }, (_, index) => {
+    const y = bottom - (index + 1) * layerHeight;
+    const isBrown = index / layers < brownShare;
+    const className = isBrown
+      ? "compost-layer compost-layer-brown"
+      : "compost-layer compost-layer-green";
+    const opacity = Math.max(0.35, 1 - Math.abs(index - 4) * 0.06);
+    return `<rect class="${className}" x="164" y="${y}" width="272" height="${layerHeight + 1}" opacity="${opacity.toFixed(2)}" />`;
+  }).join("");
+}
+
+function sceneMarkup(
+  inputs: CompostInputs,
+  result: CompostResult,
+  ui: CompostBinVolumeRatioCalculatorUI,
+): string {
+  const fill = Math.min(100, Math.max(0, result.fillPercent));
+  const fillHeight = 312 * (fill / 100);
+  const fillY = 358 - fillHeight;
+  const shapeLabel =
+    inputs.shape === "rectangular" ? ui.shapeRectangular : ui.shapeCylindrical;
+  return `<div class="compost-scene-heading"><span>${ui.sceneTitle}</span><strong>${shapeLabel}</strong></div><svg class="compost-scene-svg" viewBox="0 0 600 420" role="img" aria-label="${ui.sceneTitle}"><path class="compost-scene-sun" d="M76 80c46-48 115-48 162 0" /><path class="compost-scene-ground" d="M42 370c112-23 197-14 282 0 89 15 171 14 234-6" /><rect class="compost-bin" x="145" y="42" width="310" height="328" rx="26" /><clipPath id="compost-clip"><rect x="164" y="58" width="272" height="300" rx="17" /></clipPath><g clip-path="url(#compost-clip)"><rect class="compost-fill" x="164" y="${fillY.toFixed(1)}" width="272" height="${fillHeight.toFixed(1)}" /><g>${layerMarkup(result)}</g></g><path class="compost-scene-rim" d="M164 58h272" /><path class="compost-scene-marker" d="M478 358h31M478 58h31M494 358V58" /><text class="compost-scene-scale" x="519" y="214">${number(displayVolume(result.capacityLiters, inputs.unitSystem))} ${unitLabels(inputs.unitSystem, ui).volume}</text><text class="compost-scene-scale" x="519" y="232">${number(result.fillPercent, 0)}% full</text><text class="compost-scene-label compost-scene-label-brown" x="87" y="156">${ui.brownLabel}</text><text class="compost-scene-label compost-scene-label-green" x="87" y="176">${ui.greenLabel}</text></svg>`;
+}
+
+function actionText(
+  inputs: CompostInputs,
+  result: CompostResult,
+  ui: CompostBinVolumeRatioCalculatorUI,
+): string {
+  const ratioText =
+    result.ratio === null ? ui.statusNoGreens : `${number(result.ratio, 2)}:1`;
+  const moistureText = moistureLabel(inputs.moisture, ui);
+  let tone = "caution";
+  if (result.status === "balanced") tone = "good";
+  if (result.status === "overfilled") tone = "alert";
+  const airText =
+    result.status === "overfilled" ? ui.statusOverfilled : ui.statusNote;
+  return `<div class="compost-result-status" data-tone="${tone}"><span>${statusLabel(result.status, ui)}</span><strong>${ratioText}</strong></div><div class="compost-result-advice"><p><b>${ui.brownTarget}</b> ${number(displayVolume(result.targetBrownLowLiters, inputs.unitSystem))} to ${number(displayVolume(result.targetBrownHighLiters, inputs.unitSystem))} ${unitLabels(inputs.unitSystem, ui).volume}</p><p><b>${ui.waterAction}</b> ${moistureText}</p><p><b>${ui.airAction}</b> ${airText}</p></div>`;
+}
+
+export function renderCompost(
+  root: HTMLElement,
+  inputs: CompostInputs,
+  result: CompostResult,
+  ui: CompostBinVolumeRatioCalculatorUI,
+): void {
+  const labels = unitLabels(inputs.unitSystem, ui);
+  const scene = root.querySelector<HTMLElement>("[data-compost-scene]");
+  const results = root.querySelector<HTMLElement>("[data-compost-results]");
+  const diagnostics = getDiagnostics(result);
+  if (scene) scene.innerHTML = sceneMarkup(inputs, result, ui);
+  if (results) {
+    results.innerHTML = `<div class="compost-result-eyebrow">${ui.resultCapacity}</div><div class="compost-result-capacity">${number(displayVolume(result.capacityLiters, inputs.unitSystem))} <span>${labels.volume}</span></div><div class="compost-result-stats"><div><span>${ui.resultMaterials}</span><strong>${number(displayVolume(result.materialsLiters, inputs.unitSystem))} ${labels.volume}</strong></div><div><span>${ui.resultRatio}</span><strong>${result.ratio === null ? "..." : `${number(result.ratio, 2)}:1`}</strong></div><div><span>${ui.resultFill}</span><strong>${number(result.fillPercent, 0)}%</strong></div></div>${actionText(inputs, result, ui)}<div class="compost-result-diagnostics">${diagnostics.map((item) => `<span data-tone="${item.tone}">${statusLabel(item.key, ui)}</span>`).join("")}</div>`;
+  }
+}
+
+export function syncInputLabels(
+  root: HTMLElement,
+  inputs: CompostInputs,
+  ui: CompostBinVolumeRatioCalculatorUI,
+): void {
+  const labels = unitLabels(inputs.unitSystem, ui);
+  syncUnitText(root, labels);
+  syncPressedStates(root, inputs);
+}
+
+function syncUnitText(
+  root: HTMLElement,
+  labels: { volume: string; dimension: string },
+): void {
+  root
+    .querySelectorAll<HTMLElement>("[data-dimension-unit]")
+    .forEach((node) => {
+      node.textContent = labels.dimension;
+    });
+  root.querySelectorAll<HTMLElement>("[data-volume-unit]").forEach((node) => {
+    node.textContent = labels.volume;
+  });
+}
+
+function syncPressedStates(root: HTMLElement, inputs: CompostInputs): void {
+  root
+    .querySelector<HTMLElement>("[data-unit-metric]")
+    ?.toggleAttribute("aria-pressed", inputs.unitSystem === "metric");
+  root
+    .querySelector<HTMLElement>("[data-unit-imperial]")
+    ?.toggleAttribute("aria-pressed", inputs.unitSystem === "imperial");
+  root
+    .querySelector<HTMLElement>("[data-shape-rectangular]")
+    ?.toggleAttribute("aria-pressed", inputs.shape === "rectangular");
+  root
+    .querySelector<HTMLElement>("[data-shape-cylindrical]")
+    ?.toggleAttribute("aria-pressed", inputs.shape === "cylindrical");
+  root.querySelectorAll<HTMLElement>("[data-moisture]").forEach((node) => {
+    node.toggleAttribute(
+      "aria-pressed",
+      node.dataset.moisture === inputs.moisture,
+    );
+  });
+}

package/src/tool/compostBinVolumeRatioCalculator/entry.ts

@@ -0,0 +1,28 @@
+import type { NatureToolEntry, ToolLocaleContent } from "../../types";
+import type { CompostBinVolumeRatioCalculatorUI } from "./ui";
+
+export type CompostBinVolumeRatioCalculatorLocaleContent =
+  ToolLocaleContent<CompostBinVolumeRatioCalculatorUI>;
+
+export const compostBinVolumeRatioCalculator: NatureToolEntry<CompostBinVolumeRatioCalculatorUI> =
+  {
+    id: "compost-bin-volume-ratio-calculator",
+    icons: { bg: "mdi:compost", fg: "mdi:leaf" },
+    i18n: {
+      de: async () => (await import("./i18n/de")).content,
+      en: async () => (await import("./i18n/en")).content,
+      es: async () => (await import("./i18n/es")).content,
+      fr: async () => (await import("./i18n/fr")).content,
+      id: async () => (await import("./i18n/id")).content,
+      it: async () => (await import("./i18n/it")).content,
+      ja: async () => (await import("./i18n/ja")).content,
+      ko: async () => (await import("./i18n/ko")).content,
+      nl: async () => (await import("./i18n/nl")).content,
+      pl: async () => (await import("./i18n/pl")).content,
+      pt: async () => (await import("./i18n/pt")).content,
+      ru: async () => (await import("./i18n/ru")).content,
+      sv: async () => (await import("./i18n/sv")).content,
+      tr: async () => (await import("./i18n/tr")).content,
+      zh: async () => (await import("./i18n/zh")).content,
+    },
+  };

package/src/tool/compostBinVolumeRatioCalculator/evaluator.ts

@@ -0,0 +1,26 @@
+import type { CompostResult } from "./logic";
+
+export type DiagnosticTone = "good" | "caution" | "alert";
+
+export interface CompostDiagnostic {
+  key: string;
+  tone: DiagnosticTone;
+}
+
+export function getDiagnostics(result: CompostResult): CompostDiagnostic[] {
+  const diagnostics: CompostDiagnostic[] = [
+    {
+      key: result.status,
+      tone: result.status === "balanced" ? "good" : "caution",
+    },
+  ];
+  if (result.moistureStatus !== "good") {
+    diagnostics.push({
+      key: result.moistureStatus,
+      tone: result.moistureStatus === "dry" ? "caution" : "alert",
+    });
+  }
+  if (result.status === "overfilled")
+    diagnostics[0] = { key: result.status, tone: "alert" };
+  return diagnostics;
+}

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

@@ -0,0 +1,193 @@
+import type {
+  FAQPage,
+  HowTo,
+  SoftwareApplication,
+  WithContext,
+} from "schema-dts";
+import { bibliography } from "../bibliography";
+import type { CompostBinVolumeRatioCalculatorLocaleContent } from "../entry";
+
+const slug = "komposter-volumen-braun-gruen-verhaeltnis-rechner";
+const title = "Komposter Volumen und Braun Grün Verhältnis Rechner";
+const description =
+  "Berechnen Sie das Innenvolumen eines rechteckigen oder zylindrischen Komposters und prüfen Sie das praktische Verhältnis von Braunstoffen, Grünstoffen, Feuchtigkeit und Belüftung.";
+
+const faq = [
+  {
+    question: "Wie berechnet man das Volumen eines Komposters?",
+    answer:
+      "Messen Sie den Innenraum des Behälters. Bei einem rechteckigen Komposter multiplizieren Sie Breite, Tiefe und Höhe und rechnen Kubikzentimeter in Liter um. Bei einem Zylinder nutzen Sie Pi mal Radius zum Quadrat mal Höhe.",
+  },
+  {
+    question: "Was ist das richtige Verhältnis von Braunstoffen zu Grünstoffen?",
+    answer:
+      "Ein praktischer Richtwert sind zwei bis drei Teile kohlenstoffreiche Braunstoffe nach Volumen auf einen Teil stickstoffreiche Grünstoffe. Passen Sie die Mischung an Feuchtigkeit, Geruch und Durchlüftung an.",
+  },
+  {
+    question: "Wie viel Kompost passt in den Behälter?",
+    answer:
+      "Vergleichen Sie das Gesamtvolumen Ihres Kompostguts mit dem Innenvolumen des Komposters. Lassen Sie stets ausreichend Raum für Belüftung und das regelmäßige Umschichten des Haufens.",
+  },
+  {
+    question: "Was bedeutet die Feuchtigkeit eines ausgedrückten Schwamms?",
+    answer:
+      "Das Material sollte sich durchgehend feucht anfühlen, ohne bei leichtem Druck Wasser abzugeben. Trockener Kompost stoppt die mikrobielle Zersetzung, während zu nasser Kompost Luftlöcher verliert.",
+  },
+];
+
+const howTo = [
+  {
+    name: "Form des Komposters wählen",
+    text: "Wählen Sie rechteckig oder zylindrisch und geben Sie die Innenmaße in Zentimetern oder Zoll präzise ein.",
+  },
+  {
+    name: "Materialvolumen eingeben",
+    text: "Schätzen Sie das getrennte Volumen von braunen kohlenstoffreichen und grünen stickstoffreichen Abfällen ab.",
+  },
+  {
+    name: "Feuchtigkeitsstufe einstellen",
+    text: "Wählen Sie trocken, ausgedrückter Schwamm oder nass für passende Pflegetipps und Wartungshinweise.",
+  },
+  {
+    name: "Ergebnis auswerten",
+    text: "Nutzen Sie Kapazität, Füllstand und Mischungsverhältnis zur Anpassung von Belüftung, Materialzugabe und Feuchte.",
+  },
+];
+
+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: "EUR" },
+  inLanguage: "de",
+};
+
+export const content: CompostBinVolumeRatioCalculatorLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    unitMetric: "Metrisch",
+    unitImperial: "Imperial",
+    shapeTitle: "Komposterform",
+    shapeRectangular: "Rechteckig",
+    shapeCylindrical: "Zylindrisch",
+    widthLabel: "Innenbreite",
+    depthLabel: "Innentiefe",
+    diameterLabel: "Innendurchmesser",
+    heightLabel: "Innenhöhe",
+    brownLabel: "Braunstoffe",
+    greenLabel: "Grünstoffe",
+    moistureTitle: "Feuchtigkeitsgefühl",
+    moistureDry: "Trocken",
+    moistureSponge: "Ausgedrückter Schwamm",
+    moistureWet: "Nass",
+    moistureAdviceDry: "Trocken: Schrittweise befeuchten und umschichten.",
+    moistureAdviceSponge: "Optimal: Feuchte wie ein ausgedrückter Schwamm halten.",
+    moistureAdviceWet: "Nass: Trockenes Braunmaterial zugeben und wenden.",
+    recipeTitle: "Empfohlene Mischung",
+    recipeKitchen: "Küchenabfälle",
+    recipeGarden: "Gartenabfälle",
+    recipeLeafy: "Laubmischung",
+    sceneTitle: "Schnitt durch den Komposthaufen",
+    resultCapacity: "Innenvolumen des Komposters",
+    resultMaterials: "Eingegebenes Material",
+    resultRatio: "Verhältnis Braun zu Grün",
+    resultFill: "Ausgenutzte Kapazität",
+    brownTarget: "Zielmenge Braunstoffe",
+    waterAction: "Feuchtigkeit",
+    airAction: "Luft und Struktur",
+    statusBalanced: "Gutes Startverhältnis",
+    statusTooGreen: "Mehr Braunstoffe zugeben",
+    statusTooBrown: "Mehr Grünstoffe zugeben",
+    statusNoGreens: "Grünstoffe hinzufügen",
+    statusOverfilled: "Komposter ist überfüllt",
+    statusDry: "Haufen ist zu trocken",
+    statusWet: "Haufen ist zu nass",
+    statusGoodMoisture: "Feuchtigkeit im optimalen Bereich",
+    statusNote: "Haufen regelmäßig umschichten für Belüftung.",
+    volumeUnitLiters: "L",
+    volumeUnitGallons: "gal",
+    dimensionUnitCm: "cm",
+    dimensionUnitIn: "in",
+    formulaTitle: "Geometrische Volumenberechnung",
+    formulaText:
+      "Der Rechner ermittelt die echte Innenkapazität aus Ihren Abmessungen. Rechteckige Behälter nutzen Breite × Tiefe × Höhe. Zylindrische Behälter nutzen π × Radius² × Höhe. Alle Volumen werden auf dieselbe Einheit umgerechnet, bevor der Füllstand angezeigt wird.",
+    practicalTitle: "Das Verhältnis ist ein Orientierungswert",
+    practicalText:
+      "Das Braunstoff-Ziel nutzt das Zwei- bis Dreifache des Grünstoffvolumens. Feuchtigkeit und Struktur sind ebenso wichtig: streben Sie ein Schwammgefühl an, erhalten Sie grobe Materialstrukturen und wenden Sie den Haufen bei Verdichtung.",
+    localNote:
+      "Alle Berechnungen finden lokal im Browser statt. Dies ist eine praktische Planungshilfe für Garten und Kompostierung im Haushalt.",
+    resetLabel: "Zurücksetzen",
+  },
+  seo: [
+    {
+      type: "title",
+      text: "Berechnen Sie das echte Volumen Ihres Komposters",
+      level: 2,
+    },
+    {
+      type: "paragraph",
+      html: "Ein Komposter-Volumenrechner hilft besonders dann zuverlässig, wenn er auf den tatsächlichen Innenmaßen basiert und nicht auf den äußeren Herstellerangaben. Geben Sie die Breite, Tiefe und Höhe eines rechteckigen Komposters oder den Durchmesser und die Höhe eines zylindrischen Modells ein. Das Ergebnis zeigt die verbleibende Nettokapazität in Litern oder Gallonen und vergleicht diese direkt mit der Menge der geplanten Abfälle.",
+    },
+    { type: "title", text: "Mathematische Formeln zur Volumenberechnung", level: 3 },
+    {
+      type: "paragraph",
+      html: "Für rechteckige Komposter gilt die geometrische Formel <code>Breite × Tiefe × Höhe</code>. Wenn Sie die Messungen in Zentimetern durchführen, teilen Sie das Ergebnis in Kubikzentimetern durch 1.000, um das korrekte Volumen in Litern zu erhalten. Für zylindrische Behälter nutzen Sie <code>π × Radius² × Höhe</code>, wobei der Radius der Hälfte des Innendurchmessers entspricht. Messen Sie nur den nutzbaren Innenraum ohne Wandstärken oder Deckel.",
+    },
+    {
+      type: "list",
+      items: [
+        "<strong>Rechteckiger Behälter:</strong> Breite × Tiefe × Höhe.",
+        "<strong>Zylindrischer Behälter:</strong> π × Radius² × Höhe.",
+        "<strong>Volumenumrechnung:</strong> 1.000 Kubikzentimeter entsprechen exakt 1 Liter.",
+        "<strong>Füllstandsanzeige:</strong> Summe aus Braun- und Grünvolumen im Vergleich zur maximalen Innenkapazität.",
+      ],
+    },
+    { type: "title", text: "Ausgewogenes Verhältnis zwischen Braunstoffen und Grünstoffen", level: 3 },
+    {
+      type: "paragraph",
+      html: "Als bewährter Praxiswert gilt ein Mischungsverhältnis von zwei bis drei Teilen braunen kohlenstoffreichen Materialien auf einen Teil grüner stickstoffreicher Abfälle nach Volumen. Zu den Braunstoffen zählen trockenes Laub, zerkleinerter Karton und kleine Zweige. Grünstoffe umfassen frische Küchenabfälle, Rasenschnitt und Pflanzenteile. Der Rechner gibt den Zielbereich für Braunstoffe an, während die Feuchtigkeit und Durchlüftung den Zersetzungsprozess unterstützen.",
+    },
+    { type: "title", text: "Feuchtigkeit und Belüftung richtig steuern", level: 3 },
+    {
+      type: "paragraph",
+      html: "Achten Sie auf die Konsistenz eines feuchten, gut ausgedrückten Schwamms. Zu trockener Kompost verlangsamt die biologische Aktivität der Mikroorganismen erheblich, während ein durchnässter Haufen an Sauerstoff verliert und unangenehme Gerüche entwickeln kann. Durch regelmäßiges Umschichten bringen Sie frischen Sauerstoff in den Komposthaufen.",
+    },
+    {
+      type: "tip",
+      title: "Praktischer Nutzungshinweis",
+      html: "Dieses Volumenergebnis dient als nützlicher Richtwert für die Gartenpraxis und ersetzt keine chemische Laboranalyse des C:N-Verhältnisses. Beachten Sie stets die lokalen Vorgaben zur Eigenkompostierung.",
+    },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, howToSchema, appSchema],
+};

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

@@ -0,0 +1,193 @@
+import type {
+  FAQPage,
+  HowTo,
+  SoftwareApplication,
+  WithContext,
+} from "schema-dts";
+import { bibliography } from "../bibliography";
+import type { CompostBinVolumeRatioCalculatorLocaleContent } from "../entry";
+
+const slug = "compost-bin-volume-and-browns-greens-ratio-calculator";
+const title = "Compost Bin Volume and Browns Greens Ratio Calculator";
+const description =
+  "Calculate the internal volume of a rectangular or cylindrical compost bin and check the practical balance of browns, greens, moisture, and air.";
+
+const faq = [
+  {
+    question: "How do I calculate compost bin volume?",
+    answer:
+      "Measure the inside of the bin. For a rectangular bin, multiply width by depth by height and convert cubic centimeters to liters. For a cylinder, use pi times the radius squared times height.",
+  },
+  {
+    question: "What is the right ratio of browns to greens in compost?",
+    answer:
+      "A practical starting point is two to three parts carbon rich browns by volume for each part nitrogen rich greens. Adjust by observing moisture, smell, and airflow rather than treating the ratio as a laboratory measurement.",
+  },
+  {
+    question: "How much compost can I put in the bin?",
+    answer:
+      "Compare the volume of your materials with the bin capacity. Leave room for air and turning, and do not pack the contents tightly just to reach the rim.",
+  },
+  {
+    question: "What does wrung out sponge moisture mean?",
+    answer:
+      "The materials should feel damp without releasing water when squeezed. A dry pile slows down, while a saturated pile needs more dry structure and turning for airflow.",
+  },
+];
+
+const howTo = [
+  {
+    name: "Choose the bin shape",
+    text: "Select rectangular or cylindrical and enter the inside dimensions in centimeters or inches.",
+  },
+  {
+    name: "Add your material volumes",
+    text: "Estimate the separate volume of brown carbon rich materials and green nitrogen rich materials.",
+  },
+  {
+    name: "Set the moisture feel",
+    text: "Choose dry, wrung out sponge, or wet to make the maintenance advice match the pile you are preparing.",
+  },
+  {
+    name: "Read the pile",
+    text: "Use the capacity, fill level, ratio, and warnings to decide whether to add browns, add moisture, or turn the pile.",
+  },
+];
+
+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: "EUR" },
+  inLanguage: "en",
+};
+
+export const content: CompostBinVolumeRatioCalculatorLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    unitMetric: "Metric",
+    unitImperial: "Imperial",
+    shapeTitle: "Bin shape",
+    shapeRectangular: "Rectangular",
+    shapeCylindrical: "Cylindrical",
+    widthLabel: "Inside width",
+    depthLabel: "Inside depth",
+    diameterLabel: "Inside diameter",
+    heightLabel: "Inside height",
+    brownLabel: "Browns",
+    greenLabel: "Greens",
+    moistureTitle: "Moisture feel",
+    moistureDry: "Dry",
+    moistureSponge: "Wringed sponge",
+    moistureWet: "Wet",
+    moistureAdviceDry: "Dry: moisten gradually and turn.",
+    moistureAdviceSponge: "Good: keep the wrung out sponge feel.",
+    moistureAdviceWet: "Wet: add dry browns and turn.",
+    recipeTitle: "Add what you have",
+    recipeKitchen: "Kitchen caddy",
+    recipeGarden: "Garden batch",
+    recipeLeafy: "Leafy pile",
+    sceneTitle: "Your pile in section",
+    resultCapacity: "Internal bin capacity",
+    resultMaterials: "Materials entered",
+    resultRatio: "Browns to greens",
+    resultFill: "Capacity used",
+    brownTarget: "Brown target",
+    waterAction: "Moisture",
+    airAction: "Air and structure",
+    statusBalanced: "Good starting balance",
+    statusTooGreen: "Add more browns",
+    statusTooBrown: "Add more greens",
+    statusNoGreens: "Add some greens",
+    statusOverfilled: "Pile is over capacity",
+    statusDry: "Pile feels dry",
+    statusWet: "Pile feels too wet",
+    statusGoodMoisture: "Moisture is in range",
+    statusNote: "Turn the pile to reopen air pockets.",
+    volumeUnitLiters: "L",
+    volumeUnitGallons: "gal",
+    dimensionUnitCm: "cm",
+    dimensionUnitIn: "in",
+    formulaTitle: "The volume behind the drawing",
+    formulaText:
+      "The calculator finds internal capacity from your inside measurements. Rectangular bins use width × depth × height. Cylindrical bins use π × radius² × height. Material volumes are converted to the same unit before the fill level is shown.",
+    practicalTitle: "A ratio is a starting point",
+    practicalText:
+      "The brown target uses two to three times the green volume. Moisture and air still matter: aim for a wrung out sponge feel, keep bulky structure in the mix, and turn the pile when it settles.",
+    localNote:
+      "All measurements stay in this browser. This is a planning aid, not a laboratory C:N analysis.",
+    resetLabel: "Reset",
+  },
+  seo: [
+    {
+      type: "title",
+      text: "Calculate the Real Capacity of a Compost Bin",
+      level: 2,
+    },
+    {
+      type: "paragraph",
+      html: "A compost bin volume calculator is most useful when it works from the inside measurements, not the label on the product. Enter the width, depth, and height of a rectangular bin, or the diameter and height of a cylindrical one. The result shows the internal capacity in liters or gallons and compares it with the material volume you plan to add.",
+    },
+    { type: "title", text: "Compost Bin Volume Formulas", level: 3 },
+    {
+      type: "paragraph",
+      html: "For a rectangular bin, use <code>width × depth × height</code>. If the measurements are in centimeters, divide the cubic centimeter result by 1,000 to get liters. For a cylindrical bin, use <code>π × radius² × height</code>, where radius is half the inside diameter. Measure the clear space inside the bin and do not count thick walls, legs, or a lid.",
+    },
+    {
+      type: "list",
+      items: [
+        "<strong>Rectangular:</strong> width × depth × height.",
+        "<strong>Cylindrical:</strong> π × radius² × height.",
+        "<strong>Liters:</strong> 1,000 cubic centimeters.",
+        "<strong>Fill level:</strong> brown volume plus green volume compared with internal capacity.",
+      ],
+    },
+    { type: "title", text: "How Much Browns and Greens to Add", level: 3 },
+    {
+      type: "paragraph",
+      html: "Use two to three parts browns for each part greens by volume as a practical starting point. Browns include dry leaves, shredded cardboard, and small woody material. Greens include food scraps, fresh grass, and other nitrogen rich material. The calculator reports the target brown range, but the pile itself supplies the final feedback through moisture, smell, heat, and airflow.",
+    },
+    { type: "title", text: "Read the Moisture and Air Warnings", level: 3 },
+    {
+      type: "paragraph",
+      html: "A pile that feels dry may decompose slowly, while a saturated pile can lose air spaces and develop unpleasant odors. Aim for a wrung out sponge feel. If the pile is wet, add dry bulky browns and turn it. If it is dry, moisten it gradually while turning so the water spreads through the material.",
+    },
+    {
+      type: "tip",
+      title: "Use the result as a check, not a prescription",
+      html: "The ratio is a volume guideline, not a measured carbon to nitrogen analysis. The calculator does not identify materials, measure temperature, assess contamination, or guarantee finished compost. Keep animal waste, treated wood, and other unsuitable materials out of a home pile according to local guidance.",
+    },
+  ],
+  faq,
+  bibliography,
+  howTo,
+  schemas: [faqSchema, howToSchema, appSchema],
+};