@hedia/recommendation-screen 1.8.2 → 2.0.2

package/src/utils/Validations.ts

@@ -1,15 +1,7 @@
-import { IRecommendationParams } from "@hedia/recommendation-calculator";
-import {
-	ActivityIntensity,
-	IActivityInterval,
-	IActivityParams,
-	IActivitySettings,
-	IRecentBolus,
-} from "@hedia/recommendation-calculator/src/RecommendationCalculator";
-import { BloodGlucoseUnit, BloodKetonesUnit } from "@hedia/types";
+import { Activity, BloodGlucoseUnit, BloodKetonesUnit, Languages, UserSettings } from "@hedia/types";
 import moment from "moment";
 import { IRecommendationProps } from "../RecommendationScreen";
-import { ActivityEnum, ActivityInterval, InjectionMethod, Language } from "../types/enum";
+import { ActivitySettings, IActivityParams, IRecentBolus, IRecommendationParams, logbookEntry } from "../types/types";
 import {
 	ACTIVITY_BUFFER_MINUTES,
 	ACTIVITY_DURATION_MINUTES_LIMITS,
@@ -44,11 +36,16 @@ import {
 	InsulinSensitivityError,
 	InsulinToCarbsRatioError,
 	LanguageError,
+	LatestLogbook6HoursBGLError,
+	RecentBolusError,
 	TargetBGLError,
 	UserReminderError,
 } from "./RecommendationError";
 import { Utils } from "./Utils";
 
+const { hard } = Activity.Enums.ActivityIntensity;
+const { fromFortysix } = Activity.Enums.ActivityReductionIntervals;
+
 export function validateParams(props: IRecommendationProps): void {
 	checkCalculatorParams(props.calculatorParams);
 	checkBGLUnit(props.bloodGlucoseUnit);
@@ -59,49 +56,52 @@ export function validateParams(props: IRecommendationProps): void {
 	checkInjectionMethod(props.injectionMethod);
 	checkUserReminder(props.userReminder);
 	checkLanguage(props.language);
+	checkLatestLogbook6Hours(props.latestLogbookFrom6Hours);
 	if (props?.calculatorParams?.activity && props?.activityDisplayProps) {
 		checkActivityType(props.activityDisplayProps.activityType);
 	}
 }
 
-export function checkLanguage(language: Language): void {
-	if (!Object.values(Language).includes(language)) {
+export function checkLanguage(language: Languages): void {
+	if (!Object.values(Languages).includes(language)) {
 		throw LanguageError();
 	}
 }
+export function checkLatestLogbook6Hours(logbook: logbookEntry | null): void {
+	if (logbook === undefined) {
+		throw LatestLogbook6HoursBGLError();
+	}
+	if (logbook !== null) {
+		if (!Utils.isInRange(logbook.blood_glucose_millimolar, CURRENT_BGL_MMOL_LIMITS)) {
+			throw LatestLogbook6HoursBGLError();
+		}
+	}
+}
 
-export function checkInjectionMethod(injectionMethod: InjectionMethod): void {
-	switch (injectionMethod) {
-		case InjectionMethod.PenHalf:
-		case InjectionMethod.PenWhole:
-		case InjectionMethod.Pump:
-			break;
-		default:
-			throw InjectionMethodError();
+export function checkInjectionMethod(injectionMethod: UserSettings.Enums.InjectionMethod): void {
+	const check = Object.values(UserSettings.Enums.InjectionMethod).some(
+		(method): boolean => method === injectionMethod,
+	);
+	if (!check) {
+		throw InjectionMethodError();
 	}
 }
 
 export function checkBGLUnit(unit: BloodGlucoseUnit): void {
-	switch (unit) {
-		case BloodGlucoseUnit.MG_DL:
-		case BloodGlucoseUnit.MMOL_L:
-			break;
-		default:
-			throw BloodGlucoseUnitError();
+	const check = Object.values(BloodGlucoseUnit).some((enumUnit): boolean => enumUnit === unit);
+	if (!check) {
+		throw BloodGlucoseUnitError();
 	}
 }
 export function checkBKLUnit(unit: BloodKetonesUnit): void {
-	switch (unit) {
-		case BloodKetonesUnit.MG_DL:
-		case BloodKetonesUnit.MMOL_L:
-			break;
-		default:
-			throw BloodKetoneUnitError();
+	const check = Object.values(BloodKetonesUnit).some((enumUnit): boolean => enumUnit === unit);
+	if (!check) {
+		throw BloodKetoneUnitError();
 	}
 }
 
 export function checkUserReminder(userReminder: number): void {
-	if (!Utils.isInClosedInterval(userReminder, REMINDER_HOURS_LIMITS)) {
+	if (!Utils.isInRange(userReminder, REMINDER_HOURS_LIMITS)) {
 		throw UserReminderError();
 	}
 }
@@ -113,11 +113,12 @@ function checkCalculatorParams(calculatorParams: IRecommendationParams): void {
 	checkTargetBGL(calculatorParams.targetBGL);
 	checkInsulinToCarbRatio(calculatorParams.carbohydrateRatio);
 	checkInsulinSensitivity(calculatorParams.insulinSensitivity);
+	checkRecentBolus(calculatorParams.recentBoluses);
 	checkRecentBolusesInsulinDose(calculatorParams.recentBoluses);
 	checkRecentBolusesSecondsPassed(calculatorParams.recentBoluses);
 }
 
-export function checkActivity(activity: IActivityParams): void {
+export function checkActivity(activity: IActivityParams | null): void {
 	if (activity) {
 		checkActivityDate(activity);
 		checkActivityDuration(activity.activityDuration);
@@ -127,53 +128,47 @@ export function checkActivity(activity: IActivityParams): void {
 	}
 }
 
-export function checkRecentBolusesInsulinDose(recentBoluses: Array<IRecentBolus>): void {
-	if (recentBoluses !== null) {
-		recentBoluses.forEach((bolus: IRecentBolus): void => {
-			if (!Utils.isInClosedInterval(bolus.insulinDose, INSULIN_DOSE_LIMITS)) {
-				throw BolusInsulinDoseError();
-			}
-		});
+export function checkRecentBolus(recentBoluses: Array<IRecentBolus>): void {
+	if (recentBoluses === null || recentBoluses === undefined) {
+		throw RecentBolusError();
 	}
 }
 
+export function checkRecentBolusesInsulinDose(recentBoluses: Array<IRecentBolus>): void {
+	recentBoluses.forEach((bolus: IRecentBolus): void => {
+		if (!Utils.isInRange(bolus.insulinDose, INSULIN_DOSE_LIMITS)) {
+			throw BolusInsulinDoseError();
+		}
+	});
+}
+
 export function checkRecentBolusesSecondsPassed(recentBoluses: Array<IRecentBolus>): void {
-	if (recentBoluses !== null) {
-		recentBoluses.forEach((bolus: IRecentBolus): void => {
-			if (!Utils.isInClosedInterval(bolus.secondsPassed, BOLUS_SECONDS_PASSED_LIMITS)) {
-				throw BolusInsulinSecondsPassedError();
-			}
-		});
-	}
+	recentBoluses.forEach((bolus: IRecentBolus): void => {
+		if (!Utils.isInRange(bolus.secondsPassed, BOLUS_SECONDS_PASSED_LIMITS)) {
+			throw BolusInsulinSecondsPassedError();
+		}
+	});
 }
 
 export function checkActivityDuration(activityDuration: number): void {
-	if (!Utils.isInClosedInterval(activityDuration, ACTIVITY_DURATION_MINUTES_LIMITS)) {
+	if (!Utils.isInRange(activityDuration, ACTIVITY_DURATION_MINUTES_LIMITS)) {
 		throw ActivityDurationError();
 	}
 }
 
-export function checkActivityIntensity(activityIntensity: ActivityIntensity): void {
-	switch (activityIntensity) {
-		case ActivityIntensity.Hard:
-		case ActivityIntensity.Moderate:
-		case ActivityIntensity.Light:
-			break;
-		default:
-			throw ActivityIntensityError();
+export function checkActivityIntensity(activityIntensity: Activity.Enums.ActivityIntensity): void {
+	const check = Object.values(Activity.Enums.ActivityIntensity).some(
+		(method): boolean => method === activityIntensity,
+	);
+	if (!check) {
+		throw ActivityIntensityError();
 	}
 }
 
-export function checkActivityType(activityType: ActivityEnum): void {
-	switch (activityType) {
-		case ActivityEnum.Cycling:
-		case ActivityEnum.Other:
-		case ActivityEnum.Run:
-		case ActivityEnum.Swim:
-		case ActivityEnum.Walk:
-			break;
-		default:
-			throw ActivityTypeError();
+export function checkActivityType(activityType: Activity.Enums.ActivityEnum | null): void {
+	const check = Object.values(Activity.Enums.ActivityEnum).some((method): boolean => method === activityType);
+	if (!check) {
+		throw ActivityTypeError();
 	}
 }
 
@@ -186,13 +181,13 @@ export function checkActivityDate(activity: IActivityParams): void {
 	}
 }
 
-type intensityType = Omit<IActivitySettings, "target">;
-export function checkActivitySettings(activitySettings: IActivitySettings): void {
-	for (const intensity of Object.keys(activitySettings) as Array<keyof intensityType>) {
-		for (const interval of Object.keys(activitySettings[intensity]) as Array<keyof IActivityInterval>) {
-			const value: number = activitySettings[intensity][interval];
-			const isInInterval: boolean = Utils.isInClosedInterval(value, ACTIVITY_SETTINGS_INTERVAL_LIMITS);
-			if (intensity === ActivityIntensity.Hard.toLowerCase() && interval === ActivityInterval.fromFortysix) {
+export function checkActivitySettings(activitySettings: ActivitySettings): void {
+	for (const intensity of Object.keys(activitySettings) as Array<Activity.Enums.ActivityIntensity>) {
+		const reductionIntervals = activitySettings[intensity];
+		for (const interval of Object.keys(reductionIntervals) as Array<keyof typeof reductionIntervals>) {
+			const value = activitySettings[intensity][interval];
+			const isInInterval: boolean = Utils.isInRange(value, ACTIVITY_SETTINGS_INTERVAL_LIMITS);
+			if (intensity === hard && interval === fromFortysix) {
 				if (!isInInterval && value !== null) {
 					throw ActivitySettingsError();
 				}
@@ -204,47 +199,47 @@ export function checkActivitySettings(activitySettings: IActivitySettings): void
 }
 
 export function checkActivityTargetBGL(activitySettingsTargetBGL: number): void {
-	if (!Utils.isInClosedInterval(activitySettingsTargetBGL, ACTIVITY_TARGET_BGL_MMOL_LIMITS)) {
+	if (!Utils.isInRange(activitySettingsTargetBGL, ACTIVITY_TARGET_BGL_MMOL_LIMITS)) {
 		throw ActivityTargetBGLError();
 	}
 }
 
 export function checkCurrentBGL(currentBGL: number): void {
 	if (currentBGL !== null) {
-		if (!Utils.isInClosedInterval(currentBGL, CURRENT_BGL_MMOL_LIMITS)) {
+		if (!Utils.isInRange(currentBGL, CURRENT_BGL_MMOL_LIMITS)) {
 			throw CurrentBGLError();
 		}
 	}
 }
 
 export function checkTargetBGL(targetBGL: number): void {
-	if (!Utils.isInClosedInterval(targetBGL, TARGET_BGL_MMOL_LIMITS)) {
+	if (!Utils.isInRange(targetBGL, TARGET_BGL_MMOL_LIMITS)) {
 		throw TargetBGLError();
 	}
 }
 
 export function checkBloodKetoneLevel(currentBKL: number): void {
 	if (currentBKL !== null) {
-		if (!Utils.isInClosedInterval(currentBKL, CURRENT_BKL_MMOL_LIMITS)) {
+		if (!Utils.isInRange(currentBKL, CURRENT_BKL_MMOL_LIMITS)) {
 			throw CurrentBKLError();
 		}
 	}
 }
 
 export function checkInsulinSensitivity(insulinSensitivity: number): void {
-	if (!Utils.isInClosedInterval(insulinSensitivity, INSULIN_SENSITIVITY_MMOL_LIMITS)) {
+	if (!Utils.isInRange(insulinSensitivity, INSULIN_SENSITIVITY_MMOL_LIMITS)) {
 		throw InsulinSensitivityError();
 	}
 }
 
 export function checkInsulinToCarbRatio(insulinToCarbRatio: number): void {
-	if (!Utils.isInClosedInterval(insulinToCarbRatio, INSULIN_TO_CARBS_RATIO_LIMITS)) {
+	if (!Utils.isInRange(insulinToCarbRatio, INSULIN_TO_CARBS_RATIO_LIMITS)) {
 		throw InsulinToCarbsRatioError();
 	}
 }
 
 export function checkCarbohydrates(carbohydrates: number): void {
-	if (!Utils.isInClosedInterval(carbohydrates, CARBOHYDRATES_LIMTS)) {
+	if (!Utils.isInRange(carbohydrates, CARBOHYDRATES_LIMTS)) {
 		throw CarbohydrateLimitError();
 	}
 }

package/tsconfig.json

@@ -29,9 +29,9 @@
         /* Strict Type-Checking Options */
         //"strict": true,                           /* Enable all strict type-checking options. */
         // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
-        // "strictNullChecks": true,              /* Enable strict null checks. */
+        "strictNullChecks": true,              /* Enable strict null checks. */
         // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
-        // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+        "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
         // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
         // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */