+ {showBackButton && (
+
+
+ )}
TES
diff --git a/src/components/tools/DripRateCalculator.tsx b/src/components/tools/DripRateCalculator.tsx
new file mode 100644
index 00000000..3059e16c
--- /dev/null
+++ b/src/components/tools/DripRateCalculator.tsx
@@ -0,0 +1,182 @@
+import { useState } from 'react';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
+import { Info } from 'lucide-react';
+
+const DripRateCalculator = () => {
+ const [volume, setVolume] = useState
('');
+ const [time, setTime] = useState('');
+ const [dripFactor, setDripFactor] = useState('20');
+ const [calculationType, setCalculationType] = useState<'drops' | 'mlh'>('drops');
+
+ const volumeNum = parseFloat(volume) || 0;
+ const timeNum = parseFloat(time) || 0;
+ const factorNum = parseFloat(dripFactor) || 20;
+
+ const isValid = volumeNum > 0 && timeNum > 0 && factorNum > 0;
+
+ // Cálculo de gotas/minuto
+ const calculateDropsPerMinute = (): number => {
+ if (!isValid) return 0;
+ const timeInMinutes = timeNum;
+ return (volumeNum * factorNum) / timeInMinutes;
+ };
+
+ // Cálculo de ml/hora
+ const calculateMlPerHour = (): number => {
+ if (!isValid) return 0;
+ const timeInHours = timeNum / 60;
+ return volumeNum / timeInHours;
+ };
+
+ const dropsPerMin = isValid ? calculateDropsPerMinute() : 0;
+ const mlPerHour = isValid ? calculateMlPerHour() : 0;
+
+ return (
+
+
+ 💉 Calculadora de Goteo
+
+
+
+ {/* Información */}
+
+
+
+
+
Fórmulas:
+
Gotas/min: (Volumen × Factor goteo) / Tiempo (min)
+
ml/h: Volumen / Tiempo (h)
+
+ Factor goteo: 20 gotas/ml (macrogoteo) o 60 gotas/ml (microgoteo)
+
+
+
+
+
+ {/* Tipo de cálculo */}
+
+
+ Tipo de Cálculo
+
+ setCalculationType(v as 'drops' | 'mlh')}>
+
+
+
+ Gotas por minuto
+ Mililitros por hora
+
+
+
+
+ {/* Volumen */}
+
+
+ Volumen Total (ml)
+
+
+
+ {/* Tiempo */}
+
+
+ Tiempo de Infusión ({calculationType === 'drops' ? 'minutos' : 'minutos'})
+
+
setTime(e.target.value)}
+ className="w-full"
+ min="0"
+ step="1"
+ />
+
+ {calculationType === 'drops'
+ ? 'Tiempo total en minutos para administrar el volumen'
+ : 'Tiempo total en minutos (se convertirá a horas)'}
+
+
+
+ {/* Factor de goteo (solo para gotas/min) */}
+ {calculationType === 'drops' && (
+
+
+ Factor de Goteo (gotas/ml)
+
+
+
+
+
+ 20 gotas/ml (Macrogoteo)
+ 60 gotas/ml (Microgoteo)
+ 15 gotas/ml (Algunos sistemas)
+
+
+
+ )}
+
+ {/* Resultados */}
+ {isValid && (
+
+ {calculationType === 'drops' ? (
+
+
Velocidad de Goteo
+
+ {Math.round(dropsPerMin)} gotas/min
+
+
+ Equivalente: {mlPerHour.toFixed(1)} ml/h
+
+
+ ) : (
+
+
Velocidad de Infusión
+
+ {mlPerHour.toFixed(1)} ml/h
+
+
+ Con factor {factorNum} gotas/ml: {Math.round((mlPerHour * factorNum) / 60)} gotas/min
+
+
+ )}
+
+ {/* Información adicional */}
+
+
+ Cálculo: {volumeNum} ml ÷ {timeNum} min = {mlPerHour.toFixed(2)} ml/h
+ {calculationType === 'drops' && ` × ${factorNum} gotas/ml = ${Math.round(dropsPerMin)} gotas/min`}
+
+
+
+ )}
+
+ {/* Mensaje cuando faltan datos */}
+ {!isValid && (volume || time) && (
+
+
+ Por favor, completa todos los campos con valores válidos
+
+
+ )}
+
+
('');
+ const [currentPressure, setCurrentPressure] = useState('');
+ const [flowRate, setFlowRate] = useState('');
+
+ const bottle = bottleSizes.find((b) => b.id === selectedBottle);
+ const pressureNum = parseFloat(currentPressure) || 0;
+ const flowNum = parseFloat(flowRate) || 0;
+
+ const isValid = bottle && pressureNum > 0 && pressureNum <= bottle.pressure && flowNum > 0 && flowNum <= 15;
+
+ // Fórmula: Tiempo (minutos) = (Presión actual / Presión llena) × Capacidad (L) / Flujo (L/min)
+ const calculateDuration = (): number => {
+ if (!bottle || !isValid) return 0;
+ const pressureRatio = pressureNum / bottle.pressure;
+ const availableLiters = bottle.capacity * pressureRatio;
+ return availableLiters / flowNum;
+ };
+
+ const duration = isValid ? calculateDuration() : 0;
+ const durationHours = Math.floor(duration / 60);
+ const durationMinutes = Math.floor(duration % 60);
+
+ return (
+
+
+ 💨 Calculadora de Duración de Botella de Oxígeno
+
+
+
+ {/* Información */}
+
+
+
+
+
Fórmula:
+
Tiempo = (Presión actual / Presión llena) × Capacidad (L) / Flujo (L/min)
+
Presión estándar: 2000 PSI (botellas D, E, M, G) o 2200 PSI (botella H)
+
+
+
+
+ {/* Selección de botella */}
+
+
+ Tamaño de Botella
+
+
+
+
+
+ {bottleSizes.map((b) => (
+
+ {b.name} - {b.capacity}L @ {b.pressure} PSI
+
+ ))}
+
+
+
+
+ {/* Presión actual */}
+
+
+ Presión Actual (PSI)
+
+
setCurrentPressure(e.target.value)}
+ className="w-full"
+ min="0"
+ max={bottle ? bottle.pressure : 2200}
+ step="50"
+ />
+ {bottle && (
+
+ Presión máxima: {bottle.pressure} PSI
+
+ )}
+
+
+ {/* Flujo */}
+
+
+ Flujo de Oxígeno (L/min)
+
+
setFlowRate(e.target.value)}
+ className="w-full"
+ min="0"
+ max="15"
+ step="0.5"
+ />
+
+ Rango típico: 1-15 L/min
+
+
+
+ {/* Resultado */}
+ {isValid && duration > 0 && (
+
+
+
Duración Estimada
+
+ {durationHours > 0 && `${durationHours}h `}
+ {durationMinutes} min
+
+
+ ≈ {duration.toFixed(1)} minutos totales
+
+
+
+ {/* Advertencias */}
+ {duration < 30 && (
+
+
+
+
+ ⚠️ Botella con poca duración. Considerar cambio o reducir flujo si es posible.
+
+
+
+ )}
+
+ {/* Información adicional */}
+
+
+ Nota: Este cálculo es una estimación. La duración real puede variar según temperatura,
+ uso intermitente y otros factores. Verificar presión periódicamente durante el uso.
+
+
+
+ )}
+
+ {/* Mensaje cuando faltan datos */}
+ {!isValid && (selectedBottle || currentPressure || flowRate) && (
+
+
+ Por favor, completa todos los campos con valores válidos
+
+
+ )}
+
+
('');
+ const [burnPercentage, setBurnPercentage] = useState('');
+ const [hoursSinceBurn, setHoursSinceBurn] = useState('');
+
+ const weightNum = parseFloat(weight) || 0;
+ const burnPercentNum = parseFloat(burnPercentage) || 0;
+ const hoursNum = parseFloat(hoursSinceBurn) || 0;
+
+ const isValid = weightNum > 0 && burnPercentNum > 0 && burnPercentNum <= 100 && hoursNum >= 0;
+ const result = isValid ? calculateParkland(weightNum, burnPercentNum, hoursNum) : null;
+
+ return (
+
+
+ 🔥 Fórmula de Parkland (Quemados)
+
+
+
+ {/* Información sobre la fórmula */}
+
+
+
+
+
Fórmula de Parkland:
+
4 ml × peso (kg) × % superficie corporal quemada
+
Aplicable para quemaduras >20% SCQ en adultos
+
+
+
+
+ {/* Inputs */}
+
+
+
+ Peso del paciente (kg)
+
+
+
+
+
+ Superficie Corporal Quemada (%)
+
+
setBurnPercentage(e.target.value)}
+ className="w-full"
+ min="0"
+ max="100"
+ step="0.1"
+ />
+
+ Usar regla de los 9 o palma de la mano (1% SCQ)
+
+
+
+
+
+ Tiempo desde la quemadura (horas)
+
+ setHoursSinceBurn(e.target.value)}
+ className="w-full"
+ min="0"
+ step="0.5"
+ />
+
+
+
+ {/* Resultados */}
+ {result && (
+
+ {/* Total de líquidos en 24h */}
+
+
Total de líquidos en primeras 24h
+
+ {result.total24h.toLocaleString('es-ES', { maximumFractionDigits: 0 })} ml
+
+
+ ≈ {result.total24hLiters.toFixed(1)} litros
+
+
+
+ {/* Distribución según tiempo */}
+ {hoursNum < 8 ? (
+
+
+
+
+ {result.first8h.toLocaleString('es-ES', { maximumFractionDigits: 0 })} ml
+
+
+ Velocidad: {result.rateFirst8h.toFixed(1)} ml/h
+
+ {hoursNum > 0 && (
+
+ Ya transcurridas: {hoursNum.toFixed(1)}h | Restante: {(8 - hoursNum).toFixed(1)}h
+
+ )}
+
+
+
+
Siguientes 16 horas
+
+ {result.next16h.toLocaleString('es-ES', { maximumFractionDigits: 0 })} ml
+
+
+ Velocidad: {result.rateNext16h.toFixed(1)} ml/h
+
+
+
+ ) : hoursNum < 24 ? (
+
+
Restante de primeras 24h
+
+ {result.remaining24h.toLocaleString('es-ES', { maximumFractionDigits: 0 })} ml
+
+
+ En {(24 - hoursNum).toFixed(1)} horas restantes
+
+
+ ) : (
+
+
+
+
Pasadas primeras 24h
+
+
+ Mantenimiento según necesidades: ~{result.maintenance.toLocaleString('es-ES')} ml/día
+
+
+ Considerar pérdidas por evaporación y necesidades basales
+
+
+ )}
+
+ {/* Advertencias */}
+
+
+
⚠️ Consideraciones importantes:
+
+ Usar Ringer Lactato como solución de elección
+ Monitorizar diuresis objetivo: 0.5-1 ml/kg/h
+ Ajustar según respuesta clínica y analítica
+ En pediatría: añadir glucosa al mantenimiento
+ {burnPercentNum < 20 && (
+
+ Quemaduras <20% pueden requerir menos líquidos
+
+ )}
+
+
+
+
+ )}
+
+ {/* Mensaje cuando faltan datos */}
+ {!isValid && (weight || burnPercentage || hoursSinceBurn) && (
+
+
+ Por favor, completa todos los campos con valores válidos
+
+
+ )}
+
+
('');
+ const [weight, setWeight] = useState('');
+
+ const selectedDrug = pediatricDrugs.find((d) => d.id === selectedDrugId);
+ const weightNum = parseFloat(weight) || 0;
+ const isValid = selectedDrug && weightNum > 0 && weightNum <= 200;
+
+ const result = isValid && selectedDrug
+ ? calculatePediatricDose(selectedDrug, weightNum)
+ : null;
+
+ return (
+
+
+ ⚖️ Dosis Pediátricas por Peso
+
+
+
+ {/* Información importante */}
+
+
+
+
+
⚠️ CRÍTICO:
+
En pediatría, SIEMPRE calcular dosis por peso. Un error decimal puede ser grave.
+
Verificar cálculo con compañero antes de administrar.
+
+
+
+
+ {/* Selección de fármaco */}
+
+
+ Fármaco
+
+
+
+
+
+ {pediatricDrugs.map((drug) => (
+
+ {drug.name} - {drug.indication}
+
+ ))}
+
+
+
+
+ {/* Información del fármaco seleccionado */}
+ {selectedDrug && (
+
+
+
{selectedDrug.name}
+
+ {selectedDrug.route}
+
+
+
+ Presentación: {selectedDrug.presentation}
+
+
+ Concentración: {selectedDrug.concentration}
+
+
+ Dosis: {selectedDrug.dosePerKg}
+ {selectedDrug.maxDose && ` (máx: ${selectedDrug.maxDose})`}
+ {selectedDrug.minDose && ` (mín: ${selectedDrug.minDose})`}
+
+ {selectedDrug.warning && (
+
+ {selectedDrug.warning}
+
+ )}
+
+ )}
+
+ {/* Input de peso */}
+
+
+ Peso del paciente (kg)
+
+
setWeight(e.target.value)}
+ className="w-full"
+ min="0"
+ max="200"
+ step="0.1"
+ />
+
+ Si no se conoce el peso exacto, usar estimación por edad o Broselow si está disponible
+
+
+
+ {/* Resultados */}
+ {result && result.isValid && selectedDrug && (
+
+ {/* Resultado principal */}
+
+
+
+
+
Dosis en mg
+
+ {result.doseMg.toFixed(2)} mg
+
+
+
+
Volumen en ml
+
+ {result.doseMl.toFixed(3)} ml
+
+
+
+
+
+ {/* Advertencia si hay */}
+ {result.warning && (
+
+ )}
+
+ {/* Información adicional */}
+
+
+
Cálculo:
+
+ {weightNum} kg × {selectedDrug.dosePerKg} = {result.doseMg.toFixed(2)} mg
+
+
+ {result.doseMg.toFixed(2)} mg ÷ {selectedDrug.concentration} = {result.doseMl.toFixed(3)} ml
+
+
+
+ {/* Notas del fármaco */}
+ {selectedDrug.notes && selectedDrug.notes.length > 0 && (
+
+
+
+
+
Notas importantes:
+
+ {selectedDrug.notes.map((note, idx) => (
+ {note}
+ ))}
+
+
+
+
+ )}
+
+ {/* Advertencia general */}
+
+
⚠️ Verificación obligatoria:
+
+ Verificar cálculo con compañero antes de preparar
+ Leer etiqueta del fármaco en voz alta
+ Confirmar concentración y presentación
+ Documentar dosis exacta en mg y ml (no "1 ampolla")
+
+
+
+
+ )}
+
+ {/* Mensaje cuando faltan datos */}
+ {!isValid && (selectedDrugId || weight) && (
+
+
+ Por favor, selecciona un fármaco e ingresa un peso válido (0-200 kg)
+
+
+ )}
+
+
(null);
+ const audioRef = useRef(null);
+
+ // Ciclo de RCP: 2 minutos = 120 segundos
+ const CYCLE_DURATION = 120;
+
+ useEffect(() => {
+ if (isRunning) {
+ intervalRef.current = setInterval(() => {
+ setElapsedTime((prev) => {
+ const newTime = prev + 1;
+ const cycleTime = newTime - lastCycleTime;
+
+ // Alerta cada 2 minutos (cambio de reanimador)
+ if (cycleTime >= CYCLE_DURATION) {
+ setCycles((prev) => prev + 1);
+ setLastCycleTime(newTime);
+ playAlert();
+ }
+
+ return newTime;
+ });
+ }, 1000);
+ } else {
+ if (intervalRef.current) {
+ clearInterval(intervalRef.current);
+ }
+ }
+
+ return () => {
+ if (intervalRef.current) {
+ clearInterval(intervalRef.current);
+ }
+ };
+ }, [isRunning, lastCycleTime]);
+
+ const playAlert = () => {
+ // Crear audio para alerta (usando Web Audio API)
+ if (typeof Audio !== 'undefined') {
+ const audioContext = new (window.AudioContext || (window as any).webkitAudioContext)();
+ const oscillator = audioContext.createOscillator();
+ const gainNode = audioContext.createGain();
+
+ oscillator.connect(gainNode);
+ gainNode.connect(audioContext.destination);
+
+ oscillator.frequency.value = 800;
+ oscillator.type = 'sine';
+
+ gainNode.gain.setValueAtTime(0.3, audioContext.currentTime);
+ gainNode.gain.exponentialRampToValueAtTime(0.01, audioContext.currentTime + 0.5);
+
+ oscillator.start(audioContext.currentTime);
+ oscillator.stop(audioContext.currentTime + 0.5);
+ }
+ };
+
+ const handleStart = () => {
+ setIsRunning(true);
+ if (elapsedTime === 0) {
+ setLastCycleTime(0);
+ }
+ };
+
+ const handlePause = () => {
+ setIsRunning(false);
+ };
+
+ const handleReset = () => {
+ setIsRunning(false);
+ setElapsedTime(0);
+ setCycles(0);
+ setLastCycleTime(0);
+ };
+
+ const formatTime = (seconds: number): string => {
+ const mins = Math.floor(seconds / 60);
+ const secs = seconds % 60;
+ return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+ };
+
+ const cycleTime = elapsedTime - lastCycleTime;
+ const timeUntilNextCycle = CYCLE_DURATION - cycleTime;
+ const progress = (cycleTime / CYCLE_DURATION) * 100;
+
+ return (
+
+
+ ⏱️ Temporizador de RCP
+
+
+
+ {/* Información */}
+
+
+
+
+
Ciclos de RCP:
+
Cada 2 minutos (120 segundos) se debe cambiar de reanimador para mantener calidad de compresiones.
+
+
+
+
+ {/* Tiempo principal */}
+
+
+
+ {formatTime(elapsedTime)}
+
+
+ Ciclos completados: {cycles}
+
+
+
+ {/* Progreso del ciclo actual */}
+ {isRunning && (
+
+
+ Tiempo hasta cambio de reanimador
+
+ {formatTime(timeUntilNextCycle)}
+
+
+
+ {timeUntilNextCycle <= 10 && timeUntilNextCycle > 0 && (
+
+
+
+
+ ¡Cambio de reanimador en {timeUntilNextCycle} segundos!
+
+
+
+ )}
+
+ )}
+
+ {/* Controles */}
+
+ {!isRunning ? (
+
+
+ ) : (
+
+
+ )}
+
+
+
+
+ {/* Instrucciones */}
+
+
+ Uso: Iniciar cuando comience RCP. El temporizador alertará cada 2 minutos para cambio de reanimador.
+ Pausar durante desfibrilación si es necesario.
+
+
+
+
+ {label}
+
+ );
+};
+
+export default BackButton;
diff --git a/src/data/calculators.ts b/src/data/calculators.ts
index 322fad17..9af0e2e6 100644
--- a/src/data/calculators.ts
+++ b/src/data/calculators.ts
@@ -98,4 +98,85 @@ export const infusionTables: InfusionTable[] = [
{ weight: 100, doses: { '0.1 mcg/kg/min': '7.5', '0.2 mcg/kg/min': '15', '0.3 mcg/kg/min': '22.5', '0.5 mcg/kg/min': '37.5' } },
],
},
+ {
+ id: 'adrenalina',
+ name: 'Perfusión Adrenalina',
+ drugName: 'Adrenalina',
+ preparation: '1mg en 100ml SG5% = 10 mcg/ml',
+ unit: 'ml/h',
+ doseRange: '0.05-0.5 mcg/kg/min',
+ columns: ['0.1 mcg/kg/min', '0.2 mcg/kg/min', '0.3 mcg/kg/min', '0.5 mcg/kg/min'],
+ rows: [
+ { weight: 50, doses: { '0.1 mcg/kg/min': '30', '0.2 mcg/kg/min': '60', '0.3 mcg/kg/min': '90', '0.5 mcg/kg/min': '150' } },
+ { weight: 60, doses: { '0.1 mcg/kg/min': '36', '0.2 mcg/kg/min': '72', '0.3 mcg/kg/min': '108', '0.5 mcg/kg/min': '180' } },
+ { weight: 70, doses: { '0.1 mcg/kg/min': '42', '0.2 mcg/kg/min': '84', '0.3 mcg/kg/min': '126', '0.5 mcg/kg/min': '210' } },
+ { weight: 80, doses: { '0.1 mcg/kg/min': '48', '0.2 mcg/kg/min': '96', '0.3 mcg/kg/min': '144', '0.5 mcg/kg/min': '240' } },
+ { weight: 90, doses: { '0.1 mcg/kg/min': '54', '0.2 mcg/kg/min': '108', '0.3 mcg/kg/min': '162', '0.5 mcg/kg/min': '270' } },
+ { weight: 100, doses: { '0.1 mcg/kg/min': '60', '0.2 mcg/kg/min': '120', '0.3 mcg/kg/min': '180', '0.5 mcg/kg/min': '300' } },
+ ],
+ },
];
+
+/**
+ * Calcula la reposición de líquidos según la Fórmula de Parkland para quemaduras
+ * @param weight Peso del paciente en kg
+ * @param burnPercentage Porcentaje de superficie corporal quemada (0-100)
+ * @param hoursSinceBurn Horas transcurridas desde la quemadura
+ * @returns Objeto con los cálculos de líquidos
+ */
+export const calculateParkland = (
+ weight: number,
+ burnPercentage: number,
+ hoursSinceBurn: number = 0
+): {
+ total24h: number;
+ total24hLiters: number;
+ first8h: number;
+ next16h: number;
+ rateFirst8h: number;
+ rateNext16h: number;
+ remaining24h: number;
+ maintenance: number;
+} => {
+ // Fórmula de Parkland: 4 ml × peso (kg) × % SCQ
+ const total24h = 4 * weight * burnPercentage;
+ const total24hLiters = total24h / 1000;
+
+ // Distribución: 50% en primeras 8h, 50% en siguientes 16h
+ const first8h = total24h * 0.5;
+ const next16h = total24h * 0.5;
+
+ // Velocidades de infusión
+ const rateFirst8h = first8h / 8; // ml/h
+ const rateNext16h = next16h / 16; // ml/h
+
+ // Calcular líquidos restantes si ya pasaron horas
+ let remaining24h = total24h;
+ if (hoursSinceBurn < 8) {
+ // Aún en primeras 8h
+ const alreadyGiven = (hoursSinceBurn / 8) * first8h;
+ remaining24h = total24h - alreadyGiven;
+ } else if (hoursSinceBurn < 24) {
+ // Pasadas primeras 8h, calcular restante
+ const remainingHours = 24 - hoursSinceBurn;
+ remaining24h = (remainingHours / 16) * next16h;
+ } else {
+ // Pasadas 24h, solo mantenimiento
+ remaining24h = 0;
+ }
+
+ // Mantenimiento después de 24h: ~2000-2500 ml/día + pérdidas por evaporación
+ // Estimación conservadora: 30-50 ml/kg/día para quemaduras extensas
+ const maintenance = weight * 40; // ml/día
+
+ return {
+ total24h: Math.round(total24h),
+ total24hLiters: total24hLiters,
+ first8h: Math.round(first8h),
+ next16h: Math.round(next16h),
+ rateFirst8h,
+ rateNext16h,
+ remaining24h: Math.round(remaining24h),
+ maintenance: Math.round(maintenance),
+ };
+};
diff --git a/src/data/pediatric-drugs.ts b/src/data/pediatric-drugs.ts
new file mode 100644
index 00000000..ebf92f52
--- /dev/null
+++ b/src/data/pediatric-drugs.ts
@@ -0,0 +1,239 @@
+/**
+ * Fármacos comunes con dosis pediátricas para calculadora
+ */
+
+export interface PediatricDrug {
+ id: string;
+ name: string;
+ presentation: string;
+ concentration: string; // Ej: "1 mg/ml" o "150 mg/3 ml"
+ dosePerKg: string; // Ej: "0.01 mg/kg" o "5 mg/kg"
+ maxDose?: string; // Dosis máxima
+ minDose?: string; // Dosis mínima
+ route: string;
+ indication: string;
+ notes?: string[];
+ warning?: string;
+}
+
+export const pediatricDrugs: PediatricDrug[] = [
+ {
+ id: 'adrenalina-anafilaxia',
+ name: 'Adrenalina (Anafilaxia)',
+ presentation: 'Ampolla 1 mg/1 ml (1:1000)',
+ concentration: '1 mg/ml',
+ dosePerKg: '0.01 mg/kg',
+ maxDose: '0.5 mg',
+ route: 'IM',
+ indication: 'Anafilaxia grave',
+ notes: [
+ 'Sitio IM: tercio medio del vasto externo (muslo lateral)',
+ 'Repetir a los 5 min si no mejora',
+ 'Efectos adversos esperados (temblor, taquicardia) son normales',
+ ],
+ warning: '⚠️ CONCENTRACIÓN CRÍTICA: Usar ampolla 1:1000 (1 mg/ml) para IM',
+ },
+ {
+ id: 'adrenalina-pcr',
+ name: 'Adrenalina (PCR)',
+ presentation: 'Ampolla 1 mg/10 ml (1:10.000)',
+ concentration: '0.1 mg/ml',
+ dosePerKg: '0.01 mg/kg',
+ route: 'IV/IO',
+ indication: 'Parada cardiorrespiratoria',
+ notes: [
+ 'Administrar durante pausa mínima en compresiones',
+ 'Lavado con 20 ml SSF',
+ 'Repetir cada 3-5 minutos',
+ ],
+ warning: '⚠️ CONCENTRACIÓN CRÍTICA: Usar ampolla 1:10.000 (0.1 mg/ml) para IV/IO',
+ },
+ {
+ id: 'amiodarona',
+ name: 'Amiodarona',
+ presentation: 'Ampolla 150 mg/3 ml',
+ concentration: '50 mg/ml',
+ dosePerKg: '5 mg/kg',
+ maxDose: '300 mg',
+ route: 'IV/IO',
+ indication: 'FV/TVSP refractaria',
+ notes: [
+ 'Diluir en SG5% (precipita con SSF)',
+ 'Segunda dosis: 150 mg si persiste FV/TVSP',
+ ],
+ },
+ {
+ id: 'atropina',
+ name: 'Atropina',
+ presentation: 'Ampolla 1 mg/1 ml',
+ concentration: '1 mg/ml',
+ dosePerKg: '0.02 mg/kg',
+ minDose: '0.1 mg',
+ maxDose: '0.5 mg',
+ route: 'IV/IO',
+ indication: 'Bradicardia sintomática',
+ notes: [
+ 'Dosis <0.5 mg pueden causar bradicardia paradójica',
+ 'Repetir cada 3-5 min si es necesario',
+ ],
+ },
+ {
+ id: 'midazolam-crisis',
+ name: 'Midazolam (Crisis)',
+ presentation: 'Ampolla 5 mg/1 ml o 10 mg/2 ml',
+ concentration: '5 mg/ml',
+ dosePerKg: '0.2-0.3 mg/kg',
+ maxDose: '10 mg',
+ route: 'Intranasal/Bucal',
+ indication: 'Crisis convulsiva',
+ notes: [
+ 'Vía intranasal o bucal preferida en pediatría',
+ 'Monitorizar respiración',
+ ],
+ },
+ {
+ id: 'salbutamol-nebulizacion',
+ name: 'Salbutamol (Nebulización)',
+ presentation: 'Ampolla 2.5 mg/2.5 ml',
+ concentration: '1 mg/ml',
+ dosePerKg: '0.15 mg/kg',
+ route: 'Nebulizado',
+ indication: 'Crisis asmática / Broncoespasmo',
+ notes: [
+ '<20 kg: 2.5 mg',
+ '≥20 kg: 5 mg',
+ 'Repetir cada 20 min si es necesario',
+ ],
+ },
+ {
+ id: 'furosemida',
+ name: 'Furosemida',
+ presentation: 'Ampolla 20 mg/2 ml',
+ concentration: '10 mg/ml',
+ dosePerKg: '1-2 mg/kg',
+ maxDose: '40 mg',
+ route: 'IV/IO',
+ indication: 'Edema pulmonar / Insuficiencia cardíaca',
+ notes: [
+ 'Administrar lentamente',
+ 'Monitorizar diuresis',
+ ],
+ },
+ {
+ id: 'morfina',
+ name: 'Morfina',
+ presentation: 'Ampolla 10 mg/1 ml',
+ concentration: '10 mg/ml',
+ dosePerKg: '0.1-0.2 mg/kg',
+ maxDose: '10 mg',
+ route: 'IV/IO',
+ indication: 'Dolor severo',
+ notes: [
+ 'Administrar lentamente',
+ 'Monitorizar respiración',
+ 'Tener naloxona disponible',
+ ],
+ warning: '⚠️ Monitorizar respiración. Tener naloxona disponible',
+ },
+ {
+ id: 'naloxona',
+ name: 'Naloxona',
+ presentation: 'Ampolla 0.4 mg/1 ml',
+ concentration: '0.4 mg/ml',
+ dosePerKg: '0.01-0.1 mg/kg',
+ route: 'IV/IO/IM',
+ indication: 'Intoxicación opioides / Depresión respiratoria',
+ notes: [
+ 'Dosis inicial: 0.01 mg/kg',
+ 'Repetir si es necesario',
+ 'Efecto corto, puede requerir múltiples dosis',
+ ],
+ },
+ {
+ id: 'glucosa',
+ name: 'Glucosa (Dextrosa)',
+ presentation: 'Ampolla 50% 25 g/50 ml',
+ concentration: '0.5 g/ml',
+ dosePerKg: '0.5-1 g/kg',
+ route: 'IV/IO',
+ indication: 'Hipoglucemia',
+ notes: [
+ 'Diluir al 10% o 25% según protocolo',
+ 'Administrar lentamente',
+ 'Monitorizar glucemia',
+ ],
+ },
+];
+
+/**
+ * Calcula la dosis pediátrica de un fármaco
+ */
+export const calculatePediatricDose = (
+ drug: PediatricDrug,
+ weightKg: number
+): {
+ doseMg: number;
+ doseMl: number;
+ isValid: boolean;
+ warning?: string;
+ message?: string;
+} => {
+ // Extraer dosis por kg del string (ej: "0.01 mg/kg" -> 0.01)
+ const doseMatch = drug.dosePerKg.match(/([\d.]+)\s*mg\/kg/);
+ if (!doseMatch) {
+ return {
+ doseMg: 0,
+ doseMl: 0,
+ isValid: false,
+ message: 'Error al parsear dosis por kg',
+ };
+ }
+
+ const dosePerKg = parseFloat(doseMatch[1]);
+ let doseMg = weightKg * dosePerKg;
+
+ // Aplicar dosis mínima si existe
+ if (drug.minDose) {
+ const minMatch = drug.minDose.match(/([\d.]+)\s*mg/);
+ if (minMatch) {
+ const minDose = parseFloat(minMatch[1]);
+ if (doseMg < minDose) {
+ doseMg = minDose;
+ }
+ }
+ }
+
+ // Aplicar dosis máxima si existe
+ let warning: string | undefined;
+ if (drug.maxDose) {
+ const maxMatch = drug.maxDose.match(/([\d.]+)\s*mg/);
+ if (maxMatch) {
+ const maxDose = parseFloat(maxMatch[1]);
+ if (doseMg > maxDose) {
+ warning = `⚠️ Dosis calculada (${doseMg.toFixed(2)} mg) excede el máximo (${maxDose} mg). Usar dosis máxima: ${maxDose} mg`;
+ doseMg = maxDose;
+ }
+ }
+ }
+
+ // Calcular ml según concentración
+ const concMatch = drug.concentration.match(/([\d.]+)\s*mg\/ml/);
+ if (!concMatch) {
+ return {
+ doseMg,
+ doseMl: 0,
+ isValid: false,
+ message: 'Error al parsear concentración',
+ };
+ }
+
+ const concentration = parseFloat(concMatch[1]);
+ const doseMl = doseMg / concentration;
+
+ return {
+ doseMg: Math.round(doseMg * 100) / 100, // Redondear a 2 decimales
+ doseMl: Math.round(doseMl * 1000) / 1000, // Redondear a 3 decimales
+ isValid: true,
+ warning,
+ };
+};
diff --git a/src/data/procedures.ts b/src/data/procedures.ts
index b282dd82..d70ca22c 100644
--- a/src/data/procedures.ts
+++ b/src/data/procedures.ts
@@ -29,14 +29,14 @@ export const procedures: Procedure[] = [
steps: [
'Garantizar seguridad de la escena',
'Comprobar consciencia: estimular y preguntar "¿Se encuentra bien?"',
- 'Si no responde, gritar pidiendo ayuda',
+ 'Si no responde, llamar inmediatamente al 112',
'Abrir vía aérea: maniobra frente-mentón',
'Comprobar respiración: VER-OÍR-SENTIR (máx. 10 segundos)',
- 'Si no respira normal: llamar 112 y pedir DEA',
+ 'Si no respira normal: iniciar RCP',
'Iniciar compresiones torácicas: 30 compresiones',
'Dar 2 ventilaciones de rescate',
'Continuar ciclos 30:2 sin interrupción',
- 'Cuando llegue DEA: encenderlo y seguir instrucciones',
+ 'Solicitar DEA cuando esté disponible',
],
warnings: [
'Profundidad compresiones: 5-6 cm',
@@ -95,15 +95,16 @@ export const procedures: Procedure[] = [
priority: 'critico',
ageGroup: 'pediatrico',
steps: [
- 'Garantizar seguridad',
+ 'Garantizar seguridad de la escena',
'Comprobar consciencia',
+ 'Si no responde, llamar inmediatamente al 112',
'Abrir vía aérea: maniobra frente-mentón',
'Comprobar respiración (máx. 10 segundos)',
+ 'Si no respira normal: iniciar RCP',
'Dar 5 ventilaciones de rescate iniciales',
'Comprobar signos de vida/pulso (máx. 10 seg)',
'Si no hay signos de vida: 15 compresiones torácicas',
'Continuar con ciclos 15:2',
- 'Si está solo: RCP 1 minuto antes de llamar 112',
],
warnings: [
'Lactante (<1 año): compresiones con 2 dedos',
diff --git a/src/data/tes-medication.ts b/src/data/tes-medication.ts
new file mode 100644
index 00000000..4891b597
--- /dev/null
+++ b/src/data/tes-medication.ts
@@ -0,0 +1,118 @@
+/**
+ * Medicación que puede administrar el TES
+ * Solo información de ejecución bajo prescripción facultativa
+ * NO incluye dosis ni decisiones clínicas
+ */
+
+export interface TESMedication {
+ id: string;
+ name: string;
+ category: 'hipoglucemia' | 'respiratorio' | 'anafilaxia';
+ indication: string;
+ presentation: string;
+ route: string;
+ notes?: string[];
+ warning?: string;
+}
+
+export const tesMedications: TESMedication[] = [
+ {
+ id: 'glucagon',
+ name: 'Glucagón',
+ category: 'hipoglucemia',
+ indication: 'Hipoglucemia severa con pérdida de consciencia',
+ presentation: 'Polvo para reconstituir + disolvente',
+ route: 'IM/SC',
+ notes: [
+ 'Administrar si paciente inconsciente y no se puede administrar glucosa oral',
+ 'Efecto en 10-15 minutos',
+ 'Monitorizar glucemia tras administración',
+ ],
+ warning: 'Solo si paciente inconsciente y no se puede administrar glucosa oral',
+ },
+ {
+ id: 'salbutamol-nebulizacion',
+ name: 'Salbutamol (Nebulización)',
+ category: 'respiratorio',
+ indication: 'Crisis asmática / Broncoespasmo',
+ presentation: 'Ampolla nebulización',
+ route: 'Nebulizado',
+ notes: [
+ 'Administrar con nebulizador y mascarilla',
+ 'Monitorizar respuesta respiratoria',
+ 'Puede repetirse según prescripción',
+ ],
+ },
+ {
+ id: 'atrovent-nebulizacion',
+ name: 'Atrovent (Ipratropio)',
+ category: 'respiratorio',
+ indication: 'Crisis asmática / Broncoespasmo',
+ presentation: 'Ampolla nebulización',
+ route: 'Nebulizado',
+ notes: [
+ 'Puede combinarse con Salbutamol según prescripción',
+ 'Administrar con nebulizador',
+ ],
+ },
+ {
+ id: 'pulmicort-nebulizacion',
+ name: 'Pulmicort (Budesonida)',
+ category: 'respiratorio',
+ indication: 'Crisis asmática / Broncoespasmo',
+ presentation: 'Suspensión para nebulización',
+ route: 'Nebulizado',
+ notes: [
+ 'Corticosteroide inhalado',
+ 'Efecto antiinflamatorio',
+ ],
+ },
+ {
+ id: 'combiprasal',
+ name: 'Combiprasal',
+ category: 'respiratorio',
+ indication: 'Crisis asmática / Broncoespasmo',
+ presentation: 'Combinación Salbutamol + Ipratropio',
+ route: 'Nebulizado',
+ notes: [
+ 'Combinación de broncodilatadores',
+ 'Administrar con nebulizador',
+ ],
+ },
+ {
+ id: 'adrenalina-anafilaxia',
+ name: 'Adrenalina (Anafilaxia)',
+ category: 'anafilaxia',
+ indication: 'Anafilaxia grave',
+ presentation: 'Ampolla 1 mg/1 ml (1:1000)',
+ route: 'IM',
+ notes: [
+ 'Sitio IM: tercio medio del vasto externo (muslo lateral)',
+ 'Fármaco salvavidas - administración precoz es crítica',
+ 'Efectos adversos esperados (temblor, taquicardia) son normales',
+ 'Repetir según prescripción si no hay mejoría',
+ ],
+ warning: '⚠️ CONCENTRACIÓN CRÍTICA: Usar ampolla 1:1000 (1 mg/ml) para IM. Leer etiqueta en voz alta.',
+ },
+ {
+ id: 'urbason',
+ name: 'Urbason (Metilprednisolona)',
+ category: 'anafilaxia',
+ indication: 'Anafilaxia grave (tratamiento complementario)',
+ presentation: 'Ampolla inyectable',
+ route: 'IV/IM',
+ notes: [
+ 'Corticosteroide de acción rápida',
+ 'Complementa la acción de adrenalina',
+ 'Efecto antiinflamatorio y antialérgico',
+ ],
+ },
+];
+
+export const getMedicationsByCategory = (category: TESMedication['category']): TESMedication[] => {
+ return tesMedications.filter((m) => m.category === category);
+};
+
+export const getMedicationById = (id: string): TESMedication | undefined => {
+ return tesMedications.find((m) => m.id === id);
+};
diff --git a/src/index.css b/src/index.css
index 2a4ff87d..008d3dd6 100644
--- a/src/index.css
+++ b/src/index.css
@@ -127,7 +127,7 @@
}
.btn-emergency-critical {
- @apply bg-[hsl(var(--emergency-critical))] text-white hover:bg-[hsl(var(--emergency-critical))]/90;
+ @apply bg-black text-white hover:bg-black/90;
}
.btn-emergency-high {
diff --git a/src/main.tsx b/src/main.tsx
index 68176a72..b3166b04 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -2,4 +2,23 @@ import { createRoot } from "react-dom/client";
import App from "./App.tsx";
import "./index.css";
+// Registrar Service Worker para PWA
+if ('serviceWorker' in navigator) {
+ window.addEventListener('load', () => {
+ navigator.serviceWorker
+ .register('/sw.js')
+ .then((registration) => {
+ console.log('SW registered:', registration);
+
+ // Verificar actualizaciones cada hora
+ setInterval(() => {
+ registration.update();
+ }, 60 * 60 * 1000);
+ })
+ .catch((error) => {
+ console.log('SW registration failed:', error);
+ });
+ });
+}
+
createRoot(document.getElementById("root")!).render(
- {/* Drugs List */}
-
- {filteredDrugs.map((drug) => (
-
+ {/* TES Medication Subcategories */}
+ {activeCategory === 'tes' && (
+
+ {tesCategories.map((cat) => (
+ setActiveTESCategory(cat.id)}
+ className={`px-4 py-2 rounded-full text-sm font-medium whitespace-nowrap transition-colors ${
+ activeTESCategory === cat.id
+ ? 'bg-primary text-primary-foreground'
+ : 'bg-muted text-muted-foreground hover:bg-accent'
+ }`}
+ >
+ {cat.label}
+
+ ))}
+
+ )}
- {filteredDrugs.length === 0 && (
-
-
- No se encontraron fármacos
-
+ {/* TES Medications List */}
+ {activeCategory === 'tes' && (
+
+ {filteredTESMedications.map((medication) => (
+
+ ))}
+ {filteredTESMedications.length === 0 && (
+
+
+ No se encontraron medicaciones
+
+
+ )}
+
+ )}
+
+ {/* Drugs List (Vademécum completo) */}
+ {activeCategory !== 'tes' && (
+
+ {filteredDrugs.map((drug) => (
+
+ ))}
+ {filteredDrugs.length === 0 && (
+
+
+ No se encontraron fármacos
+
+
+ )}
)}
diff --git a/src/pages/Herramientas.tsx b/src/pages/Herramientas.tsx
index 7683f57c..87e7bba4 100644
--- a/src/pages/Herramientas.tsx
+++ b/src/pages/Herramientas.tsx
@@ -1,6 +1,7 @@
import { useState } from 'react';
import { Calculator, Table, AlertCircle, BookOpen } from 'lucide-react';
import GlasgowCalculator from '@/components/tools/GlasgowCalculator';
+import ParklandCalculator from '@/components/tools/ParklandCalculator';
import InfusionTableView from '@/components/tools/InfusionTableView';
import { infusionTables } from '@/data/calculators';
import { Link } from 'react-router-dom';
@@ -17,25 +18,25 @@ const codigosProtocolo = [
{
name: 'Código Ictus',
description: 'Activación ante sospecha de ictus agudo',
- path: '/patologias?tab=neurologicas',
+ path: '/ictus',
color: 'bg-secondary',
},
{
name: 'Código IAM',
description: 'SCACEST - Infarto con elevación ST',
- path: '/patologias?tab=circulatorias',
+ path: '/patologias',
color: 'bg-primary',
},
{
name: 'Código Sepsis',
description: 'Sospecha de sepsis severa / shock séptico',
- path: '/soporte-vital',
+ path: '/shock',
color: 'bg-emergency-high',
},
{
name: 'Código Parada',
description: 'PCR - Parada cardiorrespiratoria',
- path: '/soporte-vital?id=rcp-adulto-svb',
+ path: '/rcp',
color: 'bg-primary',
},
];
@@ -77,25 +78,11 @@ const Herramientas = () => {
{activeTab === 'calculadoras' && (
-
- {/* Placeholder for more calculators */}
-
-
- 🔥 Fórmula de Parkland (Quemados)
-
-
- Próximamente disponible
-
-
-
-
-
- ⚖️ Dosis Pediátricas por Peso
-
-
- Próximamente disponible
-
-
+
+
+
+
+
)}
diff --git a/src/pages/Ictus.tsx b/src/pages/Ictus.tsx
new file mode 100644
index 00000000..e32046ad
--- /dev/null
+++ b/src/pages/Ictus.tsx
@@ -0,0 +1,217 @@
+import { Link } from 'react-router-dom';
+import { Brain, Clock, AlertTriangle, ChevronRight, Phone } from 'lucide-react';
+import BackButton from '@/components/ui/BackButton';
+
+const Ictus = () => {
+ return (
+
+
+
+ {/* Header */}
+
+
+
+
+
+
Código Ictus
+
Protocolo de activación ante sospecha de ictus agudo
+
+
+
+ {/* Alerta de tiempo */}
+
+
+
+
+ ⏱️ TIEMPO ES CEREBRO
+
+
+ Cada minuto cuenta. La activación precoz del Código Ictus mejora significativamente el pronóstico.
+
+
+
+
+
+ {/* Test FAST */}
+
+
+
+
+
+
+
F
+
Face (Cara)
+
Asimetría facial al sonreír
+
+
+
A
+
Arms (Brazos)
+
Debilidad en un brazo al elevarlo
+
+
+
S
+
Speech (Habla)
+
Dificultad para hablar o entender
+
+
+
T
+
Time (Tiempo)
+
Activar Código Ictus INMEDIATAMENTE
+
+
+
+
+ {/* Protocolo de Actuación */}
+
+
Protocolo de Actuación
+
+
+
+
+ 1
+
+
+
Activación Inmediata
+
+ Si cualquier signo del test FAST es positivo, activar Código Ictus inmediatamente.
+ Comunicar al coordinador: "Código Ictus activado, tiempo desde inicio de síntomas: [X] minutos".
+
+
+
+
+
+
+ 2
+
+
+
Valoración Inicial
+
+ Hora de inicio de síntomas (crítico para ventana terapéutica)
+ Glucemia capilar (hipoglucemia puede simular ictus)
+ Tensión arterial (no bajar si <220/120 mmHg)
+ Nivel de consciencia (Glasgow)
+ Signos neurológicos focales
+
+
+
+
+
+
+ 3
+
+
+
Manejo Prehospitalario
+
+ Oxigenoterapia si SpO₂ <94%
+ Monitorización continua (ECG, SpO₂, TA)
+ Acceso venoso periférico
+ NO administrar glucosa salvo hipoglucemia confirmada
+ NO administrar fármacos antihipertensivos salvo emergencia hipertensiva
+ Posición semisentada si consciencia preservada
+
+
+
+
+
+
+ 4
+
+
+
Traslado Urgente
+
+ Traslado inmediato al hospital con Unidad de Ictus más cercana.
+ Comunicar previamente al hospital: hora de inicio de síntomas, test FAST positivo,
+ estado neurológico actual, y tiempo estimado de llegada.
+
+
+
+
+
+
+ {/* Criterios de Exclusión */}
+
+
Criterios de Exclusión
+
+
+ ✗
+ Síntomas >24 horas de evolución (excepto indicación específica del hospital)
+
+
+ ✗
+ Hipoglucemia como causa de síntomas
+
+
+ ✗
+ Trauma craneal reciente
+
+
+ ✗
+ Paciente en tratamiento anticoagulante con INR >3.0
+
+
+
+
+ {/* Advertencias */}
+
+
+
+
+
+ •
+ La hora de inicio de síntomas es CRÍTICA para determinar elegibilidad a trombólisis
+
+
+ •
+ NO administrar AAS ni otros antiagregantes sin indicación médica
+
+
+ •
+ Si el paciente pierde consciencia o deja de respirar, iniciar RCP inmediatamente
+
+
+ •
+ Mantener comunicación constante con el coordinador durante el traslado
+
+
+
+
+ {/* Enlaces relacionados */}
+
+
Protocolos Relacionados
+
+
+
+
+
Protocolo Transtelefónico de Ictus
+
+
+
+
+
Ver todas las patologías neurológicas
+
+
+
+
RCP (si pierde consciencia)
+
+
+
+
+
+ );
+};
+
+export default Ictus;
diff --git a/src/pages/Index.tsx b/src/pages/Index.tsx
index 0a837681..426c5b20 100644
--- a/src/pages/Index.tsx
+++ b/src/pages/Index.tsx
@@ -19,10 +19,10 @@ const recentSearches = [
];
const quickAccess = [
- { label: 'OVACE', path: '/soporte-vital?id=obstruccion-via-aerea' },
+ { label: 'OVACE', path: '/via-aerea' },
{ label: 'Glasgow', path: '/herramientas' },
{ label: 'Triage', path: '/escena' },
- { label: 'Código Ictus', path: '/patologias' },
+ { label: 'Código Ictus', path: '/ictus' },
{ label: 'Dopamina', path: '/herramientas' },
{ label: 'Politrauma', path: '/soporte-vital' },
];
@@ -52,27 +52,27 @@ const Home = ({ onSearchClick }: HomeProps) => {
{
{/* Floating Emergency Button */}
+ {/* Botón de retroceso */}
+
+
{/* Header */}
diff --git a/src/pages/ManualViewer.tsx b/src/pages/ManualViewer.tsx
index a1c7707b..4c9a4a2b 100644
--- a/src/pages/ManualViewer.tsx
+++ b/src/pages/ManualViewer.tsx
@@ -2,6 +2,7 @@ import { useEffect, useState } from 'react';
import { useParams, Link } from 'react-router-dom';
import { ChevronLeft, ChevronRight, BookOpen } from 'lucide-react';
import MarkdownViewer from '@/components/content/MarkdownViewer';
+import BackButton from '@/components/ui/BackButton';
import { manualIndex, getCapituloById, Capitulo } from '@/data/manual-index';
const ManualViewer = () => {
@@ -53,6 +54,11 @@ const ManualViewer = () => {
return (
+ {/* Botón de retroceso */}
+
+
+
{/* Header del capítulo */}
diff --git a/src/pages/RCP.tsx b/src/pages/RCP.tsx
new file mode 100644
index 00000000..587d47a1
--- /dev/null
+++ b/src/pages/RCP.tsx
@@ -0,0 +1,290 @@
+import { useState } from 'react';
+import { Link } from 'react-router-dom';
+import { Heart, ChevronRight, AlertTriangle, Clock, Users, Baby } from 'lucide-react';
+import BackButton from '@/components/ui/BackButton';
+import { getProcedureById } from '@/data/procedures';
+
+const RCP = () => {
+ const [activeTab, setActiveTab] = useState<'adulto' | 'pediatrico'>('adulto');
+
+ const rcpAdulto = getProcedureById('rcp-adulto-svb');
+ const rcpAdultoSVA = getProcedureById('rcp-adulto-sva');
+ const rcpPediatrico = getProcedureById('rcp-pediatrico');
+
+ return (
+
+
+
+ {/* Header */}
+
+
+
+
+
+
RCP / Parada Cardiorrespiratoria
+
Protocolo de Reanimación Cardiopulmonar
+
+
+
+ {/* Tabs Adulto/Pediátrico */}
+
+
setActiveTab('adulto')}
+ className={`px-4 py-2 font-medium transition-colors ${
+ activeTab === 'adulto'
+ ? 'text-primary border-b-2 border-primary'
+ : 'text-muted-foreground hover:text-foreground'
+ }`}
+ >
+
+ Adulto
+
+
+
setActiveTab('pediatrico')}
+ className={`px-4 py-2 font-medium transition-colors ${
+ activeTab === 'pediatrico'
+ ? 'text-primary border-b-2 border-primary'
+ : 'text-muted-foreground hover:text-foreground'
+ }`}
+ >
+
+ Pediátrico
+
+
+
+
+
+ {/* Contenido Adulto */}
+ {activeTab === 'adulto' && (
+
+ {/* SVB */}
+ {rcpAdulto && (
+
+
+
Soporte Vital Básico (SVB)
+
+ Crítico
+
+
+
+
+
+
+
+
+ {rcpAdulto.steps.map((step, index) => (
+
+ {step}
+
+ ))}
+
+
+
+ {rcpAdulto.warnings && rcpAdulto.warnings.length > 0 && (
+
+
+
+
+ {rcpAdulto.warnings.map((warning, index) => (
+
+ •
+ {warning}
+
+ ))}
+
+
+ )}
+
+ {rcpAdulto.keyPoints && rcpAdulto.keyPoints.length > 0 && (
+
+
Puntos Clave
+
+ {rcpAdulto.keyPoints.map((point, index) => (
+
+ ✓
+ {point}
+
+ ))}
+
+
+ )}
+
+ {rcpAdulto.equipment && rcpAdulto.equipment.length > 0 && (
+
+
Material Necesario
+
+ {rcpAdulto.equipment.map((item, index) => (
+
+ {item}
+
+ ))}
+
+
+ )}
+
+
+ )}
+
+ {/* SVA */}
+ {rcpAdultoSVA && (
+
+
+
Soporte Vital Avanzado (SVA)
+
+ Crítico
+
+
+
+
+
+
Pasos del Protocolo
+
+ {rcpAdultoSVA.steps.map((step, index) => (
+
+ {step}
+
+ ))}
+
+
+
+ {rcpAdultoSVA.warnings && rcpAdultoSVA.warnings.length > 0 && (
+
+
Advertencias
+
+ {rcpAdultoSVA.warnings.map((warning, index) => (
+
+ •
+ {warning}
+
+ ))}
+
+
+ )}
+
+ {rcpAdultoSVA.keyPoints && rcpAdultoSVA.keyPoints.length > 0 && (
+
+
Puntos Clave
+
+ {rcpAdultoSVA.keyPoints.map((point, index) => (
+
+ ✓
+ {point}
+
+ ))}
+
+
+ )}
+
+
+ )}
+
+ {/* Enlaces relacionados */}
+
+
Protocolos Relacionados
+
+ Vía Aérea / OVACE
+ Ver todos los protocolos de Soporte Vital
+
+
+
+ )}
+
+ {/* Contenido Pediátrico */}
+ {activeTab === 'pediatrico' && rcpPediatrico && (
+
+
+
+
RCP Pediátrico
+
+ Crítico
+
+
+
+
+
+
+
+
+ {rcpPediatrico.steps.map((step, index) => (
+
+ {step}
+
+ ))}
+
+
+
+ {rcpPediatrico.warnings && rcpPediatrico.warnings.length > 0 && (
+
+
Advertencias Importantes
+
+ {rcpPediatrico.warnings.map((warning, index) => (
+
+ •
+ {warning}
+
+ ))}
+
+
+ )}
+
+ {rcpPediatrico.keyPoints && rcpPediatrico.keyPoints.length > 0 && (
+
+
Puntos Clave
+
+ {rcpPediatrico.keyPoints.map((point, index) => (
+
+ ✓
+ {point}
+
+ ))}
+
+
+ )}
+
+
+
+ {/* Enlaces relacionados */}
+
+
Protocolos Relacionados
+
+ OVACE Pediátrico
+
+
+
+ )}
+
+ );
+};
+
+export default RCP;
diff --git a/src/pages/Shock.tsx b/src/pages/Shock.tsx
new file mode 100644
index 00000000..54a02d50
--- /dev/null
+++ b/src/pages/Shock.tsx
@@ -0,0 +1,200 @@
+import { Link } from 'react-router-dom';
+import { Zap, AlertTriangle, ChevronRight, Droplet } from 'lucide-react';
+import BackButton from '@/components/ui/BackButton';
+import { getProcedureById } from '@/data/procedures';
+
+const Shock = () => {
+ const shockHemorragico = getProcedureById('shock-hemorragico');
+
+ return (
+
+
+
+ {/* Header */}
+
+
+
+
+
+
Shock Hemorrágico
+
Protocolo de manejo del shock por pérdida de sangre
+
+
+
+
+ {/* Clasificación */}
+
+
Clasificación del Shock Hemorrágico
+
+
+
+
Clase I
+
+
Pérdida: <15%
+
FC: Normal
+
TA: Normal
+
Signos: Mínimos
+
+
+
+
Clase II
+
+
Pérdida: 15-30%
+
FC: ↑ Taquicardia
+
TA: Normal
+
Signos: Ansiedad
+
+
+
+
Clase III
+
+
Pérdida: 30-40%
+
FC: ↑↑ Taquicardia
+
TA: ↓ Hipotensión
+
Signos: Confusión
+
+
+
+
Clase IV
+
+
Pérdida: >40%
+
FC: ↓ Bradicardia
+
TA: ↓↓ Severa
+
Signos: Letargo
+
+
+
+
+
+ {/* Protocolo */}
+ {shockHemorragico && (
+
+
+
Protocolo de Actuación
+
+ Crítico
+
+
+
+
+
+
+
+
+ {shockHemorragico.steps.map((step, index) => (
+
+ {step}
+
+ ))}
+
+
+
+ {shockHemorragico.warnings && shockHemorragico.warnings.length > 0 && (
+
+
Advertencias Importantes
+
+ {shockHemorragico.warnings.map((warning, index) => (
+
+ •
+ {warning}
+
+ ))}
+
+
+ )}
+
+ {shockHemorragico.keyPoints && shockHemorragico.keyPoints.length > 0 && (
+
+
Clasificación por Clases
+
+ {shockHemorragico.keyPoints.map((point, index) => (
+
+ ✓
+ {point}
+
+ ))}
+
+
+ )}
+
+ {shockHemorragico.equipment && shockHemorragico.equipment.length > 0 && (
+
+
+
+
+ {shockHemorragico.equipment.map((item, index) => (
+
+ {item}
+
+ ))}
+
+
+ )}
+
+ {shockHemorragico.drugs && shockHemorragico.drugs.length > 0 && (
+
+
Fármacos
+
+ {shockHemorragico.drugs.map((drug, index) => (
+
+ {drug}
+
+ ))}
+
+
+ )}
+
+
+ )}
+
+ {/* Hipotensión Permisiva */}
+
+
+
+
+ En shock hemorrágico sin trauma craneoencefálico (TCE), mantener TAS objetivo de 80-90 mmHg
+ hasta control quirúrgico de la hemorragia. Esto reduce la pérdida de sangre y mejora la supervivencia.
+
+
+ ⚠️ EXCEPCIÓN: En TCE, mantener TAS >90 mmHg para preservar perfusión cerebral.
+
+
+
+ {/* Enlaces relacionados */}
+
+
Protocolos Relacionados
+
+ Ver todos los protocolos de Soporte Vital
+ Fármacos: Ácido Tranexámico
+
+
+
+ );
+};
+
+export default Shock;
diff --git a/src/pages/ViaAerea.tsx b/src/pages/ViaAerea.tsx
new file mode 100644
index 00000000..93d78040
--- /dev/null
+++ b/src/pages/ViaAerea.tsx
@@ -0,0 +1,212 @@
+import { Link } from 'react-router-dom';
+import { Wind, AlertTriangle, ChevronRight, Baby, Users } from 'lucide-react';
+import BackButton from '@/components/ui/BackButton';
+import { getProcedureById } from '@/data/procedures';
+
+const ViaAerea = () => {
+ const ovace = getProcedureById('obstruccion-via-aerea');
+
+ return (
+
+
+
+ {/* Header */}
+
+
+
+
+
+
Vía Aérea
+
OVACE (Obstrucción de Vía Aérea por Cuerpo Extraño) e IOT
+
+
+
+
+ {/* Valoración Inicial */}
+
+
Valoración Inicial
+
+
+
+
+
+
+ ✓ Puede toser con fuerza
+ ✓ Puede hablar
+ ✓ Respiración presente
+ ✓ Coloración normal
+
+
+
Actuación:
+
Animar a toser, vigilar estrechamente
+
+
+
+
+
+
+ ✗ No puede toser
+ ✗ No puede hablar
+ ✗ Respiración ausente o débil
+ ✗ Cianosis
+ ✗ Pérdida de consciencia inminente
+
+
+
Actuación:
+
Maniobras de desobstrucción INMEDIATAS
+
+
+
+
+
+ {/* Protocolo OVACE */}
+ {ovace && (
+
+
+
Protocolo OVACE
+
+ Crítico
+
+
+
+
+
+
+
+
+ {ovace.steps.map((step, index) => (
+
+ {step}
+
+ ))}
+
+
+
+ {ovace.warnings && ovace.warnings.length > 0 && (
+
+
Advertencias Importantes
+
+ {ovace.warnings.map((warning, index) => (
+
+ •
+ {warning}
+
+ ))}
+
+
+ )}
+
+ {ovace.keyPoints && ovace.keyPoints.length > 0 && (
+
+
Puntos Clave
+
+ {ovace.keyPoints.map((point, index) => (
+
+ ✓
+ {point}
+
+ ))}
+
+
+ )}
+
+
+ )}
+
+ {/* Variaciones por Edad */}
+
+
Variaciones por Edad
+
+
+
+
+
+
+ • 5 golpes interescapulares
+ • 5 compresiones abdominales (Heimlich)
+ • Alternar hasta resolución o pérdida de consciencia
+ • En embarazadas/obesos: compresiones torácicas en lugar de abdominales
+
+
+
+
+
+
+
+ • 5 golpes en la espalda (posición boca abajo sobre antebrazo)
+ • 5 compresiones torácicas (posición boca arriba sobre antebrazo)
+ • Alternar hasta resolución o pérdida de consciencia
+ • NO hacer compresiones abdominales (riesgo de lesión)
+
+
+
+
+
+ {/* Si Pierde Consciencia */}
+
+
+
+
+ Tumbar al paciente con control
+ Activar 112 si no se ha hecho
+ Antes de ventilar: revisar boca y extraer objeto visible
+ Iniciar RCP inmediatamente (ver protocolo RCP)
+ Antes de cada ventilación: revisar boca
+
+
+
+ {/* IOT (Intubación Orotraqueal) */}
+
+
Intubación Orotraqueal (IOT)
+
+ La IOT es un procedimiento avanzado que requiere formación específica y certificación.
+ Consulta el manual completo para detalles técnicos y consideraciones especiales.
+
+
+ Ver Manual Completo
+
+
+
+
+ {/* Enlaces relacionados */}
+
+
Protocolos Relacionados
+
+ RCP (si pierde consciencia)
+ Ver todos los protocolos de Soporte Vital
+
+
+
+ );
+};
+
+export default ViaAerea;
diff --git a/vite.config.ts b/vite.config.ts
index 42bb0db9..163405d8 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -2,8 +2,16 @@ import { defineConfig } from "vite";
import react from "@vitejs/plugin-react-swc";
import path from "path";
+// Detectar si estamos en GitHub Pages
+// GitHub Pages usa el formato: https://username.github.io/repository-name/
+const isGitHubPages = process.env.GITHUB_PAGES === 'true';
+const repositoryName = process.env.GITHUB_REPOSITORY_NAME || 'guia-tes-digital';
+const base = isGitHubPages ? `/${repositoryName}/` : '/';
+
// https://vitejs.dev/config/
export default defineConfig({
+ // Base path para GitHub Pages (necesario para rutas SPA)
+ base: base,
server: {
host: "::",
port: 8096,
@@ -42,7 +50,11 @@ export default defineConfig({
},
// Incluir archivos .md en el build
assetsInclude: ['**/*.md'],
+ // Copiar 404.html y sw.js de public/ a dist/ para GitHub Pages
+ copyPublicDir: true,
},
+ // Configuración para PWA
+ // El service worker se copia automáticamente desde public/ con copyPublicDir
// Configuración para importar archivos .md como texto usando ?raw
// Ejemplo de uso: