@jjlmoya/utils-nature 1.19.0 → 1.21.0

package/package.json

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

package/src/category/index.ts

@@ -3,10 +3,11 @@ import { cricketThermometer } from '../tool/cricketThermometer/entry';
 import { seedCalculator } from '../tool/seedCalculator/entry';
 import { rainHarvester } from '../tool/rainHarvester/entry';
 import { digitalCarbon } from '../tool/digitalCarbon/entry';
+import { urbanGardenPlanner } from '../tool/urbanGardenPlanner/entry';
 
 export const natureCategory: NatureCategoryEntry = {
   icon: 'mdi:leaf',
-  tools: [cricketThermometer, seedCalculator, rainHarvester, digitalCarbon],
+  tools: [cricketThermometer, seedCalculator, rainHarvester, digitalCarbon, urbanGardenPlanner],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     es: () => import('./i18n/es').then((m) => m.content),

package/src/entries.ts

@@ -6,9 +6,12 @@ export { rainHarvester } from './tool/rainHarvester/entry';
 export type { RainHarvesterLocaleContent } from './tool/rainHarvester/entry';
 export { seedCalculator } from './tool/seedCalculator/entry';
 export type { SeedCalculatorLocaleContent } from './tool/seedCalculator/entry';
+export { urbanGardenPlanner } from './tool/urbanGardenPlanner/entry';
+export type { UrbanGardenPlannerLocaleContent } from './tool/urbanGardenPlanner/entry';
 export { natureCategory } from './category';
 import { cricketThermometer } from './tool/cricketThermometer/entry';
 import { digitalCarbon } from './tool/digitalCarbon/entry';
 import { rainHarvester } from './tool/rainHarvester/entry';
 import { seedCalculator } from './tool/seedCalculator/entry';
-export const ALL_ENTRIES = [cricketThermometer, digitalCarbon, rainHarvester, seedCalculator];
+import { urbanGardenPlanner } from './tool/urbanGardenPlanner/entry';
+export const ALL_ENTRIES = [cricketThermometer, digitalCarbon, rainHarvester, seedCalculator, urbanGardenPlanner];

package/src/index.ts

@@ -24,3 +24,5 @@ export { SEED_CALCULATOR_TOOL, seedCalculator } from './tool/seedCalculator/inde
 export { RAIN_HARVESTER_TOOL, rainHarvester } from './tool/rainHarvester/index';
 
 export { DIGITAL_CARBON_TOOL, digitalCarbon } from './tool/digitalCarbon/index';
+
+export { URBAN_GARDEN_PLANNER_TOOL, urbanGardenPlanner } from './tool/urbanGardenPlanner/index';

package/src/tests/spanish_leakage.test.ts

@@ -28,6 +28,8 @@ const TRANSLATABLE_KEYS = [
   'schemas',
 ] as const;
 
+const COPY_THRESHOLD = 0.9;
+
 const SPANISH_MARKERS = [
   ['sangre', /\bsangre\b/gi],
   ['molino', /\bmolino\b/gi],
@@ -65,12 +67,16 @@ function normalize(value: string): string {
 }
 
 function isTechnicalInvariant(text: string): boolean {
+  const ledUnitMatches = text.match(/\b\d+(?:-\d+)?\s*(?:w|lm)\b/g) ?? [];
   return [
     'data:image/svg+xml;base64',
     'background-image: url',
     '.layout-playground {',
     'const samplerate =',
-  ].some((pattern) => text.includes(pattern)) || (text.includes('presets') && text.includes('hz'));
+  ].some((pattern) => text.includes(pattern)) ||
+    (text.includes('presets') && text.includes('hz')) ||
+    (text.includes('t_rectal') && text.includes('exp(-k * t)')) ||
+    (text.includes('led') && ledUnitMatches.length >= 3);
 }
 
 function collectString(value: string, output: string[]): void {
@@ -111,10 +117,26 @@ function findSpanishMarkers(text: string[]): string[] {
   );
 }
 
+function similarity(left: string, right: string): number {
+  const leftTokens = left.split(/\s+/);
+  const rightCounts = new Map<string, number>();
+  right.split(/\s+/).forEach((token) => rightCounts.set(token, (rightCounts.get(token) ?? 0) + 1));
+  const matches = leftTokens.reduce((total, token) => {
+    const count = rightCounts.get(token) ?? 0;
+    if (count > 0) rightCounts.set(token, count - 1);
+    return total + (count > 0 ? 1 : 0);
+  }, 0);
+  return (2 * matches) / (leftTokens.length + right.split(/\s+/).length);
+}
+
 function findCopiedFragments(spanish: string[], translated: string[]): string[] {
-  const corpus = translated.join(' ');
   return spanish
-    .filter((fragment) => fragment.length >= 80 && corpus.includes(fragment))
+    .filter((fragment) => fragment.length >= 80)
+    .filter((fragment) => translated.some((candidate) =>
+      candidate.length >= 80 &&
+      Math.min(fragment.length, candidate.length) / Math.max(fragment.length, candidate.length) >= COPY_THRESHOLD &&
+      similarity(fragment, candidate) >= COPY_THRESHOLD,
+    ))
     .sort((a, b) => b.length - a.length)
     .slice(0, 3);
 }

package/src/tests/tool_validation.test.ts

@@ -3,8 +3,8 @@ import { ALL_TOOLS, natureCategory } from '../index';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 4 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(4);
+    it('should have 5 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(5);
     });
 
     it('natureCategory should be defined', () => {
@@ -13,4 +13,3 @@ describe('Tool Validation Suite', () => {
     });
   });
 });
-

package/src/tool/urbanGardenPlanner/bibliography.astro

@@ -0,0 +1,9 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { urbanGardenPlanner } from './index';
+
+const { locale = 'en' } = Astro.props;
+const content = await urbanGardenPlanner.i18n[locale as keyof typeof urbanGardenPlanner.i18n]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/urbanGardenPlanner/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'RHS Urban gardening',
+    url: 'https://www.rhs.org.uk/advice/urban-gardening',
+  },
+  {
+    name: 'US EPA Rain barrels',
+    url: 'https://www.epa.gov/soakuptherain/soak-rain-rain-barrels',
+  },
+  {
+    name: 'FAO Water harvesting and soil moisture management',
+    url: 'https://www.fao.org/4/y4690e/y4690e00.htm',
+  },
+];

package/src/tool/urbanGardenPlanner/component.astro

@@ -0,0 +1,131 @@
+---
+import { Icon } from 'astro-icon/components';
+import { urbanGardenPlanner } from './index';
+import { DEFAULT_INPUTS } from './logic';
+
+const { ui: propUi, locale = 'en' } = Astro.props;
+let ui = propUi;
+
+if (!ui) {
+  const content = await urbanGardenPlanner.i18n[locale as keyof typeof urbanGardenPlanner.i18n]?.();
+  ui = content?.ui;
+}
+
+if (!ui) return null;
+
+const config = JSON.stringify({ ui, defaults: DEFAULT_INPUTS });
+---
+
+<urban-garden-planner class="ugrp-root">
+  <div class="ugrp-shell">
+    <section class="ugrp-input-panel" aria-labelledby="ugrp-input-heading">
+      <div class="ugrp-kicker">{ui.eyebrow}</div>
+      <h2 id="ugrp-input-heading" class="ugrp-heading">
+        <span class="ugrp-step">1</span>
+        {ui.headInputs}
+      </h2>
+
+      <div class="ugrp-fields">
+        <label class="ugrp-field" for="gardenArea">
+          <span class="ugrp-label"><Icon name="mdi:flower-outline" aria-hidden="true" />{ui.labelGardenArea}</span>
+          <span class="ugrp-input-line">
+            <input id="gardenArea" type="number" min="0" step="0.5" value={DEFAULT_INPUTS.gardenAreaM2} />
+            <span>{ui.unitSquareMeters}</span>
+          </span>
+          <span class="ugrp-help">{ui.helpGardenArea}</span>
+        </label>
+
+        <label class="ugrp-field" for="substrateDepth">
+          <span class="ugrp-label"><Icon name="mdi:layers-outline" aria-hidden="true" />{ui.labelDepth}</span>
+          <span class="ugrp-input-line">
+            <input id="substrateDepth" type="number" min="0" step="1" value={DEFAULT_INPUTS.substrateDepthCm} />
+            <span>{ui.unitCentimeters}</span>
+          </span>
+          <span class="ugrp-help">{ui.helpDepth}</span>
+        </label>
+
+        <label class="ugrp-field" for="collectionArea">
+          <span class="ugrp-label"><Icon name="mdi:home-roof" aria-hidden="true" />{ui.labelCollectionArea}</span>
+          <span class="ugrp-input-line">
+            <input id="collectionArea" type="number" min="0" step="0.5" value={DEFAULT_INPUTS.collectionAreaM2} />
+            <span>{ui.unitSquareMeters}</span>
+          </span>
+          <span class="ugrp-help">{ui.helpCollectionArea}</span>
+        </label>
+
+        <label class="ugrp-field" for="rainfall">
+          <span class="ugrp-label"><Icon name="mdi:weather-rainy" aria-hidden="true" />{ui.labelRainfall}</span>
+          <span class="ugrp-input-line">
+            <input id="rainfall" type="number" min="0" step="1" value={DEFAULT_INPUTS.rainfallMm} />
+            <span>{ui.unitMillimeters}</span>
+          </span>
+          <span class="ugrp-help">{ui.helpRainfall}</span>
+        </label>
+      </div>
+
+      <div class="ugrp-presets">
+        <div class="ugrp-subheading">{ui.presetsTitle}</div>
+        <div class="ugrp-preset-row">
+          <button type="button" class="ugrp-preset" data-preset="4,20,8,15">{ui.presetBalcony}</button>
+          <button type="button" class="ugrp-preset" data-preset="12,30,25,20">{ui.presetRaisedBed}</button>
+          <button type="button" class="ugrp-preset" data-preset="24,35,50,25">{ui.presetCommunity}</button>
+        </div>
+      </div>
+
+      <div class="ugrp-note ugrp-note-assumption">
+        <Icon name="mdi:calculator-variant-outline" aria-hidden="true" />
+        <div><strong>{ui.assumptionTitle}</strong><span>{ui.assumptionText}</span></div>
+      </div>
+    </section>
+
+    <section class="ugrp-result-panel" aria-labelledby="ugrp-scene-heading">
+      <div class="ugrp-result-topline">
+        <div>
+          <div class="ugrp-kicker">{ui.headScene}</div>
+          <h2 id="ugrp-scene-heading" class="ugrp-heading"><span class="ugrp-step ugrp-step-light">2</span>{ui.sceneGardenBed}</h2>
+        </div>
+        <div id="planStatus" class="ugrp-status" aria-live="polite">{ui.statusBalanced}</div>
+      </div>
+
+      <div class="ugrp-landscape" aria-label={ui.headScene} role="img">
+        <div id="rainDots" class="ugrp-rain-dots" aria-hidden="true"></div>
+        <div class="ugrp-cloud"><Icon name="mdi:weather-cloudy" aria-hidden="true" /></div>
+        <div class="ugrp-catchment"><span>{ui.sceneCatchment}</span><i></i></div>
+        <div class="ugrp-pipe"><i></i><b></b></div>
+        <div class="ugrp-bed">
+          <div class="ugrp-bed-frame"></div>
+          <div id="soilFill" class="ugrp-soil-fill" role="progressbar" aria-valuemin="0" aria-valuemax="100"></div>
+          <div class="ugrp-leaves"><Icon name="mdi:sprout" aria-hidden="true" /><Icon name="mdi:sprout" aria-hidden="true" /><Icon name="mdi:sprout" aria-hidden="true" /></div>
+          <span>{ui.sceneSoil}</span>
+        </div>
+        <div class="ugrp-water-vessel"><div id="waterFill" role="progressbar" aria-valuemin="0" aria-valuemax="100"></div><Icon name="mdi:water-outline" aria-hidden="true" /><span>{ui.sceneWater}</span></div>
+      </div>
+
+      <p id="planStatusNote" class="ugrp-status-note">{ui.statusNote}</p>
+
+      <div class="ugrp-metrics" aria-live="polite">
+        <div class="ugrp-metric ugrp-metric-main"><span>{ui.labelWaterCaptured}</span><strong id="waterValue">0 L</strong></div>
+        <div class="ugrp-metric"><span>{ui.labelSoilNeeded}</span><strong id="soilValue">0 L</strong></div>
+        <div class="ugrp-metric"><span>{ui.labelGardenDepth}</span><strong id="depthValue">0 mm</strong></div>
+        <div class="ugrp-metric"><span>{ui.labelWateringArea}</span><strong id="areaValue">0 m²</strong></div>
+      </div>
+
+      <div class="ugrp-note ugrp-note-limit">
+        <Icon name="mdi:leaf-circle-outline" aria-hidden="true" />
+        <div><strong>{ui.limitationTitle}</strong><span>{ui.limitationText}</span></div>
+      </div>
+    </section>
+  </div>
+</urban-garden-planner>
+
+<script is:inline type="application/json" id="ugrp-config" set:html={config}></script>
+
+<script>
+  import { mountUrbanGardenPlanner } from './controller';
+  const root = document.querySelector<HTMLElement>('urban-garden-planner');
+  const configNode = document.getElementById('ugrp-config');
+  if (root && configNode) {
+    const config = JSON.parse(configNode.textContent || '{}');
+    mountUrbanGardenPlanner(root, config);
+  }
+</script>

package/src/tool/urbanGardenPlanner/controller.ts

@@ -0,0 +1,88 @@
+import { evaluateGardenPlan } from './evaluator';
+import { calculateGardenPlan, DEFAULT_INPUTS, type GardenPlanInput } from './logic';
+import { findElements, renderGardenPlan, type GardenPlannerElements } from './dom-views';
+import { loadGardenPlan, saveGardenPlan } from './storage';
+import type { UrbanGardenPlannerUI } from './ui';
+
+export interface UrbanGardenPlannerConfig {
+  ui: UrbanGardenPlannerUI;
+  defaults: GardenPlanInput;
+}
+
+const inputKeys: (keyof GardenPlanInput)[] = [
+  'gardenAreaM2',
+  'substrateDepthCm',
+  'collectionAreaM2',
+  'rainfallMm',
+];
+
+class UrbanGardenPlannerController {
+  private readonly elements: GardenPlannerElements;
+  private readonly config: UrbanGardenPlannerConfig;
+
+  constructor(private readonly root: HTMLElement, config: UrbanGardenPlannerConfig) {
+    this.elements = findElements(root);
+    this.config = config;
+  }
+
+  mount(): void {
+    this.restoreInputs();
+    this.bindInputs();
+    this.bindPresets();
+    this.calculate();
+  }
+
+  private restoreInputs(): void {
+    const saved = loadGardenPlan();
+    const values = { ...DEFAULT_INPUTS, ...this.config.defaults, ...saved };
+    inputKeys.forEach((key) => {
+      const element = this.elements.inputs[key];
+      if (element) element.value = String(values[key]);
+    });
+  }
+
+  private bindInputs(): void {
+    inputKeys.forEach((key) => {
+      this.elements.inputs[key]?.addEventListener('input', () => this.calculate());
+    });
+  }
+
+  private bindPresets(): void {
+    this.root.querySelectorAll<HTMLButtonElement>('[data-preset]').forEach((button) => {
+      button.addEventListener('click', () => {
+        const values = button.dataset.preset?.split(',').map(Number) ?? [];
+        inputKeys.forEach((key, index) => {
+          const element = this.elements.inputs[key];
+          if (element && Number.isFinite(values[index])) element.value = String(values[index]);
+        });
+        this.calculate();
+      });
+    });
+  }
+
+  private readInputs(): GardenPlanInput {
+    return {
+      gardenAreaM2: Number(this.elements.inputs.gardenAreaM2?.value),
+      substrateDepthCm: Number(this.elements.inputs.substrateDepthCm?.value),
+      collectionAreaM2: Number(this.elements.inputs.collectionAreaM2?.value),
+      rainfallMm: Number(this.elements.inputs.rainfallMm?.value),
+    };
+  }
+
+  private calculate(): void {
+    const input = this.readInputs();
+    const result = calculateGardenPlan(input);
+    const assessment = evaluateGardenPlan(input, result);
+    saveGardenPlan(input);
+    renderGardenPlan(this.elements, result, assessment, this.config.ui);
+  }
+}
+
+export function mountUrbanGardenPlanner(
+  root: HTMLElement,
+  config: UrbanGardenPlannerConfig,
+): void {
+  if (root.dataset.mounted === 'true') return;
+  root.dataset.mounted = 'true';
+  new UrbanGardenPlannerController(root, config).mount();
+}

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

@@ -0,0 +1,84 @@
+import type { GardenPlanAssessment } from './evaluator';
+import type { GardenPlanResult } from './logic';
+import type { UrbanGardenPlannerUI } from './ui';
+
+export interface GardenPlannerElements {
+  root: HTMLElement;
+  inputs: Record<keyof GardenPlanResult, HTMLInputElement | null>;
+  soilValue: HTMLElement | null;
+  waterValue: HTMLElement | null;
+  depthValue: HTMLElement | null;
+  areaValue: HTMLElement | null;
+  status: HTMLElement | null;
+  statusNote: HTMLElement | null;
+  soilFill: HTMLElement | null;
+  waterFill: HTMLElement | null;
+  rainDots: HTMLElement | null;
+}
+
+export function findElements(root: HTMLElement): GardenPlannerElements {
+  const input = (id: string) => root.querySelector<HTMLInputElement>(id);
+  const output = (id: string) => root.querySelector<HTMLElement>(id);
+
+  return {
+    root,
+    inputs: {
+      gardenAreaM2: input('#gardenArea'),
+      substrateDepthCm: input('#substrateDepth'),
+      collectionAreaM2: input('#collectionArea'),
+      rainfallMm: input('#rainfall'),
+      soilVolumeLiters: null,
+      grossRainwaterLiters: null,
+      harvestedWaterLiters: null,
+      gardenWaterDepthMm: null,
+      wateringAreaAt10Mm: null,
+    },
+    soilValue: output('#soilValue'),
+    waterValue: output('#waterValue'),
+    depthValue: output('#depthValue'),
+    areaValue: output('#areaValue'),
+    status: output('#planStatus'),
+    statusNote: output('#planStatusNote'),
+    soilFill: output('#soilFill'),
+    waterFill: output('#waterFill'),
+    rainDots: output('#rainDots'),
+  };
+}
+
+export function formatNumber(value: number, maximumFractionDigits = 0): string {
+  return new Intl.NumberFormat('en', { maximumFractionDigits }).format(value);
+}
+
+function setText(element: HTMLElement | null, text: string): void {
+  if (element) element.textContent = text;
+}
+
+function statusLabel(ui: UrbanGardenPlannerUI, assessment: GardenPlanAssessment): string {
+  const labels = {
+    balanced: ui.statusBalanced,
+    lightCapture: ui.statusLightCapture,
+    deepBed: ui.statusDeepBed,
+    noRain: ui.statusNoRain,
+  };
+  return labels[assessment.status];
+}
+
+export function renderGardenPlan(
+  elements: GardenPlannerElements,
+  result: GardenPlanResult,
+  assessment: GardenPlanAssessment,
+  ui: UrbanGardenPlannerUI,
+): void {
+  setText(elements.soilValue, `${formatNumber(result.soilVolumeLiters)} L`);
+  setText(elements.waterValue, `${formatNumber(result.harvestedWaterLiters, 1)} L`);
+  setText(elements.depthValue, `${formatNumber(result.gardenWaterDepthMm, 1)} mm`);
+  setText(elements.areaValue, `${formatNumber(result.wateringAreaAt10Mm, 1)} m²`);
+  setText(elements.status, statusLabel(ui, assessment));
+  setText(elements.statusNote, ui.statusNote);
+  elements.root.dataset.status = assessment.status;
+  elements.root.style.setProperty('--ugrp-water-progress', `${assessment.progress}%`);
+  elements.root.style.setProperty('--ugrp-soil-progress', `${Math.min(92, Math.max(18, result.substrateDepthCm * 1.7))}%`);
+  elements.root.style.setProperty('--ugrp-rain-progress', `${Math.min(100, Math.max(8, result.rainfallMm * 2.2))}%`);
+  if (elements.soilFill) elements.soilFill.setAttribute('aria-valuenow', String(result.substrateDepthCm));
+  if (elements.waterFill) elements.waterFill.setAttribute('aria-valuenow', String(result.harvestedWaterLiters));
+}

package/src/tool/urbanGardenPlanner/entry.ts

@@ -0,0 +1,29 @@
+import type { NatureToolEntry, ToolLocaleContent } from '../../types';
+import type { UrbanGardenPlannerUI } from './ui';
+
+export type UrbanGardenPlannerLocaleContent = ToolLocaleContent<UrbanGardenPlannerUI>;
+
+export const urbanGardenPlanner: NatureToolEntry<UrbanGardenPlannerUI> = {
+  id: 'urban-garden-rainwater-soil-planner',
+  icons: {
+    bg: 'mdi:water-outline',
+    fg: 'mdi:sprout',
+  },
+  i18n: {
+    en: async () => (await import('./i18n/en')).content,
+    de: async () => (await import('./i18n/de')).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/urbanGardenPlanner/evaluator.ts

@@ -0,0 +1,27 @@
+import type { GardenPlanInput, GardenPlanResult } from './logic';
+
+export type GardenPlanStatus = 'balanced' | 'lightCapture' | 'deepBed' | 'noRain';
+
+export interface GardenPlanAssessment {
+  status: GardenPlanStatus;
+  progress: number;
+}
+
+export function evaluateGardenPlan(
+  input: GardenPlanInput,
+  result: GardenPlanResult,
+): GardenPlanAssessment {
+  if (result.rainfallMm === 0 || result.collectionAreaM2 === 0) {
+    return { status: 'noRain', progress: 8 };
+  }
+
+  if (result.gardenWaterDepthMm < 5) {
+    return { status: 'lightCapture', progress: Math.max(12, result.gardenWaterDepthMm * 8) };
+  }
+
+  if (input.substrateDepthCm > 45) {
+    return { status: 'deepBed', progress: 86 };
+  }
+
+  return { status: 'balanced', progress: Math.min(92, Math.max(18, result.gardenWaterDepthMm * 3)) };
+}

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

@@ -0,0 +1,50 @@
+import type { FAQPage, HowToThing, SoftwareApplication, WithContext } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { UrbanGardenPlannerLocaleContent } from '../entry';
+
+const slug = 'gartenboden-und-regenwasser-planer';
+const title = 'Planer für Gartenboden und Regenwasser';
+const description = 'Berechne das Substratvolumen für Hochbeete und schätze die Regenwassermenge für kleine Stadtgärten.';
+
+const faqData = [
+  { question: 'Wie viel Erde brauche ich für ein Hochbeet?', answer: 'Gib die Anbaufläche und die Substrattiefe ein. Der Planer multipliziert beide Werte und rechnet das Ergebnis in Liter um, damit du Erde oder Kompost besser bestellen kannst.' },
+  { question: 'Wie berechne ich Regenwasser für einen Garten?', answer: 'Gib die Sammelfläche und die Niederschlagshöhe ein. Der Planer wendet danach einen Abflussfaktor von 85 Prozent und einen Sammelfaktor von 90 Prozent als vorsichtige Planungsschätzung an.' },
+  { question: 'Funktioniert der Planer für einen Balkon?', answer: 'Ja. Verwende die Fläche des Pflanzbereichs, die geplante Substrattiefe und die Dach- oder Vordachfläche, die deinen Behälter speist.' },
+  { question: 'Ist gesammeltes Regenwasser für essbare Pflanzen sicher?', answer: 'Nicht automatisch. Prüfe Sammelfläche und Behälter, sorge für geeignete Filter und Entwässerung und beachte die örtlichen Hinweise.' },
+];
+
+const howToData = [
+  { name: 'Anbaufläche messen', text: 'Gib die Fläche des Beets, Balkons oder Pflanzgefäßes ein, die das Substrat aufnehmen soll.' },
+  { name: 'Substrattiefe festlegen', text: 'Trage die geplante Tiefe in Zentimetern ein, einschließlich möglicher Setzung.' },
+  { name: 'Sammelfläche eintragen', text: 'Gib die Dach-, Vordach- oder andere Fläche ein, die Wasser in den Behälter leitet.' },
+  { name: 'Regenereignis testen', text: 'Trage eine Niederschlagshöhe in Millimetern ein und vergleiche das Wasser mit der Gartengröße.' },
+];
+
+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<HowToThing> = { '@context': 'https://schema.org', '@type': 'HowTo', name: title, description, step: howToData.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: UrbanGardenPlannerLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    eyebrow: 'Ein kleiner Garten, in lebendigen Schichten gemessen', headInputs: 'Gartenszene festlegen', headScene: 'Die Landschaft lesen', labelGardenArea: 'Anbaufläche', labelDepth: 'Substrattiefe', labelCollectionArea: 'Sammelfläche', labelRainfall: 'Regenereignis', unitSquareMeters: 'm²', unitCentimeters: 'cm', unitMillimeters: 'mm', unitLiters: 'L', helpGardenArea: 'Fläche von Beet, Balkon oder Pflanzgefäß.', helpDepth: 'Die Bodenschicht, die du auffüllen möchtest.', helpCollectionArea: 'Fläche, die Wasser in deinen Behälter leitet.', helpRainfall: 'Teste einen Schauer oder ein örtliches Planungsereignis.', presetsTitle: 'Mit einer Form beginnen', presetBalcony: 'Balkonbeet', presetRaisedBed: 'Hochbeet', presetCommunity: 'Gemeinschaftsgarten', labelSoilNeeded: 'Benötigtes Substrat', labelWaterCaptured: 'Gesammeltes Wasser', labelGardenDepth: 'Auf dieser Gartenfläche', labelWateringArea: 'Bei 10 mm Wasser', sceneCatchment: 'Sammelfläche', sceneGardenBed: 'Anbaufläche', sceneSoil: 'Bodenschicht', sceneWater: 'Gesammeltes Wasser', statusBalanced: 'Eine brauchbare Planungskombination', statusLightCapture: 'Ein kleines Regenereignis', statusDeepBed: 'Ein tiefes Bodenprofil', statusNoRain: 'Warte auf ein Regenereignis', statusNote: 'Nutze diese Momentaufnahme zum Vergleichen von Materialien und Szenarien. Sie ist keine Bewässerungsempfehlung.', assumptionTitle: 'Planungsannahmen', assumptionText: 'Die Schätzung rechnet mit 85 Prozent Abfluss und 90 Prozent nach Verlusten bei der Sammlung. Ein Liter auf einem Quadratmeter entspricht einem Millimeter Wasser.', limitationTitle: 'Garten sicher nutzen', limitationText: 'Sorge für Entwässerung, vermeide belastete Sammelflächen und prüfe örtliche Regeln, bevor du Regenwasser für essbare Pflanzen verwendest.',
+  },
+  seo: [
+    { type: 'title', text: 'Gartenboden und Regenwasser für kleine Flächen berechnen', level: 2 },
+    { type: 'paragraph', html: 'Ein Hochbeet, ein Balkon und ein Gemeinschaftsgarten brauchen dieselbe praktische Klarheit: Wie viel Substrat wird benötigt und wie viel Regenwasser kann eine verfügbare Fläche ungefähr sammeln? Dieser Planer stellt beide Schätzungen nebeneinander.' },
+    { type: 'title', text: 'Formel für das Substratvolumen', level: 3 },
+    { type: 'paragraph', html: 'Die Rechnung lautet <code>Fläche in m² × Tiefe in cm × 10 = Liter Substrat</code>. Ein Beet mit 12 m² Fläche und 30 cm Tiefe benötigt damit 3.600 Liter, bevor Setzung, Drainageschichten oder die konkrete Bepflanzung berücksichtigt werden.' },
+    { type: 'list', items: ['<strong>Anbaufläche:</strong> Grundfläche von Beet, Balkon oder Pflanzgefäß.', '<strong>Substrattiefe:</strong> geplante Höhe der Bodenschicht.', '<strong>Sammelfläche:</strong> Dach, Vordach oder andere Zuflussfläche.', '<strong>Regenereignis:</strong> Niederschlagshöhe in Millimetern.'] },
+    { type: 'title', text: 'Regenwasser für den Garten schätzen', level: 3 },
+    { type: 'paragraph', html: 'Die Wassermenge beginnt mit <code>Sammelfläche × Niederschlag</code>. Danach werden 85 Prozent für Abflussverluste und 90 Prozent für Verluste bei der Sammlung angesetzt. So entsteht eine nachvollziehbare Schätzung statt eines Versprechens über die tatsächlich verfügbare Wassermenge.' },
+    { type: 'title', text: 'Szenarien offline vergleichen', level: 3 },
+    { type: 'paragraph', html: 'Teste ein Balkonbeet, ein Hochbeet und eine größere Gemeinschaftsfläche mit den Presets und ersetze sie danach durch deine Messwerte. Der Planer benötigt keine Adresse, Karte oder Wetterverbindung und bleibt im Browser.' },
+    { type: 'tip', title: 'Wichtige Grenzen', html: 'Entwässerung, Wasserqualität, Verdunstung, Pflanzenwahl und örtliche Vorschriften brauchen weiterhin eine menschliche Entscheidung. Belastete Dächer oder Behälter sind für essbare Pflanzen nicht automatisch geeignet.' },
+  ],
+  faq: faqData,
+  howTo: howToData,
+  bibliography,
+  schemas: [faqSchema, howToSchema, appSchema],
+};