@jjlmoya/utils-health 1.32.0 → 1.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-health",
-    "version": "1.32.0",
+    "version": "1.34.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -24,14 +24,16 @@ import { leanBodyMassCalculator } from '../tool/leanBodyMassCalculator/entry';
 import { metabolicAgeCalculator } from '../tool/metabolicAgeCalculator/entry';
 import { bunCreatinineCalculator } from '../tool/bunCreatinineCalculator/entry';
 import { serumOsmolalityCalculator } from '../tool/serumOsmolalityCalculator/entry';
+import { meanArterialPressureCalculator } from '../tool/meanArterialPressureCalculator/entry';
 import { correctedSodiumHyperglycemiaCalculator } from '../tool/correctedSodiumHyperglycemiaCalculator/entry';
 import { fractionalExcretionSodiumCalculator } from '../tool/fractionalExcretionSodiumCalculator/entry';
 import { targetHeightEstimator } from '../tool/targetHeightEstimator/entry';
 import { correctedReticulocyteIndex } from '../tool/correctedReticulocyteIndex/entry';
+import { estimatedBloodVolumeCalculator } from '../tool/estimatedBloodVolumeCalculator/entry';
 
 export const healthCategory: HealthCategoryEntry = {
   icon: 'mdi:heart-pulse',
-  tools: [bmiCalculator, amputationAdjustedBmiCalculator, bodyAdiposityIndexCalculator, bodyFatPercentageCalculator, waistHipRatioCalculator, waistHeightRatioCalculator, leanBodyMassCalculator, metabolicAgeCalculator, caloricDeficitCalculator, dailyProteinCalculator, macronutrientCalculator, tdeeCalculator, bunCreatinineCalculator, serumOsmolalityCalculator, correctedSodiumHyperglycemiaCalculator, fractionalExcretionSodiumCalculator, correctedReticulocyteIndex, targetHeightEstimator, daltonismSimulator, tinnitusReliever, parametricNoiseSynthesizer, breathingVisualizer, caffeineTracker, waterPurifier, digestionStopwatch, binauralTuner, pelliRobsonTest, peripheralVisionTrainer, epworthSleepinessScale],
+  tools: [bmiCalculator, amputationAdjustedBmiCalculator, bodyAdiposityIndexCalculator, bodyFatPercentageCalculator, waistHipRatioCalculator, waistHeightRatioCalculator, leanBodyMassCalculator, metabolicAgeCalculator, caloricDeficitCalculator, dailyProteinCalculator, macronutrientCalculator, tdeeCalculator, bunCreatinineCalculator, serumOsmolalityCalculator, meanArterialPressureCalculator, correctedSodiumHyperglycemiaCalculator, fractionalExcretionSodiumCalculator, correctedReticulocyteIndex, estimatedBloodVolumeCalculator, targetHeightEstimator, daltonismSimulator, tinnitusReliever, parametricNoiseSynthesizer, breathingVisualizer, caffeineTracker, waterPurifier, digestionStopwatch, binauralTuner, pelliRobsonTest, peripheralVisionTrainer, epworthSleepinessScale],
   i18n: {
     en: () => import('./i18n/en').then((m) => m.content),
     es: () => import('./i18n/es').then((m) => m.content),

package/src/entries.ts

@@ -20,10 +20,12 @@ export { macronutrientCalculator } from './tool/macronutrientCalculator/entry';
 export { tdeeCalculator } from './tool/tdeeCalculator/entry';
 export { bunCreatinineCalculator } from './tool/bunCreatinineCalculator/entry';
 export { serumOsmolalityCalculator } from './tool/serumOsmolalityCalculator/entry';
+export { meanArterialPressureCalculator } from './tool/meanArterialPressureCalculator/entry';
 export { correctedSodiumHyperglycemiaCalculator } from './tool/correctedSodiumHyperglycemiaCalculator/entry';
 export { fractionalExcretionSodiumCalculator } from './tool/fractionalExcretionSodiumCalculator/entry';
 export { targetHeightEstimator } from './tool/targetHeightEstimator/entry';
 export { correctedReticulocyteIndex } from './tool/correctedReticulocyteIndex/entry';
+export { estimatedBloodVolumeCalculator } from './tool/estimatedBloodVolumeCalculator/entry';
 export { pelliRobsonTest } from './tool/pelliRobsonTest/entry';
 export { peripheralVisionTrainer } from './tool/peripheralVisionTrainer/entry';
 export { readingDistanceCalculator } from './tool/readingDistanceCalculator/entry';
@@ -55,10 +57,12 @@ import { macronutrientCalculator } from './tool/macronutrientCalculator/entry';
 import { tdeeCalculator } from './tool/tdeeCalculator/entry';
 import { bunCreatinineCalculator } from './tool/bunCreatinineCalculator/entry';
 import { serumOsmolalityCalculator } from './tool/serumOsmolalityCalculator/entry';
+import { meanArterialPressureCalculator } from './tool/meanArterialPressureCalculator/entry';
 import { correctedSodiumHyperglycemiaCalculator } from './tool/correctedSodiumHyperglycemiaCalculator/entry';
 import { fractionalExcretionSodiumCalculator } from './tool/fractionalExcretionSodiumCalculator/entry';
 import { targetHeightEstimator } from './tool/targetHeightEstimator/entry';
 import { correctedReticulocyteIndex } from './tool/correctedReticulocyteIndex/entry';
+import { estimatedBloodVolumeCalculator } from './tool/estimatedBloodVolumeCalculator/entry';
 import { pelliRobsonTest } from './tool/pelliRobsonTest/entry';
 import { peripheralVisionTrainer } from './tool/peripheralVisionTrainer/entry';
 import { readingDistanceCalculator } from './tool/readingDistanceCalculator/entry';
@@ -67,4 +71,4 @@ import { tinnitusReliever } from './tool/tinnitusReliever/entry';
 import { parametricNoiseSynthesizer } from './tool/parametricNoiseSynthesizer/entry';
 import { ubeCalculator } from './tool/ubeCalculator/entry';
 import { waterPurifier } from './tool/waterPurifier/entry';
-export const ALL_ENTRIES = [binauralTuner, bloodUnitConverter, bmiCalculator, amputationAdjustedBmiCalculator, bodyAdiposityIndexCalculator, bodyFatPercentageCalculator, waistHipRatioCalculator, waistHeightRatioCalculator, breathingVisualizer, caffeineTracker, caloricDeficitCalculator, dailyProteinCalculator, macronutrientCalculator, tdeeCalculator, bunCreatinineCalculator, serumOsmolalityCalculator, correctedSodiumHyperglycemiaCalculator, fractionalExcretionSodiumCalculator, correctedReticulocyteIndex, targetHeightEstimator, daltonismSimulator, digestionStopwatch, epworthSleepinessScale, hydrationCalculator, leanBodyMassCalculator, metabolicAgeCalculator, pelliRobsonTest, peripheralVisionTrainer, readingDistanceCalculator, screenDecompressionTime, tinnitusReliever, parametricNoiseSynthesizer, ubeCalculator, waterPurifier];
+export const ALL_ENTRIES = [binauralTuner, bloodUnitConverter, bmiCalculator, amputationAdjustedBmiCalculator, bodyAdiposityIndexCalculator, bodyFatPercentageCalculator, waistHipRatioCalculator, waistHeightRatioCalculator, breathingVisualizer, caffeineTracker, caloricDeficitCalculator, dailyProteinCalculator, macronutrientCalculator, tdeeCalculator, bunCreatinineCalculator, serumOsmolalityCalculator, meanArterialPressureCalculator, correctedSodiumHyperglycemiaCalculator, fractionalExcretionSodiumCalculator, correctedReticulocyteIndex, estimatedBloodVolumeCalculator, targetHeightEstimator, daltonismSimulator, digestionStopwatch, epworthSleepinessScale, hydrationCalculator, leanBodyMassCalculator, metabolicAgeCalculator, pelliRobsonTest, peripheralVisionTrainer, readingDistanceCalculator, screenDecompressionTime, tinnitusReliever, parametricNoiseSynthesizer, ubeCalculator, waterPurifier];

package/src/index.ts

@@ -28,10 +28,12 @@ export * from './tool/macronutrientCalculator';
 export * from './tool/tdeeCalculator';
 export * from './tool/bunCreatinineCalculator';
 export * from './tool/serumOsmolalityCalculator';
+export * from './tool/meanArterialPressureCalculator';
 export * from './tool/correctedSodiumHyperglycemiaCalculator';
 export * from './tool/fractionalExcretionSodiumCalculator';
 export * from './tool/targetHeightEstimator';
 export * from './tool/correctedReticulocyteIndex';
+export * from './tool/estimatedBloodVolumeCalculator';
 
 export { healthCategory } from './category';
 export const healthCategorySEO = () => import('./category/seo.astro').then((m) => m.default);

package/src/tests/locale_completeness.test.ts

@@ -36,6 +36,6 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(34);
+    expect(ALL_TOOLS.length).toBe(36);
   });
 });

package/src/tests/tool_validation.test.ts

@@ -5,7 +5,7 @@ import { healthCategory } from '../data';
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
     it('should have 33 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(34);
+      expect(ALL_TOOLS.length).toBe(36);
     });
 
     it('healthCategory should be defined', () => {

package/src/tool/estimatedBloodVolumeCalculator/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography } from '@jjlmoya/utils-shared';
+import { estimatedBloodVolumeCalculator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const content = await estimatedBloodVolumeCalculator.i18n[locale]?.();
+---
+
+{content && <Bibliography links={content.bibliography} />}

package/src/tool/estimatedBloodVolumeCalculator/bibliography.ts

@@ -0,0 +1,20 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'Nadler, Hidalgo, and Bloch: Prediction of blood volume in normal human adults',
+    url: 'https://pubmed.ncbi.nlm.nih.gov/21936146/',
+  },
+  {
+    name: 'Lemmens, Bernstein, and Brodsky: Estimating blood volume in obese and nonobese patients',
+    url: 'https://pubmed.ncbi.nlm.nih.gov/16925381/',
+  },
+  {
+    name: 'Association of Anaesthetists: Management of major haemorrhage',
+    url: 'https://associationofanaesthetists-publications.onlinelibrary.wiley.com/doi/10.1111/anae.14139',
+  },
+  {
+    name: 'Wikipedia: Blood volume',
+    url: 'https://en.wikipedia.org/wiki/Blood_volume',
+  },
+];

package/src/tool/estimatedBloodVolumeCalculator/component.astro

@@ -0,0 +1,350 @@
+---
+import { Icon } from 'astro-icon/components';
+import type { EstimatedBloodVolumeCalculatorUI } from './ui';
+import './estimated-blood-volume-calculator.css';
+
+interface Props {
+  locale?: string;
+  ui?: Record<string, unknown>;
+}
+
+const t = (Astro.props.ui || {}) as EstimatedBloodVolumeCalculatorUI;
+---
+
+<div class="ebv" data-ui={JSON.stringify(t)}>
+  <div class="ebv__panel">
+    <section class="ebv__controls" aria-label={t.inputsAria}>
+      <div class="ebv__unit" role="group" aria-label={t.unitSystemLabel}>
+        <button class="ebv__pill ebv__pill--active" type="button" data-unit="metric">{t.unitMetric}</button>
+        <button class="ebv__pill" type="button" data-unit="imperial">{t.unitImperial}</button>
+      </div>
+
+      <div class="ebv__selector-stack">
+        <div class="ebv__choice-field">
+          <span>{t.sexLabel}</span>
+          <div class="ebv__choice ebv__choice--sex" role="radiogroup" aria-label={t.sexLabel}>
+            <button class="ebv__choice-btn ebv__choice-btn--active" type="button" role="radio" aria-checked="true" data-sex="male">{t.male}</button>
+            <button class="ebv__choice-btn" type="button" role="radio" aria-checked="false" data-sex="female">{t.female}</button>
+          </div>
+        </div>
+        <div class="ebv__choice-field">
+          <span>{t.buildLabel}</span>
+          <div class="ebv__choice ebv__choice--build" role="radiogroup" aria-label={t.buildLabel}>
+            <button class="ebv__choice-btn ebv__choice-btn--active" type="button" role="radio" aria-checked="true" data-build="normal">{t.normal}</button>
+            <button class="ebv__choice-btn" type="button" role="radio" aria-checked="false" data-build="athletic">{t.athletic}</button>
+            <button class="ebv__choice-btn" type="button" role="radio" aria-checked="false" data-build="thin">{t.thin}</button>
+            <button class="ebv__choice-btn" type="button" role="radio" aria-checked="false" data-build="obese">{t.obese}</button>
+          </div>
+        </div>
+      </div>
+
+      <div class="ebv__row ebv__row--metric">
+        <label class="ebv__field">
+          <span>{t.height}</span>
+          <input id="ebv-height-cm" inputmode="decimal" type="number" min="120" max="230" step="1" value="175" />
+        </label>
+        <label class="ebv__field">
+          <span>{t.weight}</span>
+          <input id="ebv-weight-kg" inputmode="decimal" type="number" min="35" max="250" step="0.1" value="80" />
+        </label>
+      </div>
+
+      <div class="ebv__row ebv__row--imperial" hidden>
+        <label class="ebv__field">
+          <span>{t.feet}</span>
+          <input id="ebv-height-ft" inputmode="numeric" type="number" min="3" max="7" step="1" value="5" />
+        </label>
+        <label class="ebv__field">
+          <span>{t.inches}</span>
+          <input id="ebv-height-in" inputmode="decimal" type="number" min="0" max="11.9" step="0.1" value="9" />
+        </label>
+        <label class="ebv__field">
+          <span>{t.weight}</span>
+          <input id="ebv-weight-lb" inputmode="decimal" type="number" min="75" max="550" step="0.1" value="176" />
+        </label>
+      </div>
+
+      <div class="ebv__chips">
+        <span><Icon name="mdi:calculator-variant-outline" /> <strong id="ebv-bmi">26.1</strong> {t.bmi}</span>
+        <span><Icon name="mdi:water-percent" /> <strong id="ebv-factor">70</strong> {t.mlKg}</span>
+      </div>
+
+      <div class="ebv__note">
+        <strong>{t.cautionTitle}</strong>
+        <p>{t.cautionText}</p>
+      </div>
+    </section>
+
+    <section class="ebv__visual" aria-label={t.beakerAria}>
+      <div class="ebv__bag">
+        <div class="ebv__bag-neck"></div>
+        <div class="ebv__bag-body">
+          <div class="ebv__liquid" id="ebv-liquid"></div>
+          <div class="ebv__shine"></div>
+          <div class="ebv__marks">
+            <span>{t.scaleEight}</span><span>{t.scaleSix}</span><span>{t.scaleFour}</span><span>{t.scaleTwo}</span>
+          </div>
+        </div>
+      </div>
+      <div class="ebv__total">
+        <span>{t.fillLabel}</span>
+        <strong id="ebv-average">{t.initialAverage}</strong>
+      </div>
+    </section>
+
+    <section class="ebv__results" aria-label={t.methodComparison}>
+      <div class="ebv__result-card ebv__result-card--primary">
+        <span>{t.nadler}</span>
+        <strong id="ebv-nadler">{t.initialNadler}</strong>
+        <p>{t.nadlerCaption}</p>
+        <div class="ebv__bar"><i id="ebv-nadler-bar"></i></div>
+      </div>
+      <div class="ebv__result-card">
+        <span>{t.lbb}</span>
+        <strong id="ebv-lbb">{t.initialLbb}</strong>
+        <p>{t.lbbCaption}</p>
+        <div class="ebv__bar"><i id="ebv-lbb-bar"></i></div>
+      </div>
+      <div class="ebv__result-card">
+        <span>{t.gilcher}</span>
+        <strong id="ebv-gilcher">{t.initialGilcher}</strong>
+        <p id="ebv-gilcher-caption">{t.gilcherCaption}</p>
+        <div class="ebv__bar"><i id="ebv-gilcher-bar"></i></div>
+      </div>
+      <div class="ebv__method-note">
+        <strong>{t.clinicalUseTitle}</strong>
+        <p>{t.clinicalUseText}</p>
+        <small>{t.methodNote}</small>
+      </div>
+    </section>
+  </div>
+</div>
+
+<script>
+  type Unit = 'metric' | 'imperial';
+  type Sex = 'male' | 'female';
+  type Build = 'athletic' | 'normal' | 'thin' | 'obese';
+
+  interface Elements {
+    unitButtons: NodeListOf<HTMLButtonElement>;
+    metricRow: HTMLElement;
+    imperialRow: HTMLElement;
+    sexButtons: NodeListOf<HTMLButtonElement>;
+    buildButtons: NodeListOf<HTMLButtonElement>;
+    heightCm: HTMLInputElement;
+    weightKg: HTMLInputElement;
+    heightFt: HTMLInputElement;
+    heightIn: HTMLInputElement;
+    weightLb: HTMLInputElement;
+    bmi: HTMLElement;
+    factor: HTMLElement;
+    liquid: HTMLElement;
+    average: HTMLElement;
+    nadler: HTMLElement;
+    lbb: HTMLElement;
+    gilcher: HTMLElement;
+    gilcherCaption: HTMLElement;
+    nadlerBar: HTMLElement;
+    lbbBar: HTMLElement;
+    gilcherBar: HTMLElement;
+  }
+
+  const EBV_STORAGE = 'estimated_blood_volume_state';
+  const factors: Record<Sex, Record<Build, number>> = {
+    male: { athletic: 75, normal: 70, thin: 65, obese: 60 },
+    female: { athletic: 70, normal: 65, thin: 60, obese: 55 },
+  };
+
+  function required<T extends Element>(container: Element, selector: string): T {
+    const element = container.querySelector<T>(selector);
+    if (!element) throw new Error(selector);
+    return element;
+  }
+
+  function getElements(container: Element): Elements | null {
+    try {
+      return {
+        unitButtons: container.querySelectorAll<HTMLButtonElement>('.ebv__pill'),
+        metricRow: required<HTMLElement>(container, '.ebv__row--metric'),
+        imperialRow: required<HTMLElement>(container, '.ebv__row--imperial'),
+        sexButtons: container.querySelectorAll<HTMLButtonElement>('[data-sex]'),
+        buildButtons: container.querySelectorAll<HTMLButtonElement>('[data-build]'),
+        heightCm: required<HTMLInputElement>(container, '#ebv-height-cm'),
+        weightKg: required<HTMLInputElement>(container, '#ebv-weight-kg'),
+        heightFt: required<HTMLInputElement>(container, '#ebv-height-ft'),
+        heightIn: required<HTMLInputElement>(container, '#ebv-height-in'),
+        weightLb: required<HTMLInputElement>(container, '#ebv-weight-lb'),
+        bmi: required<HTMLElement>(container, '#ebv-bmi'),
+        factor: required<HTMLElement>(container, '#ebv-factor'),
+        liquid: required<HTMLElement>(container, '#ebv-liquid'),
+        average: required<HTMLElement>(container, '#ebv-average'),
+        nadler: required<HTMLElement>(container, '#ebv-nadler'),
+        lbb: required<HTMLElement>(container, '#ebv-lbb'),
+        gilcher: required<HTMLElement>(container, '#ebv-gilcher'),
+        gilcherCaption: required<HTMLElement>(container, '#ebv-gilcher-caption'),
+        nadlerBar: required<HTMLElement>(container, '#ebv-nadler-bar'),
+        lbbBar: required<HTMLElement>(container, '#ebv-lbb-bar'),
+        gilcherBar: required<HTMLElement>(container, '#ebv-gilcher-bar'),
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  function kgToLb(kg: number): number {
+    return kg * 2.2046226218;
+  }
+
+  function lbToKg(lb: number): number {
+    return lb / 2.2046226218;
+  }
+
+  function cmToImperial(cm: number): { ft: number; inch: number } {
+    const total = cm / 2.54;
+    const ft = Math.floor(total / 12);
+    return { ft, inch: Math.round((total - ft * 12) * 10) / 10 };
+  }
+
+  function imperialToCm(ft: number, inch: number): number {
+    return (ft * 12 + inch) * 2.54;
+  }
+
+  function calculate(sex: Sex, build: Build, heightCm: number, weightKg: number) {
+    const heightM = heightCm / 100;
+    const bmi = weightKg / heightM ** 2;
+    const nadler = sex === 'male'
+      ? 0.3669 * heightM ** 3 + 0.03219 * weightKg + 0.6041
+      : 0.3561 * heightM ** 3 + 0.03308 * weightKg + 0.1833;
+    const lbb = weightKg * (70 / Math.sqrt(bmi / 22)) / 1000;
+    const factor = factors[sex][build];
+    const gilcher = weightKg * factor / 1000;
+    return { bmi, nadler, lbb, gilcher, factor, average: (nadler + lbb + gilcher) / 3 };
+  }
+
+  function formatL(value: number, ui: Record<string, string>): string {
+    return `${value.toFixed(2)} ${ui.liters}`;
+  }
+
+  function getActiveUnit(elements: Elements): Unit {
+    return Array.from(elements.unitButtons).find((button) => button.classList.contains('ebv__pill--active'))?.dataset.unit as Unit || 'metric';
+  }
+
+  function getActiveSex(elements: Elements): Sex {
+    return Array.from(elements.sexButtons).find((button) => button.classList.contains('ebv__choice-btn--active'))?.dataset.sex as Sex || 'male';
+  }
+
+  function getActiveBuild(elements: Elements): Build {
+    return Array.from(elements.buildButtons).find((button) => button.classList.contains('ebv__choice-btn--active'))?.dataset.build as Build || 'normal';
+  }
+
+  function getPatientMetrics(elements: Elements, unit: Unit): { heightCm: number; weightKg: number } {
+    if (unit === 'metric') {
+      return { heightCm: Number(elements.heightCm.value), weightKg: Number(elements.weightKg.value) };
+    }
+
+    return {
+      heightCm: imperialToCm(Number(elements.heightFt.value), Number(elements.heightIn.value)),
+      weightKg: lbToKg(Number(elements.weightLb.value)),
+    };
+  }
+
+  function render(elements: Elements, ui: Record<string, string>) {
+    const unit = getActiveUnit(elements);
+    const { heightCm, weightKg } = getPatientMetrics(elements, unit);
+    const sex = getActiveSex(elements);
+    const build = getActiveBuild(elements);
+    const result = calculate(sex, build, heightCm, weightKg);
+    const max = Math.max(8, result.nadler, result.lbb, result.gilcher);
+
+    elements.bmi.textContent = result.bmi.toFixed(1);
+    elements.factor.textContent = String(result.factor);
+    elements.average.textContent = formatL(result.average, ui);
+    elements.nadler.textContent = formatL(result.nadler, ui);
+    elements.lbb.textContent = formatL(result.lbb, ui);
+    elements.gilcher.textContent = formatL(result.gilcher, ui);
+    elements.gilcherCaption.textContent = `${ui.gilcherCaption} ${result.factor} ${ui.mlKg}.`;
+    elements.liquid.style.height = `${Math.min(100, (result.average / 8) * 100)}%`;
+    elements.nadlerBar.style.width = `${Math.min(100, (result.nadler / max) * 100)}%`;
+    elements.lbbBar.style.width = `${Math.min(100, (result.lbb / max) * 100)}%`;
+    elements.gilcherBar.style.width = `${Math.min(100, (result.gilcher / max) * 100)}%`;
+
+    try {
+      window.localStorage.setItem(EBV_STORAGE, JSON.stringify({ unit, sex, build, heightCm, weightKg }));
+    } catch {
+    }
+  }
+
+  function setUnit(elements: Elements, nextUnit: Unit) {
+    const heightCm = elements.metricRow.hidden
+      ? imperialToCm(Number(elements.heightFt.value), Number(elements.heightIn.value))
+      : Number(elements.heightCm.value);
+    const weightKg = elements.metricRow.hidden ? lbToKg(Number(elements.weightLb.value)) : Number(elements.weightKg.value);
+    elements.unitButtons.forEach((button) => button.classList.toggle('ebv__pill--active', button.dataset.unit === nextUnit));
+    elements.metricRow.hidden = nextUnit !== 'metric';
+    elements.imperialRow.hidden = nextUnit !== 'imperial';
+
+    if (nextUnit === 'metric') {
+      elements.heightCm.value = String(Math.round(heightCm));
+      elements.weightKg.value = String(Math.round(weightKg * 10) / 10);
+    } else {
+      const imperialHeight = cmToImperial(heightCm);
+      elements.heightFt.value = String(imperialHeight.ft);
+      elements.heightIn.value = String(imperialHeight.inch);
+      elements.weightLb.value = String(Math.round(kgToLb(weightKg) * 10) / 10);
+    }
+  }
+
+  function restore(elements: Elements) {
+    try {
+      const saved = JSON.parse(window.localStorage.getItem(EBV_STORAGE) || '{}') as Partial<{ unit: Unit; sex: Sex; build: Build; heightCm: number; weightKg: number }>;
+      if (saved.sex) setChoice(elements.sexButtons, saved.sex, 'sex');
+      if (saved.build) setChoice(elements.buildButtons, saved.build, 'build');
+      if (saved.heightCm) elements.heightCm.value = String(Math.round(saved.heightCm));
+      if (saved.weightKg) elements.weightKg.value = String(Math.round(saved.weightKg * 10) / 10);
+      setUnit(elements, saved.unit === 'imperial' ? 'imperial' : 'metric');
+    } catch {
+      setUnit(elements, 'metric');
+    }
+  }
+
+  function setChoice(buttons: NodeListOf<HTMLButtonElement>, value: string, key: 'sex' | 'build') {
+    buttons.forEach((button) => {
+      const active = button.dataset[key] === value;
+      button.classList.toggle('ebv__choice-btn--active', active);
+      button.setAttribute('aria-checked', active ? 'true' : 'false');
+    });
+  }
+
+  function initEBV(container: Element) {
+    const ui = JSON.parse((container as HTMLElement).dataset.ui || '{}') as Record<string, string>;
+    const elements = getElements(container);
+    if (!elements) return;
+    restore(elements);
+    const update = () => render(elements, ui);
+    elements.unitButtons.forEach((button) => {
+      button.addEventListener('click', () => {
+        setUnit(elements, button.dataset.unit === 'imperial' ? 'imperial' : 'metric');
+        update();
+      });
+    });
+    elements.sexButtons.forEach((button) => {
+      button.addEventListener('click', () => {
+        setChoice(elements.sexButtons, button.dataset.sex || 'male', 'sex');
+        update();
+      });
+    });
+    elements.buildButtons.forEach((button) => {
+      button.addEventListener('click', () => {
+        setChoice(elements.buildButtons, button.dataset.build || 'normal', 'build');
+        update();
+      });
+    });
+    [elements.heightCm, elements.weightKg, elements.heightFt, elements.heightIn, elements.weightLb].forEach((element) => {
+      element.addEventListener('input', update);
+      element.addEventListener('change', update);
+    });
+    update();
+  }
+
+  document.querySelectorAll('.ebv').forEach(initEBV);
+</script>

package/src/tool/estimatedBloodVolumeCalculator/entry.ts

@@ -0,0 +1,27 @@
+import type { HealthToolEntry } from '../../types';
+import type { EstimatedBloodVolumeCalculatorUI } from './ui';
+
+export const estimatedBloodVolumeCalculator: HealthToolEntry<EstimatedBloodVolumeCalculatorUI> = {
+  id: 'estimatedBloodVolumeCalculator',
+  icons: {
+    bg: 'mdi:blood-bag',
+    fg: 'mdi:beaker-outline',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};