@jjlmoya/utils-nature 1.25.0 → 1.26.0

package/package.json

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

package/src/category/index.ts

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

package/src/entries.ts

@@ -15,4 +15,5 @@ import { rainHarvester } from './tool/rainHarvester/entry';
 import { seedCalculator } from './tool/seedCalculator/entry';
 import { urbanGardenPlanner } from './tool/urbanGardenPlanner/entry';
 import { compostBinVolumeRatioCalculator } from './tool/compostBinVolumeRatioCalculator/entry';
-export const ALL_ENTRIES = [cricketThermometer, digitalCarbon, rainHarvester, seedCalculator, urbanGardenPlanner, compostBinVolumeRatioCalculator];
+import { wildlifeCameraTrapEffortPlanner } from './tool/wildlifeCameraTrapEffortPlanner/entry';
+export const ALL_ENTRIES = [cricketThermometer, digitalCarbon, rainHarvester, seedCalculator, urbanGardenPlanner, compostBinVolumeRatioCalculator, wildlifeCameraTrapEffortPlanner];

package/src/index.ts

@@ -28,3 +28,5 @@ export { DIGITAL_CARBON_TOOL, digitalCarbon } from './tool/digitalCarbon/index';
 export { URBAN_GARDEN_PLANNER_TOOL, urbanGardenPlanner } from './tool/urbanGardenPlanner/index';
 
 export { COMPOST_BIN_VOLUME_RATIO_CALCULATOR_TOOL, compostBinVolumeRatioCalculator } from './tool/compostBinVolumeRatioCalculator/index';
+
+export { WILDLIFE_CAMERA_TRAP_EFFORT_PLANNER_TOOL, wildlifeCameraTrapEffortPlanner } from './tool/wildlifeCameraTrapEffortPlanner/index';

package/src/pages/[locale]/[slug].astro

@@ -8,14 +8,15 @@ import {
   Bibliography,
   SEORenderer,
 } from "@jjlmoya/utils-shared";
-import type { KnownLocale, ToolLocaleContent } from "../../types";
-import type { UtilitySEOContent } from "@jjlmoya/utils-shared";
+import type { KnownLocale, ToolLocaleContent } from "../../types";
+import type { UtilitySEOContent } from "@jjlmoya/utils-shared";
+import type { AstroComponentFactory } from "astro/runtime/server/index.js";
 
 export async function getStaticPaths() {
   const paths = [];
 
   for (const { entry, Component: lazyComp } of ALL_TOOLS) {
-    const Component = (await (lazyComp as () => Promise<{ default: unknown }>)()).default;
+    const Component = (await (lazyComp as () => Promise<{ default: AstroComponentFactory }>)()).default;
     const localeEntries = Object.entries(entry.i18n) as [
       KnownLocale,
       () => Promise<ToolLocaleContent>,
@@ -71,7 +72,7 @@ interface NavItem {
 }
 
 export interface Props {
-  Component: unknown;
+  Component: AstroComponentFactory;
   locale: KnownLocale;
   content: ToolLocaleContent;
   localeUrls: Partial<Record<KnownLocale, string>>;

package/src/tests/consumer_loader_contract.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+describe('Consumer loader contract', () => {
+  it('exposes renderable component loaders and locale content for both library layouts', async () => {
+    const tool = ALL_TOOLS.find(({ entry }) => entry.id === 'wildlife-camera-trap-effort-planner');
+    expect(tool).toBeDefined();
+    if (!tool) return;
+
+    const [component, seo, bibliography] = await Promise.all([
+      tool.Component(),
+      tool.SEOComponent(),
+      tool.BibliographyComponent(),
+    ]);
+    expect(typeof component.default).toBe('function');
+    expect(typeof seo.default).toBe('function');
+    expect(typeof bibliography.default).toBe('function');
+
+    const content = await tool.entry.i18n.es!();
+    expect((content.ui as { areaPerCameraLabel: string }).areaPerCameraLabel).toBe('Área por cámara');
+    expect(content.seo).toHaveLength(10);
+    expect(content.bibliography.length).toBeGreaterThan(0);
+  });
+});

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 6 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(6);
+    it('should have 7 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(7);
     });
 
     it('natureCategory should be defined', () => {

package/src/tool/wildlifeCameraTrapEffortPlanner/bibliography.astro

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

package/src/tool/wildlifeCameraTrapEffortPlanner/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Ministerio para la Transición Ecológica y el Reto Demográfico. Prescripciones Técnicas nº 8, Ficha 9: Cámaras trampa',
+    url: 'https://www.miteco.gob.es/content/dam/miteco/es/biodiversidad/temas/ecosistemas-y-conectividad/prescripcionestecnicasn8_tcm30-521531.pdf',
+  },
+  {
+    name: 'Arthur Rylah Institute. Camera trapping',
+    url: 'https://www.ari.vic.gov.au/research/technology-and-skills/monitoring-techniques/camera-trapping',
+  },
+  {
+    name: 'Province of British Columbia. Wildlife Camera Metadata Protocol Version 1.0',
+    url: 'https://www2.gov.bc.ca/assets/gov/environment/natural-resource-stewardship/nr-laws-policy/risc/wcmp_v1.pdf',
+  },
+];

package/src/tool/wildlifeCameraTrapEffortPlanner/component.astro

@@ -0,0 +1,115 @@
+---
+import { wildlifeCameraTrapEffortPlanner } from './index';
+import { DEFAULT_INPUTS } from './logic';
+
+const { ui: propUi, locale = 'en' } = Astro.props;
+let ui = propUi;
+
+if (!ui) {
+  const content = await wildlifeCameraTrapEffortPlanner.i18n[locale as keyof typeof wildlifeCameraTrapEffortPlanner.i18n]?.();
+  ui = content?.ui;
+}
+
+if (!ui) return null;
+
+const config = JSON.stringify({ ui, defaults: DEFAULT_INPUTS });
+---
+
+<wildlife-camera-trap-effort-planner class="wctep-root">
+  <div class="wctep-shell">
+    <section class="wctep-controls" aria-label={ui.labelSurveyArea}>
+      <div class="wctep-control-topline">
+        <span class="wctep-mark" aria-hidden="true">FIELD / 01</span>
+        <div class="wctep-unit-switch" role="group" aria-label={ui.unitSystemLabel}>
+          <button type="button" data-unit-button="metric" aria-pressed="true">{ui.metricLabel}</button>
+          <button type="button" data-unit-button="imperial" aria-pressed="false">{ui.imperialLabel}</button>
+        </div>
+      </div>
+
+      <div class="wctep-fields">
+        <label class="wctep-field" for="wctep-area">
+          <span class="wctep-label">{ui.labelSurveyArea}</span>
+          <span class="wctep-input-line"><input id="wctep-area" data-input="area" type="number" min="0" step="0.1" inputmode="decimal" /><span data-unit-label="area">{ui.unitHectares}</span></span>
+          <span class="wctep-help">{ui.helpSurveyArea}</span>
+        </label>
+        <label class="wctep-field" for="wctep-cameras">
+          <span class="wctep-label">{ui.labelCameraCount}</span>
+          <span class="wctep-input-line"><input id="wctep-cameras" data-input="cameras" type="number" min="0" step="1" inputmode="numeric" /><span>{ui.unitCameras}</span></span>
+          <span class="wctep-help">{ui.helpCameraCount}</span>
+        </label>
+        <label class="wctep-field" for="wctep-days">
+          <span class="wctep-label">{ui.labelDeploymentDays}</span>
+          <span class="wctep-input-line"><input id="wctep-days" data-input="days" type="number" min="0" step="1" inputmode="numeric" /><span>{ui.unitDays}</span></span>
+          <span class="wctep-help">{ui.helpDeploymentDays}</span>
+        </label>
+        <label class="wctep-field" for="wctep-spacing">
+          <span class="wctep-label">{ui.labelSpacing}</span>
+          <span class="wctep-input-line"><input id="wctep-spacing" data-input="spacing" type="number" min="0" step="1" inputmode="decimal" /><span data-unit-label="spacing">{ui.unitMeters}</span></span>
+          <span class="wctep-help">{ui.helpSpacing}</span>
+        </label>
+        <label class="wctep-field wctep-field-wide" for="wctep-triggers">
+          <span class="wctep-label">{ui.labelTriggerRate}</span>
+          <span class="wctep-input-line"><input id="wctep-triggers" data-input="triggers" type="number" min="0" step="0.1" inputmode="decimal" /><span>{ui.unitEventsPerDay}</span></span>
+          <span class="wctep-help">{ui.helpTriggerRate}</span>
+        </label>
+      </div>
+
+      <div class="wctep-presets">
+        <span class="wctep-section-label">{ui.presetsTitle}</span>
+        <div class="wctep-preset-row">
+          <button type="button" data-preset="backyard">{ui.presetBackyard}</button>
+          <button type="button" data-preset="woodland">{ui.presetWoodland}</button>
+          <button type="button" data-preset="reserve">{ui.presetReserve}</button>
+        </div>
+      </div>
+    </section>
+
+    <section class="wctep-reading" aria-label={ui.mapLabel}>
+      <div class="wctep-map-column">
+        <div class="wctep-reading-head">
+          <span class="wctep-section-label">{ui.mapLabel}</span>
+          <span class="wctep-status" data-status aria-live="polite">{ui.statusBalanced}</span>
+        </div>
+        <div class="wctep-map" data-field-map role="img" aria-label={ui.mapLabel}></div>
+        <div class="wctep-map-key"><span class="wctep-key-station" aria-hidden="true"></span><span>{ui.stationLabel}</span><span class="wctep-key-cell" aria-hidden="true"></span><span>{ui.spacingLabel}</span><strong data-footprint>0%</strong></div>
+        <p class="wctep-caption">{ui.mapCaption}</p>
+      </div>
+
+      <div class="wctep-metrics" aria-live="polite">
+        <div class="wctep-metric wctep-metric-major"><span>{ui.cameraDaysLabel}</span><strong data-camera-days>0</strong></div>
+        <div class="wctep-metric"><span>{ui.expectedEventsLabel}</span><strong data-expected-events>0</strong></div>
+        <div class="wctep-metric"><span>{ui.spacingLabel}</span><strong data-grid-spacing>0 m</strong></div>
+        <div class="wctep-metric"><span>{ui.reviewLoadLabel}</span><strong data-review-load>0</strong></div>
+        <div class="wctep-metric wctep-metric-wide"><span>{ui.areaPerCameraLabel}</span><strong data-area-per-camera>0 m²</strong></div>
+      </div>
+    </section>
+
+    <section class="wctep-review">
+      <div class="wctep-review-copy"><span class="wctep-section-label">{ui.reviewScheduleTitle}</span><p>{ui.reviewScheduleText}</p></div>
+      <ol data-review-list>
+        <li><strong>{ui.reviewDayLabel} 7</strong><span>336 {ui.reviewEventsLabel}</span></li>
+        <li><strong>{ui.reviewDayLabel} 14</strong><span>672 {ui.reviewEventsLabel}</span></li>
+        <li><strong>{ui.reviewDayLabel} 21</strong><span>1008 {ui.reviewEventsLabel}</span></li>
+        <li><strong>{ui.reviewDayLabel} 28</strong><span>1344 {ui.reviewEventsLabel}</span></li>
+      </ol>
+    </section>
+
+    <section class="wctep-notes">
+      <div><span class="wctep-note-label">{ui.assumptionTitle}</span><p>{ui.assumptionText}</p></div>
+      <div><span class="wctep-note-label">{ui.limitationTitle}</span><p>{ui.limitationText}</p></div>
+      <p class="wctep-status-note" data-status-note>{ui.statusNote}</p>
+    </section>
+  </div>
+</wildlife-camera-trap-effort-planner>
+
+<script is:inline type="application/json" id="wctep-config" set:html={config}></script>
+
+<script>
+  import { mountWildlifeCameraTrapEffortPlanner } from './controller';
+  const root = document.querySelector<HTMLElement>('wildlife-camera-trap-effort-planner');
+  const configNode = document.getElementById('wctep-config');
+  if (root && configNode) {
+    const config = JSON.parse(configNode.textContent || '{}');
+    mountWildlifeCameraTrapEffortPlanner(root, config);
+  }
+</script>

package/src/tool/wildlifeCameraTrapEffortPlanner/controller.ts

@@ -0,0 +1,81 @@
+import { ACRES_PER_HECTARE, calculateSurveyPlan, DEFAULT_INPUTS, METERS_PER_FOOT, type SurveyInput } from './logic';
+import { formatInputValue, renderPlan } from './dom-views';
+import { loadUnitSystem, saveUnitSystem, type UnitSystem } from './storage';
+import type { WildlifeCameraTrapEffortPlannerUI } from './ui';
+
+interface ToolConfig {
+  ui: WildlifeCameraTrapEffortPlannerUI;
+  defaults: SurveyInput;
+}
+
+const PRESETS: Record<string, SurveyInput> = {
+  backyard: { areaHectares: 1, cameraCount: 3, deploymentDays: 14, spacingMeters: 55, triggerRatePerCameraDay: 2 },
+  woodland: { areaHectares: 12, cameraCount: 12, deploymentDays: 28, spacingMeters: 100, triggerRatePerCameraDay: 4 },
+  reserve: { areaHectares: 80, cameraCount: 24, deploymentDays: 42, spacingMeters: 180, triggerRatePerCameraDay: 1.5 },
+};
+
+function input(root: HTMLElement, name: string): HTMLInputElement {
+  return root.querySelector<HTMLInputElement>(`[data-input="${name}"]`)!;
+}
+
+function readInput(root: HTMLElement, unitSystem: UnitSystem): SurveyInput {
+  const area = Number(input(root, 'area').value) || 0;
+  const spacing = Number(input(root, 'spacing').value) || 0;
+  return {
+    areaHectares: unitSystem === 'metric' ? area : area / ACRES_PER_HECTARE,
+    cameraCount: Number(input(root, 'cameras').value) || 0,
+    deploymentDays: Number(input(root, 'days').value) || 0,
+    spacingMeters: unitSystem === 'metric' ? spacing : spacing * METERS_PER_FOOT,
+    triggerRatePerCameraDay: Number(input(root, 'triggers').value) || 0,
+  };
+}
+
+function writeInput(root: HTMLElement, values: SurveyInput, unitSystem: UnitSystem): void {
+  input(root, 'area').value = formatInputValue(values.areaHectares, unitSystem, 'area');
+  input(root, 'cameras').value = String(values.cameraCount);
+  input(root, 'days').value = String(values.deploymentDays);
+  input(root, 'spacing').value = formatInputValue(values.spacingMeters, unitSystem, 'spacing');
+  input(root, 'triggers').value = String(values.triggerRatePerCameraDay);
+}
+
+function updateUnitLabels(root: HTMLElement, ui: WildlifeCameraTrapEffortPlannerUI, unitSystem: UnitSystem): void {
+  root.querySelector('[data-unit-label="area"]')!.textContent = unitSystem === 'metric' ? ui.unitHectares : ui.unitAcres;
+  root.querySelector('[data-unit-label="spacing"]')!.textContent = unitSystem === 'metric' ? ui.unitMeters : ui.unitFeet;
+  root.querySelector('[data-unit-button="metric"]')!.setAttribute('aria-pressed', String(unitSystem === 'metric'));
+  root.querySelector('[data-unit-button="imperial"]')!.setAttribute('aria-pressed', String(unitSystem === 'imperial'));
+}
+
+function render(root: HTMLElement, ui: WildlifeCameraTrapEffortPlannerUI, unitSystem: UnitSystem, values: SurveyInput): void {
+  renderPlan(root, calculateSurveyPlan(values), ui, unitSystem);
+}
+
+export function mountWildlifeCameraTrapEffortPlanner(root: HTMLElement, config: ToolConfig): void {
+  if (root.dataset.mounted === 'true') return;
+  root.dataset.mounted = 'true';
+  const ui = config.ui;
+  let unitSystem = loadUnitSystem();
+  let physicalValues = config.defaults ?? DEFAULT_INPUTS;
+  writeInput(root, physicalValues, unitSystem);
+  updateUnitLabels(root, ui, unitSystem);
+  root.querySelectorAll<HTMLInputElement>('[data-input]').forEach((field) => field.addEventListener('input', () => {
+    physicalValues = readInput(root, unitSystem);
+    render(root, ui, unitSystem, physicalValues);
+  }));
+  root.querySelectorAll<HTMLButtonElement>('[data-unit-button]').forEach((button) => button.addEventListener('click', () => {
+    const nextUnit = button.dataset.unitButton as UnitSystem;
+    if (nextUnit === unitSystem) return;
+    unitSystem = nextUnit;
+    writeInput(root, physicalValues, unitSystem);
+    updateUnitLabels(root, ui, unitSystem);
+    saveUnitSystem(unitSystem);
+    render(root, ui, unitSystem, physicalValues);
+  }));
+  root.querySelectorAll<HTMLButtonElement>('[data-preset]').forEach((button) => button.addEventListener('click', () => {
+    const preset = PRESETS[button.dataset.preset ?? ''];
+    if (!preset) return;
+    physicalValues = preset;
+    writeInput(root, physicalValues, unitSystem);
+    render(root, ui, unitSystem, physicalValues);
+  }));
+  render(root, ui, unitSystem, physicalValues);
+}

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

@@ -0,0 +1,98 @@
+import type { WildlifeCameraTrapEffortPlannerUI } from './ui';
+import { ACRES_PER_HECTARE, M2_PER_ACRE, METERS_PER_FOOT, type SurveyPlanResult } from './logic';
+import { evaluatePlan } from './evaluator';
+import type { UnitSystem } from './storage';
+
+function number(value: number, maximumFractionDigits = 0): string {
+  return new Intl.NumberFormat('en-US', { maximumFractionDigits }).format(value);
+}
+
+function pointGrid(count: number): Array<{ x: number; y: number; index: number }> {
+  const columns = Math.max(1, Math.ceil(Math.sqrt(count)));
+  const rows = Math.max(1, Math.ceil(count / columns));
+  const points: Array<{ x: number; y: number; index: number }> = [];
+  for (let index = 0; index < count; index += 1) {
+    const column = index % columns;
+    const row = Math.floor(index / columns);
+    points.push({
+      x: 14 + (column / Math.max(1, columns - 1)) * 72,
+      y: 16 + (row / Math.max(1, rows - 1)) * 68,
+      index,
+    });
+  }
+  return points;
+}
+
+function renderFieldMap(element: HTMLElement, result: SurveyPlanResult, ui: WildlifeCameraTrapEffortPlannerUI): void {
+  const points = pointGrid(Math.min(result.cameraCount, 36));
+  const stationMarks = points.map((point) => `
+    <g class="wctep-station" transform="translate(${point.x} ${point.y})">
+      <rect class="wctep-cell" x="-8" y="-8" width="16" height="16" rx="2" />
+      <circle class="wctep-station-dot" r="2.4" />
+      <text x="0" y="-11" text-anchor="middle">${point.index + 1}</text>
+    </g>`).join('');
+  const overflow = result.cameraCount > 36 ? `<text class="wctep-overflow" x="86" y="92" text-anchor="end">+${result.cameraCount - 36}</text>` : '';
+  element.innerHTML = `
+    <svg viewBox="0 0 100 100" role="img" aria-label="${ui.mapLabel}">
+      <title>${ui.mapLabel}</title>
+      <desc>${ui.mapCaption}</desc>
+      <path class="wctep-contour" d="M6 22 C18 10 29 18 42 10 S70 8 94 20 M4 68 C20 55 30 78 48 63 S76 55 96 72 M16 95 C25 77 46 88 60 79 S82 78 92 88" />
+      <path class="wctep-route" d="M9 84 C29 72 32 39 48 47 S68 77 91 28" />
+      ${stationMarks}
+      ${overflow}
+      <path class="wctep-north" d="M91 13 L91 25 M91 13 L88 18 M91 13 L94 18" />
+      <text class="wctep-north-label" x="91" y="9" text-anchor="middle">N</text>
+    </svg>`;
+}
+
+function renderReviewList(root: HTMLElement, result: SurveyPlanResult, ui: WildlifeCameraTrapEffortPlannerUI): void {
+  const list = root.querySelector<HTMLOListElement>('[data-review-list]');
+  if (!list) return;
+  list.replaceChildren(...result.reviewCheckpoints.map((checkpoint) => {
+    const item = document.createElement('li');
+    const day = document.createElement('strong');
+    day.textContent = `${ui.reviewDayLabel} ${number(checkpoint.day)}`;
+    const events = document.createElement('span');
+    events.textContent = `${number(checkpoint.expectedEvents)} ${ui.reviewEventsLabel}`;
+    item.append(day, events);
+    return item;
+  }));
+}
+
+function renderValues(root: HTMLElement, result: SurveyPlanResult, unitSystem: UnitSystem): void {
+  const areaPerCamera = unitSystem === 'metric' ? `${number(result.areaPerCameraM2)} m²` : `${number(result.areaPerCameraM2 / M2_PER_ACRE, 2)} ac`;
+  const spacing = unitSystem === 'metric' ? `${number(result.evenGridSpacingMeters)} m` : `${number(result.evenGridSpacingMeters / METERS_PER_FOOT)} ft`;
+  root.querySelector('[data-camera-days]')!.textContent = number(result.cameraDays);
+  root.querySelector('[data-expected-events]')!.textContent = number(result.expectedEvents);
+  root.querySelector('[data-area-per-camera]')!.textContent = areaPerCamera;
+  root.querySelector('[data-grid-spacing]')!.textContent = spacing;
+  root.querySelector('[data-footprint]')!.textContent = `${number(result.nominalFootprintPercent, 1)}%`;
+  root.querySelector('[data-review-load]')!.textContent = number(result.expectedEventsPerReview);
+}
+
+function renderStatus(root: HTMLElement, result: SurveyPlanResult, ui: WildlifeCameraTrapEffortPlannerUI): void {
+  const status = evaluatePlan(result);
+  const labels: Record<string, string> = {
+    'needs-input': ui.statusNeedsInput,
+    sparse: ui.statusSparse,
+    dense: ui.statusDense,
+    'review-heavy': ui.statusReviewHeavy,
+    balanced: ui.statusBalanced,
+  };
+  const statusElement = root.querySelector('[data-status]');
+  if (statusElement) statusElement.textContent = labels[status] ?? ui.statusNeedsInput;
+  root.dataset.planStatus = status;
+}
+
+export function renderPlan(root: HTMLElement, result: SurveyPlanResult, ui: WildlifeCameraTrapEffortPlannerUI, unitSystem: UnitSystem): void {
+  renderFieldMap(root.querySelector<HTMLElement>('[data-field-map]')!, result, ui);
+  renderValues(root, result, unitSystem);
+  renderStatus(root, result, ui);
+  renderReviewList(root, result, ui);
+}
+
+export function formatInputValue(value: number, unitSystem: UnitSystem, kind: 'area' | 'spacing'): string {
+  if (kind === 'area' && unitSystem === 'imperial') return String(Math.round((value * ACRES_PER_HECTARE) * 100) / 100);
+  if (kind === 'spacing' && unitSystem === 'imperial') return String(Math.round((value / METERS_PER_FOOT) * 10) / 10);
+  return String(value);
+}

package/src/tool/wildlifeCameraTrapEffortPlanner/entry.ts

@@ -0,0 +1,29 @@
+import type { NatureToolEntry, ToolLocaleContent } from '../../types';
+import type { WildlifeCameraTrapEffortPlannerUI } from './ui';
+
+export type WildlifeCameraTrapEffortPlannerLocaleContent = ToolLocaleContent<WildlifeCameraTrapEffortPlannerUI>;
+
+export const wildlifeCameraTrapEffortPlanner: NatureToolEntry<WildlifeCameraTrapEffortPlannerUI> = {
+  id: 'wildlife-camera-trap-effort-planner',
+  icons: {
+    bg: 'mdi:forest-outline',
+    fg: 'mdi:camera-outline',
+  },
+  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/wildlifeCameraTrapEffortPlanner/evaluator.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { evaluatePlan } from './evaluator';
+import { calculateSurveyPlan, DEFAULT_INPUTS } from './logic';
+
+describe('Wildlife camera trap plan evaluator', () => {
+  it('recognizes a balanced plan', () => {
+    expect(evaluatePlan(calculateSurveyPlan(DEFAULT_INPUTS))).toBe('balanced');
+  });
+
+  it('flags target spacing that is sparse or dense for the area', () => {
+    expect(evaluatePlan(calculateSurveyPlan({ ...DEFAULT_INPUTS, areaHectares: 100, cameraCount: 1, spacingMeters: 100 }))).toBe('sparse');
+    expect(evaluatePlan(calculateSurveyPlan({ ...DEFAULT_INPUTS, areaHectares: 1, cameraCount: 100, spacingMeters: 100, triggerRatePerCameraDay: 0.1 }))).toBe('dense');
+  });
+
+  it('flags a review load that needs attention', () => {
+    expect(evaluatePlan(calculateSurveyPlan({ ...DEFAULT_INPUTS, triggerRatePerCameraDay: 10 }))).toBe('review-heavy');
+  });
+
+  it('requires a complete deployment before interpreting it', () => {
+    expect(evaluatePlan(calculateSurveyPlan({ ...DEFAULT_INPUTS, deploymentDays: 0 }))).toBe('needs-input');
+  });
+});

package/src/tool/wildlifeCameraTrapEffortPlanner/evaluator.ts

@@ -0,0 +1,11 @@
+import type { SurveyPlanResult } from './logic';
+
+export type PlanStatus = 'needs-input' | 'sparse' | 'dense' | 'review-heavy' | 'balanced';
+
+export function evaluatePlan(result: SurveyPlanResult): PlanStatus {
+  if (result.areaM2 === 0 || result.cameraCount === 0 || result.deploymentDays === 0) return 'needs-input';
+  if (result.expectedEventsPerReview >= 500) return 'review-heavy';
+  if (result.evenGridSpacingMeters > result.spacingMeters * 1.25) return 'sparse';
+  if (result.evenGridSpacingMeters < result.spacingMeters * 0.75) return 'dense';
+  return 'balanced';
+}

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

@@ -0,0 +1,49 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import { bibliography } from '../bibliography';
+import type { WildlifeCameraTrapEffortPlannerLocaleContent } from '../entry';
+
+const slug = 'wildkamera-einsatzplan-wildtiermonitoring';
+const title = 'Planer für den Einsatz von Wildkameras';
+const description = 'Plane Kameraaufwand, schätze Kameratage und Bildprüfung und skizziere ein Einsatzraster ohne Aussagen zur Populationsgröße.';
+const faqData = [
+  { question: 'Was sind Kameratage?', answer: 'Kameratage sind die Anzahl der Kameras multipliziert mit der Zahl ihrer aktiven Tage. Sie beschreiben den Stichprobenaufwand, nicht die Zahl der Tiere in einem Gebiet.' },
+  { question: 'Berechnet der Planer die Größe einer Wildtierpopulation?', answer: 'Nein. Er schätzt den Arbeitsaufwand und eine nominale Planungsfläche. Populationsgröße, Abundanz und Belegung erfordern ein validiertes Studiendesign und ein Modell für unvollständige Entdeckung.' },
+  { question: 'Was bewirkt der Abstand?', answer: 'Der Abstand erzeugt eine nominale quadratische Planungszelle pro Kamera und vergleicht sie mit dem gleichmäßigen Rasterabstand aus Fläche und Kamerazahl. Er ist kein Erfassungsradius.' },
+  { question: 'Wie nutze ich den Prüfplan?', answer: 'Nutze die Wochenpunkte als Arbeitsrhythmus. Vergleiche die erwartete Ereignismenge mit Speicher, Batterien und Prüfkapazität und protokolliere jeden echten Besuch.' },
+];
+const howToData = [
+  { name: 'Untersuchungsfläche beschreiben', text: 'Gib die Fläche ein, die der Einsatz untersuchen soll. Der Schalter Metric oder Imperial bewahrt den physikalischen Wert beim Wechsel.' },
+  { name: 'Einsatzraster planen', text: 'Gib Kamerazahl, Einsatzdauer und Zielabstand ein. Die Skizze zeigt Stationen als Planungsraster, nicht als Koordinaten oder garantierte Erfassungszonen.' },
+  { name: 'Bildaufwand schätzen', text: 'Gib erwartete Auslösungen pro Kamera und Tag ein. Der Planer multipliziert sie mit den Kameratagen und verteilt sie auf Wochenpunkte.' },
+  { name: 'Feldprotokoll vorbereiten', text: 'Vergib eindeutige Kamera- und Sitzungscodes, notiere Aufstellung und erfasse jede Kontrolle, auch wenn kein Tier erkannt wurde.' },
+];
+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<HowTo> = { '@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: WildlifeCameraTrapEffortPlannerLocaleContent = {
+  slug, title, description,
+  ui: {
+    areaPerCameraLabel: 'Fläche pro Kamera',
+    labelSurveyArea: 'Untersuchungsfläche', labelCameraCount: 'Kamerastationen', labelDeploymentDays: 'Einsatztage', labelSpacing: 'Zielabstand der Stationen', labelTriggerRate: 'Erwartete Auslösungen pro Kamera und Tag',
+    unitHectares: 'ha', unitAcres: 'ac', unitMeters: 'm', unitFeet: 'ft', unitCameras: 'Kameras', unitDays: 'Tage', unitEventsPerDay: 'Ereignisse pro Tag',
+    helpSurveyArea: 'Die Fläche, die der Einsatz untersuchen soll.', helpCameraCount: 'Aktive Kameras dieser Kampagne.', helpDeploymentDays: 'Tage zwischen Aufbau und Abbau.', helpSpacing: 'Eine Planungshilfe, kein Erfassungsradius.', helpTriggerRate: 'Nutze einen vorsichtigen Wert aus einem vergleichbaren Einsatz oder Test.',
+    unitSystemLabel: 'Messsystem', metricLabel: 'Metrisch', imperialLabel: 'Imperial', presetsTitle: 'Startpunkte fuer das Feld', presetBackyard: 'Waldrand am Haus', presetWoodland: 'Mischwald', presetReserve: 'Grosses Schutzgebiet',
+    mapLabel: 'Relative Skizze des Kameraeinsatzes', mapCaption: 'Nummerierte Stationen in einem relativen Planungsraster. Die Zellen helfen beim Abstand, sind aber keine Habitatkarte.', stationLabel: 'Station', cameraDaysLabel: 'Kameratage', expectedEventsLabel: 'Erwartete Ereignisse', spacingLabel: 'Abstand im gleichmäßigen Raster', reviewLoadLabel: 'Ereignisse pro Kontrolle', reviewScheduleTitle: 'Kontrollrhythmus', reviewScheduleText: 'Wochenpunkte machen den Bildaufwand sichtbar, bevor die Kameras ausgebracht werden. Ersetze sie durch die Besuche deines Feldprotokolls.', reviewDayLabel: 'Tag', reviewEventsLabel: 'Ereignisse erwartet',
+    statusBalanced: 'Abstand wirkt ausgewogen', statusSparse: 'Stationen wirken weit verteilt', statusDense: 'Stationen wirken eng verteilt', statusReviewHeavy: 'Prüfaufwand braucht Aufmerksamkeit', statusNeedsInput: 'Vollständigen Einsatzplan eingeben', statusNote: 'Dies ist ein Aufwandsplan. Er sagt nicht, wie viele Tiere im Gebiet leben, und garantiert keine Artentdeckung.',
+    assumptionTitle: 'Annahmen des Modells', assumptionText: 'Die nominale Fläche behandelt jede Station als quadratische Zelle aus dem Zielabstand. Die Ereignisse setzen voraus, dass die Auslöserate bei allen Kameras und an allen Tagen gleich bleibt.', limitationTitle: 'Grenzen im Feld', limitationText: 'Wähle Standorte nach Art und Fragestellung, nicht nur nach Geometrie. Notiere Kamera-IDs, Daten, Ausrichtung, Höhe, Habitat und Leerprüfungen, damit unvollständige Entdeckung später berücksichtigt werden.',
+  },
+  seo: [
+    { type: 'title', text: 'Aufwand fuer Fotofallen planen', level: 2 },
+    { type: 'paragraph', html: 'Ein Fotofallenprojekt hat vor der Artenliste zwei Planungsfragen. Wie viel Stichprobenaufwand stellt der Einsatz dar? Und kann das erwartete Bildaufkommen geprueft, gespeichert und dokumentiert werden? Dieser Planer macht daraus Kameratage, erwartete Ereignisse, eine relative Stationsskizze und Kontrollpunkte.' },
+    { type: 'title', text: 'Kameratage als Aufwand nutzen', level: 3 },
+    { type: 'paragraph', html: 'Kameratage berechnen sich als <code>Kamerastationen × Einsatztage</code>. Zwölf Kameras für 28 Tage ergeben 336 Kameratage. Das hilft beim Vergleich zweier Kampagnen, ist aber keine Populationsschätzung und korrigiert weder Ausfälle noch Habitatunterschiede oder Tierverhalten.' },
+    { type: 'list', items: ['<strong>Kamerastationen:</strong> die aktiven Geraete der Kampagne.', '<strong>Einsatztage:</strong> die geplanten Tage zwischen Aufbau und Abbau.', '<strong>Ausloeserate:</strong> Ereignisse pro Kamera und Tag, nicht jede einzelne Aufnahme einer Serie.', '<strong>Kontrollpunkte:</strong> Aufwand fuer Speicher, Batterien, Besuche und Bildpruefung planen.'] },
+    { type: 'title', text: 'Die Feldskizze als Planungshilfe lesen', level: 3 },
+    { type: 'paragraph', html: 'Die Skizze nutzt Flaeche, Kamerazahl und Zielabstand fuer eine relative Anordnung. Die nominale Flaeche ist Stationszahl mal Zielabstand im Quadrat. Das ist eine transparente Geometriehilfe, aber keine Sensorflaeche. Gelaende, Vegetation, Wege, Hoehe, Ausrichtung und Verhalten veraendern die Entdeckungswahrscheinlichkeit.' },
+    { type: 'title', text: 'Vor dem Einsatz bessere Aufzeichnungen vorbereiten', level: 3 },
+    { type: 'paragraph', html: 'Definiere vor dem Aufbau Zielarten und Fragestellung. Vergib stabile Kennungen fuer Kamera und Einsatz. Erfasse bei Aufbau und Kontrolle Datum, Ort, Hoehe, Ausrichtung, Habitat, Einstellungen und Funktionsstatus. Auch eine Kontrolle ohne Fund ist ein echter Eintrag.' },
+    { type: 'tip', title: 'Aufwand nicht mit Abundanz verwechseln', html: 'Fotofallen haben eine unvollstaendige Entdeckung. Nutze den Planer fuer Feldaufwand und Bildbearbeitung und ein validiertes oekologisches Design fuer Belegung, Abundanz, Dichte oder Populationsveraenderung.' },
+  ],
+  faq: faqData, howTo: howToData, bibliography, schemas: [faqSchema, howToSchema, appSchema],
+};