{errorMessage}
diff --git a/src/constants/defaults.ts b/src/constants/defaults.ts
index 2a156be..ef9ee87 100644
--- a/src/constants/defaults.ts
+++ b/src/constants/defaults.ts
@@ -8,7 +8,7 @@
* @license MIT
*/
-export const LOCAL_STORAGE_KEY = 'medPlanAssistantState_v5';
+export const LOCAL_STORAGE_KEY = 'medPlanAssistantState_v6';
export const LDX_TO_DAMPH_CONVERSION_FACTOR = 0.2948;
// Type definitions
@@ -17,15 +17,17 @@ export interface PkParams {
ldx: { halfLife: string; absorptionRate: string };
}
-export interface Dose {
+export interface DayDose {
+ id: string;
time: string;
- dose: string;
- label: string;
+ ldx: string;
+ damph?: string; // Optional, kept for backwards compatibility but not used in UI
}
-export interface Deviation extends Dose {
- dayOffset?: number;
- isAdditional: boolean;
+export interface DayGroup {
+ id: string;
+ isTemplate: boolean;
+ doses: DayDose[];
}
export interface SteadyStateConfig {
@@ -39,7 +41,8 @@ export interface TherapeuticRange {
export interface UiSettings {
showDayTimeOnXAxis: boolean;
- chartView: 'damph' | 'ldx' | 'both';
+ showTemplateDay: boolean;
+ chartView: 'ldx' | 'damph' | 'both';
yAxisMin: string;
yAxisMax: string;
simulationDays: string;
@@ -48,13 +51,25 @@ export interface UiSettings {
export interface AppState {
pkParams: PkParams;
- doses: Dose[];
+ days: DayGroup[];
steadyStateConfig: SteadyStateConfig;
therapeuticRange: TherapeuticRange;
doseIncrement: string;
uiSettings: UiSettings;
}
+// Legacy interfaces for backwards compatibility (will be removed later)
+export interface Dose {
+ time: string;
+ dose: string;
+ label: string;
+}
+
+export interface Deviation extends Dose {
+ dayOffset?: number;
+ isAdditional: boolean;
+}
+
export interface ConcentrationPoint {
timeHours: number;
ldx: number;
@@ -67,18 +82,24 @@ export const getDefaultState = (): AppState => ({
damph: { halfLife: '11' },
ldx: { halfLife: '0.8', absorptionRate: '1.5' },
},
- doses: [
- { time: '06:30', dose: '25', label: 'morning' },
- { time: '12:30', dose: '10', label: 'midday' },
- { time: '17:00', dose: '10', label: 'afternoon' },
- { time: '22:00', dose: '10', label: 'evening' },
- { time: '01:00', dose: '0', label: 'night' },
+ days: [
+ {
+ id: 'day-template',
+ isTemplate: true,
+ doses: [
+ { id: 'dose-1', time: '06:30', ldx: '25' },
+ { id: 'dose-2', time: '12:30', ldx: '10' },
+ { id: 'dose-3', time: '17:00', ldx: '10' },
+ { id: 'dose-4', time: '22:00', ldx: '10' },
+ ]
+ }
],
steadyStateConfig: { daysOnMedication: '7' },
therapeuticRange: { min: '10.5', max: '11.5' },
doseIncrement: '2.5',
uiSettings: {
showDayTimeOnXAxis: true,
+ showTemplateDay: false,
chartView: 'both',
yAxisMin: '0',
yAxisMax: '16',
diff --git a/src/hooks/useAppState.ts b/src/hooks/useAppState.ts
index f43bab7..bcc6506 100644
--- a/src/hooks/useAppState.ts
+++ b/src/hooks/useAppState.ts
@@ -10,7 +10,7 @@
*/
import React from 'react';
-import { LOCAL_STORAGE_KEY, getDefaultState, type AppState } from '../constants/defaults';
+import { LOCAL_STORAGE_KEY, getDefaultState, type AppState, type DayGroup, type DayDose } from '../constants/defaults';
export const useAppState = () => {
const [appState, setAppState] = React.useState
(getDefaultState);
@@ -26,6 +26,7 @@ export const useAppState = () => {
...defaults,
...parsedState,
pkParams: {...defaults.pkParams, ...parsedState.pkParams},
+ days: parsedState.days || defaults.days,
uiSettings: {...defaults.uiSettings, ...parsedState.uiSettings},
});
}
@@ -40,7 +41,7 @@ export const useAppState = () => {
try {
const stateToSave = {
pkParams: appState.pkParams,
- doses: appState.doses,
+ days: appState.days,
steadyStateConfig: appState.steadyStateConfig,
therapeuticRange: appState.therapeuticRange,
doseIncrement: appState.doseIncrement,
@@ -72,15 +73,119 @@ export const useAppState = () => {
key: K,
value: AppState['uiSettings'][K]
) => {
- const newUiSettings = { ...appState.uiSettings, [key]: value };
- if (key === 'simulationDays') {
- const simDaysNum = parseInt(value as string, 10) || 1;
- const dispDaysNum = parseInt(newUiSettings.displayedDays, 10) || 1;
- if (dispDaysNum > simDaysNum) {
- newUiSettings.displayedDays = String(simDaysNum);
+ setAppState(prev => {
+ const newUiSettings = { ...prev.uiSettings, [key]: value };
+
+ // Auto-adjust displayedDays if simulationDays is reduced
+ if (key === 'simulationDays') {
+ const simDays = parseInt(value as string, 10) || 3;
+ const dispDays = parseInt(prev.uiSettings.displayedDays, 10) || 2;
+ if (dispDays > simDays) {
+ newUiSettings.displayedDays = String(simDays);
+ }
}
- }
- setAppState(prev => ({ ...prev, uiSettings: newUiSettings }));
+
+ return { ...prev, uiSettings: newUiSettings };
+ });
+ };
+
+ // Day management functions
+ const addDay = (cloneFromDayId?: string) => {
+ const maxDays = 3; // Template + 2 deviation days
+ if (appState.days.length >= maxDays) return;
+
+ const sourceDay = cloneFromDayId
+ ? appState.days.find(d => d.id === cloneFromDayId)
+ : undefined;
+
+ const newDay: DayGroup = sourceDay
+ ? {
+ id: `day-${Date.now()}`,
+ isTemplate: false,
+ doses: sourceDay.doses.map(d => ({
+ id: `dose-${Date.now()}-${Math.random()}`,
+ time: d.time,
+ ldx: d.ldx
+ }))
+ }
+ : {
+ id: `day-${Date.now()}`,
+ isTemplate: false,
+ doses: [{ id: `dose-${Date.now()}`, time: '12:00', ldx: '30' }]
+ };
+
+ setAppState(prev => ({ ...prev, days: [...prev.days, newDay] }));
+ };
+
+ const removeDay = (dayId: string) => {
+ setAppState(prev => {
+ const dayToRemove = prev.days.find(d => d.id === dayId);
+ // Never delete template day
+ if (dayToRemove?.isTemplate) {
+ console.warn('Cannot delete template day');
+ return prev;
+ }
+ // Never delete if it would leave us with no days
+ if (prev.days.length <= 1) {
+ console.warn('Cannot delete last day');
+ return prev;
+ }
+ return { ...prev, days: prev.days.filter(d => d.id !== dayId) };
+ });
+ };
+
+ const updateDay = (dayId: string, updatedDay: DayGroup) => {
+ setAppState(prev => ({
+ ...prev,
+ days: prev.days.map(day => day.id === dayId ? updatedDay : day)
+ }));
+ };
+
+ const addDoseToDay = (dayId: string, newDose?: Partial) => {
+ setAppState(prev => ({
+ ...prev,
+ days: prev.days.map(day => {
+ if (day.id !== dayId) return day;
+ if (day.doses.length >= 5) return day; // Max 5 doses per day
+
+ const dose: DayDose = {
+ id: `dose-${Date.now()}-${Math.random()}`,
+ time: newDose?.time || '12:00',
+ ldx: newDose?.ldx || '0',
+ damph: newDose?.damph || '0',
+ };
+
+ return { ...day, doses: [...day.doses, dose] };
+ })
+ }));
+ };
+
+ const removeDoseFromDay = (dayId: string, doseId: string) => {
+ setAppState(prev => ({
+ ...prev,
+ days: prev.days.map(day => {
+ if (day.id !== dayId) return day;
+ // Don't allow removing last dose from template day
+ if (day.isTemplate && day.doses.length <= 1) return day;
+
+ return { ...day, doses: day.doses.filter(dose => dose.id !== doseId) };
+ })
+ }));
+ };
+
+ const updateDoseInDay = (dayId: string, doseId: string, field: keyof DayDose, value: string) => {
+ setAppState(prev => ({
+ ...prev,
+ days: prev.days.map(day => {
+ if (day.id !== dayId) return day;
+ return {
+ ...day,
+ doses: day.doses.map(dose =>
+ dose.id === doseId ? { ...dose, [field]: value } : dose
+ )
+ };
+ })
+ }));
};
const handleReset = () => {
@@ -96,6 +201,12 @@ export const useAppState = () => {
updateState,
updateNestedState,
updateUiSetting,
+ addDay,
+ removeDay,
+ updateDay,
+ addDoseToDay,
+ removeDoseFromDay,
+ updateDoseInDay,
handleReset
};
};
diff --git a/src/hooks/useSimulation.ts b/src/hooks/useSimulation.ts
index 2a76b27..c04459c 100644
--- a/src/hooks/useSimulation.ts
+++ b/src/hooks/useSimulation.ts
@@ -1,9 +1,8 @@
/**
* Simulation Hook
*
- * Manages pharmacokinetic simulation calculations and deviation handling.
- * Computes ideal, deviated, and corrected concentration profiles.
- * Generates dose correction suggestions based on deviations.
+ * Manages pharmacokinetic simulation calculations for day-based plans.
+ * Computes concentration profiles from all days in the schedule.
*
* @author Andreas Weyer
* @license MIT
@@ -11,134 +10,81 @@
import React from 'react';
import { calculateCombinedProfile } from '../utils/calculations';
-import { generateSuggestion } from '../utils/suggestions';
-import { timeToMinutes } from '../utils/timeUtils';
-import type { AppState, Deviation } from '../constants/defaults';
+import type { AppState } from '../constants/defaults';
-interface SuggestionResult {
- text?: string;
- time?: string;
- dose?: string;
- isAdditional?: boolean;
- originalDose?: string;
- dayOffset?: number;
-}
+export const useSimulation = (appState: AppState) => {
+ const { pkParams, days, steadyStateConfig, uiSettings } = appState;
+ const { showTemplateDay, simulationDays } = uiSettings;
-interface Translations {
- noSuitableNextDose: string;
- noSignificantCorrection: string;
-}
+ // Extend days to match simulation duration
+ const extendedDays = React.useMemo(() => {
+ const numSimDays = parseInt(simulationDays, 10) || 3;
+ if (days.length >= numSimDays) return days;
-export const useSimulation = (appState: AppState, t: Translations) => {
- const { pkParams, doses, steadyStateConfig, doseIncrement, uiSettings } = appState;
- const { simulationDays } = uiSettings;
+ // Repeat template day to fill simulation period
+ const templateDay = days.find(d => d.isTemplate);
+ if (!templateDay) return days;
- const [deviations, setDeviations] = React.useState([]);
- const [suggestion, setSuggestion] = React.useState(null);
-
- const calculateCombinedProfileMemo = React.useCallback(
- (doseSchedule = doses, deviationList: Deviation[] = [], correction: Deviation | null = null) =>
- calculateCombinedProfile(
- doseSchedule,
- deviationList,
- correction,
- steadyStateConfig,
- simulationDays,
- pkParams
- ),
- [doses, steadyStateConfig, simulationDays, pkParams]
- );
-
- const generateSuggestionMemo = React.useCallback(() => {
- const newSuggestion = generateSuggestion(
- doses,
- deviations,
- doseIncrement,
- simulationDays,
- steadyStateConfig,
- pkParams,
- t
- );
- setSuggestion(newSuggestion);
- }, [doses, deviations, doseIncrement, simulationDays, steadyStateConfig, pkParams, t]);
-
- React.useEffect(() => {
- generateSuggestionMemo();
- }, [generateSuggestionMemo]);
-
- const idealProfile = React.useMemo(() =>
- calculateCombinedProfileMemo(doses),
- [doses, calculateCombinedProfileMemo]
- );
-
- const deviatedProfile = React.useMemo(() =>
- deviations.length > 0 ? calculateCombinedProfileMemo(doses, deviations) : null,
- [doses, deviations, calculateCombinedProfileMemo]
- );
-
- const correctedProfile = React.useMemo(() =>
- suggestion && suggestion.dose ? calculateCombinedProfileMemo(doses, deviations, suggestion as Deviation) : null,
- [doses, deviations, suggestion, calculateCombinedProfileMemo]
- );
-
- const addDeviation = () => {
- const templateDose = { time: '07:00', dose: '10', label: '' };
- const sortedDoses = [...doses].sort((a, b) => timeToMinutes(a.time) - timeToMinutes(b.time));
- let nextDose: any = sortedDoses[0] || templateDose;
- let nextDayOffset = 0;
-
- if (deviations.length > 0) {
- const lastDev = deviations[deviations.length - 1];
- const lastDevTime = timeToMinutes(lastDev.time) + (lastDev.dayOffset || 0) * 24 * 60;
- const nextPlanned = sortedDoses.find(d => timeToMinutes(d.time) > (lastDevTime % (24*60)));
- if (nextPlanned) {
- nextDose = nextPlanned;
- nextDayOffset = lastDev.dayOffset || 0;
- } else {
- nextDose = sortedDoses[0];
- nextDayOffset = (lastDev.dayOffset || 0) + 1;
- }
+ const extended = [...days];
+ for (let i = days.length; i < numSimDays; i++) {
+ extended.push({
+ id: `extended-day-${i}`,
+ isTemplate: false,
+ doses: templateDay.doses.map(d => ({
+ id: `${d.id}-ext-${i}`,
+ time: d.time,
+ ldx: d.ldx
+ }))
+ });
}
+ return extended;
+ }, [days, simulationDays]);
- // Use templateDose if nextDose has no time
- if (!nextDose.time || nextDose.time === '') {
- nextDose = templateDose;
+ // Calculate profile with extended days
+ const combinedProfile = React.useMemo(() => {
+ if (extendedDays.length === 0) return [];
+ return calculateCombinedProfile(extendedDays, steadyStateConfig, pkParams);
+ }, [extendedDays, steadyStateConfig, pkParams]);
+
+ // Filter visible days for display purposes only
+ const visibleDays = React.useMemo(() => {
+ if (showTemplateDay) {
+ return days;
}
+ // Show only non-template days
+ return days.filter(day => !day.isTemplate);
+ }, [days, showTemplateDay]);
- setDeviations([...deviations, {
- time: nextDose.time,
- dose: nextDose.dose,
- label: nextDose.label || '',
- isAdditional: false,
- dayOffset: nextDayOffset
- }]);
- };
+ // Calculate template continuation profile (day 2 onwards for comparison)
+ const templateProfile = React.useMemo(() => {
+ if (!showTemplateDay) return null;
- const removeDeviation = (index: number) => {
- setDeviations(deviations.filter((_, i) => i !== index));
- };
+ const templateDay = days.find(day => day.isTemplate);
+ if (!templateDay) return null;
- const handleDeviationChange = (index: number, field: keyof Deviation, value: any) => {
- const newDeviations = [...deviations];
- (newDeviations[index] as any)[field] = value;
- setDeviations(newDeviations);
- };
+ const numSimDays = parseInt(simulationDays, 10) || 3;
+ if (numSimDays < 2) return null; // Need at least 2 days to show continuation
- const applySuggestion = () => {
- if (!suggestion || !suggestion.dose) return;
- setDeviations([...deviations, suggestion as Deviation]);
- setSuggestion(null);
- };
+ // Create array with template day repeated for entire simulation period
+ const templateDays = Array.from({ length: numSimDays }, (_, i) => ({
+ id: `template-continuation-${i}`,
+ isTemplate: false,
+ doses: templateDay.doses.map(d => ({
+ id: `${d.id}-template-${i}`,
+ time: d.time,
+ ldx: d.ldx
+ }))
+ }));
+
+ const fullProfile = calculateCombinedProfile(templateDays, steadyStateConfig, pkParams);
+
+ // Filter to only show from day 2 onwards (skip first 24 hours)
+ return fullProfile.filter(point => point.timeHours >= 24);
+ }, [days, steadyStateConfig, pkParams, showTemplateDay, simulationDays]);
return {
- deviations,
- suggestion,
- idealProfile,
- deviatedProfile,
- correctedProfile,
- addDeviation,
- removeDeviation,
- handleDeviationChange,
- applySuggestion
+ combinedProfile,
+ templateProfile,
+ visibleDays
};
};
diff --git a/src/locales/de.ts b/src/locales/de.ts
index 323a754..ff893be 100644
--- a/src/locales/de.ts
+++ b/src/locales/de.ts
@@ -77,7 +77,28 @@ export const de = {
// Field validation
errorNumberRequired: "Bitte gib eine gültige Zahl ein.",
- errorTimeRequired: "Bitte gib eine gültige Zeitangabe ein."
+ errorTimeRequired: "Bitte gib eine gültige Zeitangabe ein.",
+
+ // Day-based schedule
+ regularPlan: "Regulärer Plan",
+ continuation: "Fortsetzung",
+ dayNumber: "Tag {{number}}",
+ cloneDay: "Tag klonen",
+ addDay: "Tag hinzufügen",
+ addDose: "Dosis hinzufügen",
+ removeDose: "Dosis entfernen",
+ removeDay: "Tag entfernen",
+ time: "Zeit",
+ ldx: "LDX",
+ damph: "d-amph",
+
+ // URL sharing
+ sharePlan: "Plan teilen",
+ viewingSharedPlan: "Du siehst einen geteilten Plan",
+ saveAsMyPlan: "Als meinen Plan speichern",
+ discardSharedPlan: "Verwerfen",
+ planCopiedToClipboard: "Plan-Link in Zwischenablage kopiert!",
+ showTemplateDayInChart: "Regulären Plan im Diagramm anzeigen"
};
export default de;
diff --git a/src/locales/en.ts b/src/locales/en.ts
index 1b9bc21..97c94c8 100644
--- a/src/locales/en.ts
+++ b/src/locales/en.ts
@@ -77,7 +77,28 @@ export const en = {
// Field validation
errorNumberRequired: "Please enter a valid number.",
- errorTimeRequired: "Please enter a valid time."
+ errorTimeRequired: "Please enter a valid time.",
+
+ // Day-based schedule
+ regularPlan: "Regular Plan",
+ continuation: "continuation",
+ dayNumber: "Day {{number}}",
+ cloneDay: "Clone day",
+ addDay: "Add day",
+ addDose: "Add dose",
+ removeDose: "Remove dose",
+ removeDay: "Remove day",
+ time: "Time",
+ ldx: "LDX",
+ damph: "d-amph",
+
+ // URL sharing
+ sharePlan: "Share Plan",
+ viewingSharedPlan: "You are viewing a shared plan",
+ saveAsMyPlan: "Save as My Plan",
+ discardSharedPlan: "Discard",
+ planCopiedToClipboard: "Plan link copied to clipboard!",
+ showTemplateDayInChart: "Show regular plan in chart"
};
export default en;
diff --git a/src/utils/calculations.ts b/src/utils/calculations.ts
index b9ab5dd..7756ed7 100644
--- a/src/utils/calculations.ts
+++ b/src/utils/calculations.ts
@@ -11,84 +11,80 @@
import { timeToMinutes } from './timeUtils';
import { calculateSingleDoseConcentration } from './pharmacokinetics';
-import type { Dose, Deviation, SteadyStateConfig, PkParams, ConcentrationPoint } from '../constants/defaults';
+import type { DayGroup, SteadyStateConfig, PkParams, ConcentrationPoint } from '../constants/defaults';
-interface DoseWithTime extends Omit {
- time: number;
- isPlan?: boolean;
+interface ProcessedDose {
+ timeMinutes: number;
+ ldx: number;
+ damph: number;
}
export const calculateCombinedProfile = (
- doseSchedule: Dose[],
- deviationList: Deviation[] = [],
- correction: Deviation | null = null,
+ days: DayGroup[],
steadyStateConfig: SteadyStateConfig,
- simulationDays: string,
pkParams: PkParams
): ConcentrationPoint[] => {
const dataPoints: ConcentrationPoint[] = [];
const timeStepHours = 0.25;
- const totalHours = (parseInt(simulationDays, 10) || 3) * 24;
+ const totalDays = days.length;
+ const totalHours = totalDays * 24;
const daysToSimulate = Math.min(parseInt(steadyStateConfig.daysOnMedication, 10) || 0, 5);
+ // Convert days to processed doses with absolute time
+ const allDoses: ProcessedDose[] = [];
+
+ // Add steady-state doses (days before simulation period)
+ // Use template day (first day) for steady state
+ const templateDay = days[0];
+ if (templateDay) {
+ for (let steadyDay = -daysToSimulate; steadyDay < 0; steadyDay++) {
+ const dayOffsetMinutes = steadyDay * 24 * 60;
+ templateDay.doses.forEach(dose => {
+ const ldxNum = parseFloat(dose.ldx);
+ if (dose.time && !isNaN(ldxNum) && ldxNum > 0) {
+ allDoses.push({
+ timeMinutes: timeToMinutes(dose.time) + dayOffsetMinutes,
+ ldx: ldxNum,
+ damph: 0 // d-amph is calculated from LDX conversion, not administered directly
+ });
+ }
+ });
+ }
+ }
+
+ // Add doses from each day in sequence
+ days.forEach((day, dayIndex) => {
+ const dayOffsetMinutes = dayIndex * 24 * 60;
+ day.doses.forEach(dose => {
+ const ldxNum = parseFloat(dose.ldx);
+ if (dose.time && !isNaN(ldxNum) && ldxNum > 0) {
+ allDoses.push({
+ timeMinutes: timeToMinutes(dose.time) + dayOffsetMinutes,
+ ldx: ldxNum,
+ damph: 0 // d-amph is calculated from LDX conversion, not administered directly
+ });
+ }
+ });
+ });
+
+ // Calculate concentrations at each time point
for (let t = 0; t <= totalHours; t += timeStepHours) {
let totalLdx = 0;
let totalDamph = 0;
- const allDoses: DoseWithTime[] = [];
- const maxDayOffset = (parseInt(simulationDays, 10) || 3) - 1;
+ allDoses.forEach(dose => {
+ const timeSinceDoseHours = t - dose.timeMinutes / 60;
- for (let day = -daysToSimulate; day <= maxDayOffset; day++) {
- const dayOffset = day * 24 * 60;
- doseSchedule.forEach(d => {
- // Skip doses with empty or invalid time values
- const timeStr = String(d.time || '').trim();
- const doseStr = String(d.dose || '').trim();
- const doseNum = parseFloat(doseStr);
-
- if (!timeStr || timeStr === '' || !doseStr || doseStr === '' || doseNum === 0 || isNaN(doseNum)) {
- return;
- }
- allDoses.push({ ...d, time: timeToMinutes(d.time) + dayOffset, isPlan: true });
- });
- }
-
- const currentDeviations = [...deviationList];
- if (correction) {
- currentDeviations.push({ ...correction, isAdditional: true });
- }
-
- currentDeviations.forEach(dev => {
- // Skip deviations with empty or invalid time values
- const timeStr = String(dev.time || '').trim();
- const doseStr = String(dev.dose || '').trim();
- const doseNum = parseFloat(doseStr);
-
- if (!timeStr || timeStr === '' || !doseStr || doseStr === '' || doseNum === 0 || isNaN(doseNum)) {
- return;
+ if (timeSinceDoseHours >= 0) {
+ // Calculate LDX contribution
+ const ldxConcentrations = calculateSingleDoseConcentration(
+ String(dose.ldx),
+ timeSinceDoseHours,
+ pkParams
+ );
+ totalLdx += ldxConcentrations.ldx;
+ totalDamph += ldxConcentrations.damph;
}
- const devTime = timeToMinutes(dev.time) + (dev.dayOffset || 0) * 24 * 60;
- if (!dev.isAdditional) {
- const closestDoseIndex = allDoses.reduce((closest, dose, index) => {
- if (!dose.isPlan) return closest;
- const diff = Math.abs(dose.time - devTime);
- if (diff <= 60 && diff < closest.minDiff) {
- return { index, minDiff: diff };
- }
- return closest;
- }, { index: -1, minDiff: 61 }).index;
- if (closestDoseIndex !== -1) {
- allDoses.splice(closestDoseIndex, 1);
- }
- }
- allDoses.push({ ...dev, time: devTime });
- });
-
- allDoses.forEach(doseInfo => {
- const timeSinceDoseHours = t - doseInfo.time / 60;
- const concentrations = calculateSingleDoseConcentration(doseInfo.dose, timeSinceDoseHours, pkParams);
- totalLdx += concentrations.ldx;
- totalDamph += concentrations.damph;
});
dataPoints.push({ timeHours: t, ldx: totalLdx, damph: totalDamph });
diff --git a/src/utils/suggestions.ts b/src/utils/suggestions.ts
index 27122bc..4ce5c08 100644
--- a/src/utils/suggestions.ts
+++ b/src/utils/suggestions.ts
@@ -11,7 +11,7 @@
import { timeToMinutes } from './timeUtils';
import { calculateCombinedProfile } from './calculations';
-import type { Dose, Deviation, SteadyStateConfig, PkParams } from '../constants/defaults';
+import type { DayGroup, SteadyStateConfig, PkParams } from '../constants/defaults';
interface SuggestionResult {
text?: string;
@@ -28,83 +28,11 @@ interface Translations {
}
export const generateSuggestion = (
- doses: Dose[],
- deviations: Deviation[],
- doseIncrement: string,
- simulationDays: string,
+ days: DayGroup[],
steadyStateConfig: SteadyStateConfig,
- pkParams: PkParams,
- t: Translations
+ pkParams: PkParams
): SuggestionResult | null => {
- if (deviations.length === 0) {
- return null;
- }
-
- const lastDeviation = [...deviations].sort((a, b) =>
- timeToMinutes(a.time) + (a.dayOffset || 0) * 1440 -
- (timeToMinutes(b.time) + (b.dayOffset || 0) * 1440)
- ).pop();
-
- if (!lastDeviation) return null;
-
- const deviationTimeTotalMinutes = timeToMinutes(lastDeviation.time) + (lastDeviation.dayOffset || 0) * 1440;
-
- type DoseWithOffset = Dose & { dayOffset: number };
- let nextDose: DoseWithOffset | null = null;
- let minDiff = Infinity;
-
- doses.forEach(d => {
- // Skip doses with empty or invalid time/dose values
- const timeStr = String(d.time || '').trim();
- const doseStr = String(d.dose || '').trim();
- const doseNum = parseFloat(doseStr);
-
- if (!timeStr || timeStr === '' || !doseStr || doseStr === '' || doseNum === 0 || isNaN(doseNum)) {
- return;
- }
- const doseTimeInMinutes = timeToMinutes(d.time);
- for (let i = 0; i < (parseInt(simulationDays, 10) || 1); i++) {
- const absoluteTime = doseTimeInMinutes + i * 1440;
- const diff = absoluteTime - deviationTimeTotalMinutes;
- if (diff > 0 && diff < minDiff) {
- minDiff = diff;
- nextDose = { ...d, dayOffset: i };
- }
- }
- });
-
- if (!nextDose) {
- return { text: t.noSuitableNextDose };
- }
-
- // Type assertion after null check
- const confirmedNextDose: DoseWithOffset = nextDose;
-
- const numDoseIncrement = parseFloat(doseIncrement) || 1;
- const idealProfile = calculateCombinedProfile(doses, [], null, steadyStateConfig, simulationDays, pkParams);
- const deviatedProfile = calculateCombinedProfile(doses, deviations, null, steadyStateConfig, simulationDays, pkParams);
-
- const nextDoseTimeHours = (timeToMinutes(confirmedNextDose.time) + (confirmedNextDose.dayOffset || 0) * 1440) / 60;
-
- const idealConcentration = idealProfile.find(p => Math.abs(p.timeHours - nextDoseTimeHours) < 0.1)?.damph || 0;
- const deviatedConcentration = deviatedProfile.find(p => Math.abs(p.timeHours - nextDoseTimeHours) < 0.1)?.damph || 0;
- const concentrationDifference = idealConcentration - deviatedConcentration;
-
- if (Math.abs(concentrationDifference) < 0.5) {
- return { text: t.noSignificantCorrection };
- }
-
- const doseAdjustmentFactor = 0.5;
- let doseChange = concentrationDifference / doseAdjustmentFactor;
- doseChange = Math.round(doseChange / numDoseIncrement) * numDoseIncrement;
- let suggestedDoseValue = (parseFloat(confirmedNextDose.dose) || 0) + doseChange;
- suggestedDoseValue = Math.max(0, Math.min(70, suggestedDoseValue));
-
- return {
- time: confirmedNextDose.time,
- dose: String(suggestedDoseValue),
- isAdditional: false,
- originalDose: confirmedNextDose.dose,
- dayOffset: confirmedNextDose.dayOffset
- };
+ // Suggestion feature is deprecated in day-based system
+ // This function is kept for backward compatibility but returns null
+ return null;
};