@hedia/recommendation-screen 1.0.7 → 1.1.1

package/src/utils/RecommendationUtils.ts

@@ -0,0 +1,128 @@
+import { IRecommendationParams } from "@hedia/recommendation-calculator";
+import moment from "moment";
+import { IRecommendationProps } from "../RecommendationScreen";
+import { BgLevel, RecommendationReminders } from "../types/enum";
+import { IActivity, logbookEntry } from "../types/types";
+import { addPostponeActivityMessage, AttentionMessage, Messages } from "./AttentionMessages";
+import { SEVERE_HYPERGLYCEMIA_START_MMOL } from "./Constants";
+import { CurrentBGLError } from "./RecommendationError";
+
+export function getBGLevel(currentBGL: number, latestLogbookFrom6Hours: logbookEntry): BgLevel {
+	if (currentBGL === null) {
+		return BgLevel.BGLevelNotProvided;
+	}
+	if (currentBGL >= 1.1 && currentBGL <= 2) {
+		return BgLevel.SevereHypoglycemia;
+	}
+	if (currentBGL > 2 && currentBGL <= 3.5) {
+		return BgLevel.Hypoglycemia;
+	}
+	if (currentBGL > 3.5 && currentBGL <= 4) {
+		return BgLevel.MildHypoglycemia;
+	}
+	if (currentBGL > 4 && currentBGL < 5) {
+		return BgLevel.NormoglycemiaUnder5MMOL;
+	}
+	if (currentBGL >= 5 && currentBGL <= 7) {
+		return BgLevel.Normoglycemia;
+	}
+	if (currentBGL > 7 && currentBGL < 15) {
+		return BgLevel.MildHyperglycemia;
+	}
+	if (currentBGL > 15 && currentBGL <= 33.3 && isSevereHyperglycemia(latestLogbookFrom6Hours)) {
+		return BgLevel.SevereHyperglycemia;
+	}
+	if (currentBGL >= 15 && currentBGL <= 33.3) {
+		return BgLevel.Hyperglycemia;
+	}
+	return BgLevel.UnsupportedBGLevel;
+}
+
+export function getReminder(
+	bgLevel: BgLevel,
+	carbohydrates: number,
+	userReminder: number,
+	activity: IRecommendationParams["activity"],
+): number {
+	const reminder = userReminder === undefined ? RecommendationReminders.HediaReminderDefault : userReminder;
+	switch (bgLevel) {
+		case BgLevel.BGLevelNotProvided:
+			return RecommendationReminders.ReminderOff;
+
+		case BgLevel.SevereHypoglycemia:
+		case BgLevel.Hypoglycemia:
+		case BgLevel.MildHypoglycemia:
+			return RecommendationReminders.Reminder15Minutes;
+
+		case BgLevel.NormoglycemiaUnder5MMOL:
+		case BgLevel.Normoglycemia:
+		case BgLevel.MildHyperglycemia:
+			return carbohydrates || activity ? reminder : RecommendationReminders.ReminderOff;
+
+		case BgLevel.Hyperglycemia:
+		case BgLevel.SevereHyperglycemia:
+			return isActivityWithin15Minutes(activity)
+				? RecommendationReminders.Reminder15Minutes
+				: RecommendationReminders.Reminder60Minutes;
+
+		default:
+			throw CurrentBGLError();
+	}
+}
+
+export function getAttentionMessage(bgLevel: BgLevel, activity: IRecommendationParams["activity"]): AttentionMessage {
+	switch (bgLevel) {
+		case BgLevel.BGLevelNotProvided:
+		case BgLevel.Normoglycemia:
+		case BgLevel.MildHyperglycemia:
+			return undefined;
+
+		case BgLevel.NormoglycemiaUnder5MMOL:
+			return isActivityWithin15Minutes(activity) ? AttentionMessage.NormoglycemiaActivityUnder5MMOL() : undefined;
+
+		case BgLevel.SevereHypoglycemia:
+		case BgLevel.Hypoglycemia:
+		case BgLevel.MildHypoglycemia:
+			return isActivityWithin15Minutes(activity)
+				? addPostponeActivityMessage(AttentionMessage[BgLevel[bgLevel]]())
+				: AttentionMessage[BgLevel[bgLevel]]();
+
+		case BgLevel.Hyperglycemia:
+			return isActivityWithin15Minutes(activity) ? AttentionMessage.HyperglycemiaActivity() : undefined;
+
+		case BgLevel.SevereHyperglycemia:
+			return isActivityWithin15Minutes(activity)
+				? AttentionMessage.SevereHyperglycemiaActivity()
+				: AttentionMessage.SevereHyperglycemia();
+		default:
+			throw CurrentBGLError();
+	}
+}
+
+export function isSevereHyperglycemia(latestLogbookFrom6Hours: logbookEntry): boolean {
+	return latestLogbookFrom6Hours?.blood_glucose_millimolar > SEVERE_HYPERGLYCEMIA_START_MMOL;
+}
+
+export function isActivityWithin15Minutes(activity: IRecommendationParams["activity"]): boolean {
+	const minutes = activity?.activityDuration;
+	return moment
+		.utc(activity?.activityDate)
+		.isBetween(moment.utc().subtract(minutes, `minutes`), moment.utc().add(15, `minutes`));
+}
+
+export function getLimitationMessage(wasLimited: boolean, activityReduction: number): Messages {
+	const message = activityReduction
+		? Messages.RecommendationWasLimitedActivity(activityReduction)
+		: Messages.RecommendationWasLimited();
+	return wasLimited ? message : undefined;
+}
+
+export function getParams(props: IRecommendationProps): IRecommendationParams & IActivity {
+	const { calculatorParams } = props;
+	const activityTarget = calculatorParams.activity?.activitySettings?.target;
+	const paramsWithAssignedCurrentBGL = {
+		...calculatorParams,
+		currentBGL: activityTarget ?? calculatorParams.targetBGL,
+	};
+	return calculatorParams.currentBGL === null ? paramsWithAssignedCurrentBGL : calculatorParams;
+}

package/src/utils/Utils.d.ts

@@ -1,5 +1,7 @@
 import { InjectionMethod } from "../types/enum";
+import { IInterval } from "../types/types";
 export declare class Utils {
-    static getRounding(method: InjectionMethod): 2 | 10 | 1;
+    static getRounding(method: InjectionMethod): number;
     static roundValue(value: number, injectMethod: InjectionMethod): number;
+    static isInClosedInterval(value: number, interval: IInterval): boolean;
 }

package/src/utils/Utils.js

@@ -20,5 +20,11 @@ class Utils {
         const rounded = Math.round(value * rounding) / rounding;
         return rounded;
     }
+    static isInClosedInterval(value, interval) {
+        if (value === null) {
+            return false;
+        }
+        return value >= interval.min && value <= interval.max;
+    }
 }
 exports.Utils = Utils;

package/src/utils/Utils.ts

@@ -1,7 +1,8 @@
 import { InjectionMethod } from "../types/enum";
+import { IInterval } from "../types/types";
 
 export class Utils {
-	public static getRounding(method: InjectionMethod) {
+	public static getRounding(method: InjectionMethod): number {
 		switch (method) {
 			case InjectionMethod.PenWhole:
 				return 1;
@@ -17,10 +18,17 @@ export class Utils {
 		}
 	}
 
-	public static roundValue(value: number, injectMethod: InjectionMethod) {
-		const rounding = Utils.getRounding(injectMethod);
-
-		const rounded = Math.round(value * rounding) / rounding;
+	public static roundValue(value: number, injectMethod: InjectionMethod): number {
+		const rounding: number = Utils.getRounding(injectMethod);
+		const rounded: number = Math.round(value * rounding) / rounding;
 		return rounded;
 	}
+
+	public static isInClosedInterval(value: number, interval: IInterval): boolean {
+		if (value === null) {
+			return false;
+		}
+
+		return value >= interval.min && value <= interval.max;
+	}
 }

package/src/utils/Validations.d.ts

@@ -0,0 +1,22 @@
+import { IRecommendationParams } from "@hedia/recommendation-calculator";
+import { IRecentBolus } from "@hedia/recommendation-calculator/src/RecommendationCalculator";
+import { IRecommendationProps } from "../RecommendationScreen";
+import { BGUnit, InjectionMethod, Languages } from "../types/enum";
+export declare function validateParams(props: IRecommendationProps): void;
+export declare function checkLanguage(language: Languages): void;
+export declare function checkInjectionMethod(injectionMethod: InjectionMethod): void;
+export declare function checkUnit(unit: BGUnit): void;
+export declare function checkUserReminder(userReminder: number): void;
+export declare function checkActivity(activity: IRecommendationParams["activity"]): void;
+export declare function checkRecentBolusesInsulinDosis(recentBoluses: Array<IRecentBolus>): void;
+export declare function checkRecentBolusesSecondsPassed(recentBoluses: Array<IRecentBolus>): void;
+export declare function checkActivityDuration(activityDuration: IRecommendationParams["activity"]["activityDuration"]): void;
+export declare function checkActivityIntensity(activityIntensity: IRecommendationParams["activity"]["activityIntensity"]): void;
+export declare function checkActivityDate(activity: IRecommendationParams["activity"]): void;
+export declare function checkActivitySettings(activitySettings: IRecommendationParams["activity"]["activitySettings"]): void;
+export declare function checkActivityTargetBGL(activitySettings: IRecommendationParams["activity"]["activitySettings"]["target"]): void;
+export declare function checkCurrentBGL(currentBGL: number): void;
+export declare function checkTargetBGL(targetBGL: number): void;
+export declare function checkInsulinSensitivity(insulinSensitivity: number): void;
+export declare function checkInsulinToCarbRatio(insulinToCarbRatio: number): void;
+export declare function checkCarbohydrates(carbohydrates: number): void;

package/src/utils/Validations.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCarbohydrates = exports.checkInsulinToCarbRatio = exports.checkInsulinSensitivity = exports.checkTargetBGL = exports.checkCurrentBGL = exports.checkActivityTargetBGL = exports.checkActivitySettings = exports.checkActivityDate = exports.checkActivityIntensity = exports.checkActivityDuration = exports.checkRecentBolusesSecondsPassed = exports.checkRecentBolusesInsulinDosis = exports.checkActivity = exports.checkUserReminder = exports.checkUnit = exports.checkInjectionMethod = exports.checkLanguage = exports.validateParams = void 0;
+const RecommendationCalculator_1 = require("@hedia/recommendation-calculator/src/RecommendationCalculator");
+const moment_1 = __importDefault(require("moment"));
+const enum_1 = require("../types/enum");
+const Constants_1 = require("./Constants");
+const RecommendationError_1 = require("./RecommendationError");
+const Utils_1 = require("./Utils");
+function validateParams(props) {
+    checkCalculatorParams(props.calculatorParams);
+    checkUnit(props.units);
+    checkInjectionMethod(props.injectionMethod);
+    checkUserReminder(props.userReminder);
+    checkLanguage(props.language);
+}
+exports.validateParams = validateParams;
+function checkLanguage(language) {
+    switch (language) {
+        case enum_1.Languages.da:
+        case enum_1.Languages.en:
+            break;
+        default:
+            throw RecommendationError_1.LanguageError();
+    }
+}
+exports.checkLanguage = checkLanguage;
+function checkInjectionMethod(injectionMethod) {
+    switch (injectionMethod) {
+        case enum_1.InjectionMethod.PenHalf:
+        case enum_1.InjectionMethod.PenWhole:
+        case enum_1.InjectionMethod.Pump:
+            break;
+        default:
+            throw RecommendationError_1.InjectionMethodError();
+    }
+}
+exports.checkInjectionMethod = checkInjectionMethod;
+function checkUnit(unit) {
+    switch (unit) {
+        case enum_1.BGUnit.MG_DL:
+        case enum_1.BGUnit.MMOL_L:
+            break;
+        default:
+            throw RecommendationError_1.UnitError();
+    }
+}
+exports.checkUnit = checkUnit;
+function checkUserReminder(userReminder) {
+    if (!Utils_1.Utils.isInClosedInterval(userReminder, Constants_1.REMINDER_HOURS_LIMITS)) {
+        throw RecommendationError_1.UserReminderError();
+    }
+}
+exports.checkUserReminder = checkUserReminder;
+function checkCalculatorParams(calculatorParams) {
+    checkActivity(calculatorParams.activity);
+    checkCarbohydrates(calculatorParams.carbohydrates);
+    checkCurrentBGL(calculatorParams.currentBGL);
+    checkTargetBGL(calculatorParams.targetBGL);
+    checkInsulinToCarbRatio(calculatorParams.carbohydrateRatio);
+    checkInsulinSensitivity(calculatorParams.insulinSensitivity);
+    checkRecentBolusesInsulinDosis(calculatorParams.recentBoluses);
+    checkRecentBolusesSecondsPassed(calculatorParams.recentBoluses);
+}
+function checkActivity(activity) {
+    if (activity) {
+        checkActivityDate(activity);
+        checkActivityDuration(activity.activityDuration);
+        checkActivityIntensity(activity.activityIntensity);
+        checkActivitySettings(activity.activitySettings);
+        checkActivityTargetBGL(activity.activitySettings.target);
+    }
+}
+exports.checkActivity = checkActivity;
+function checkRecentBolusesInsulinDosis(recentBoluses) {
+    recentBoluses.forEach((bolus) => {
+        if (!Utils_1.Utils.isInClosedInterval(bolus.insulinDosis, Constants_1.INSULIN_DOSIS_LIMITS)) {
+            throw RecommendationError_1.BolusInsulinDosisError();
+        }
+    });
+}
+exports.checkRecentBolusesInsulinDosis = checkRecentBolusesInsulinDosis;
+function checkRecentBolusesSecondsPassed(recentBoluses) {
+    recentBoluses.forEach((bolus) => {
+        if (!Utils_1.Utils.isInClosedInterval(bolus.secondsPassed, Constants_1.BOLUS_SECONDS_PASSED_LIMITS)) {
+            throw RecommendationError_1.BolusInsulinSecondsPassedError();
+        }
+    });
+}
+exports.checkRecentBolusesSecondsPassed = checkRecentBolusesSecondsPassed;
+function checkActivityDuration(activityDuration) {
+    if (!Utils_1.Utils.isInClosedInterval(activityDuration, Constants_1.ACTIVITY_DURATION_MINUTES_LIMITS)) {
+        throw RecommendationError_1.ActivityDurationError();
+    }
+}
+exports.checkActivityDuration = checkActivityDuration;
+function checkActivityIntensity(activityIntensity) {
+    switch (activityIntensity) {
+        case RecommendationCalculator_1.ActivityIntensity.Hard:
+        case RecommendationCalculator_1.ActivityIntensity.Moderate:
+        case RecommendationCalculator_1.ActivityIntensity.Light:
+        case RecommendationCalculator_1.ActivityIntensity.Post:
+            break;
+        default:
+            throw RecommendationError_1.ActivityIntensityError();
+    }
+}
+exports.checkActivityIntensity = checkActivityIntensity;
+function checkActivityDate(activity) {
+    const maximumDate = moment_1.default
+        .utc(activity.activityDate)
+        .add(activity.activityDuration + Constants_1.ONE_HOUR_MINUTES * 4, `minutes`);
+    if (!moment_1.default.utc().isBefore(maximumDate)) {
+        throw RecommendationError_1.ActivityDateError();
+    }
+}
+exports.checkActivityDate = checkActivityDate;
+function checkActivitySettings(activitySettings) {
+    for (const intensity of Object.keys(activitySettings)) {
+        for (const interval of Object.keys(activitySettings[intensity])) {
+            const value = activitySettings[intensity][interval];
+            const isInInterval = Utils_1.Utils.isInClosedInterval(value, Constants_1.ACTIVITY_SETTINGS_INTERVAL_LIMITS);
+            if (intensity === RecommendationCalculator_1.ActivityIntensity.Hard.toLowerCase() && interval === enum_1.ActivityInterval.fromFortysix) {
+                if (!isInInterval && value !== null) {
+                    throw RecommendationError_1.ActivitySettingsError();
+                }
+            }
+            else if (!isInInterval) {
+                throw RecommendationError_1.ActivitySettingsError();
+            }
+        }
+    }
+}
+exports.checkActivitySettings = checkActivitySettings;
+function checkActivityTargetBGL(activitySettings) {
+    if (!Utils_1.Utils.isInClosedInterval(activitySettings, Constants_1.ACTIVITY_TARGET_BGL_MMOL_LIMITS)) {
+        throw RecommendationError_1.ActivityTargetBGLError();
+    }
+}
+exports.checkActivityTargetBGL = checkActivityTargetBGL;
+function checkCurrentBGL(currentBGL) {
+    if (currentBGL !== null) {
+        if (!Utils_1.Utils.isInClosedInterval(currentBGL, Constants_1.CURRENT_BGL_MMOL_LIMITS)) {
+            throw RecommendationError_1.CurrentBGLError();
+        }
+    }
+}
+exports.checkCurrentBGL = checkCurrentBGL;
+function checkTargetBGL(targetBGL) {
+    if (!Utils_1.Utils.isInClosedInterval(targetBGL, Constants_1.TARGET_BGL_MMOL_LIMITS)) {
+        throw RecommendationError_1.TargetBGLError();
+    }
+}
+exports.checkTargetBGL = checkTargetBGL;
+function checkInsulinSensitivity(insulinSensitivity) {
+    if (!Utils_1.Utils.isInClosedInterval(insulinSensitivity, Constants_1.INSULIN_SENSITIVITY_MMOL_LIMITS)) {
+        throw RecommendationError_1.InsulinSensitivityError();
+    }
+}
+exports.checkInsulinSensitivity = checkInsulinSensitivity;
+function checkInsulinToCarbRatio(insulinToCarbRatio) {
+    if (!Utils_1.Utils.isInClosedInterval(insulinToCarbRatio, Constants_1.INSULIN_TO_CARBS_RATIO_LIMITS)) {
+        throw RecommendationError_1.InsulinToCarbsRatioError();
+    }
+}
+exports.checkInsulinToCarbRatio = checkInsulinToCarbRatio;
+function checkCarbohydrates(carbohydrates) {
+    if (!Utils_1.Utils.isInClosedInterval(carbohydrates, Constants_1.CARBOHYDRATES_LIMTS)) {
+        throw RecommendationError_1.CarbohydrateLimitError();
+    }
+}
+exports.checkCarbohydrates = checkCarbohydrates;

package/src/utils/Validations.ts

@@ -0,0 +1,210 @@
+import { IRecommendationParams } from "@hedia/recommendation-calculator";
+import {
+	ActivityIntensity,
+	IActivityInterval,
+	IActivitySettings,
+	IRecentBolus,
+} from "@hedia/recommendation-calculator/src/RecommendationCalculator";
+import moment from "moment";
+import { IRecommendationProps } from "../RecommendationScreen";
+import { ActivityInterval, BGUnit, InjectionMethod, Languages } from "../types/enum";
+import {
+	ACTIVITY_DURATION_MINUTES_LIMITS,
+	ACTIVITY_SETTINGS_INTERVAL_LIMITS,
+	ACTIVITY_TARGET_BGL_MMOL_LIMITS,
+	BOLUS_SECONDS_PASSED_LIMITS,
+	CARBOHYDRATES_LIMTS,
+	CURRENT_BGL_MMOL_LIMITS,
+	INSULIN_DOSIS_LIMITS,
+	INSULIN_SENSITIVITY_MMOL_LIMITS,
+	INSULIN_TO_CARBS_RATIO_LIMITS,
+	ONE_HOUR_MINUTES,
+	REMINDER_HOURS_LIMITS,
+	TARGET_BGL_MMOL_LIMITS,
+} from "./Constants";
+import {
+	ActivityDateError,
+	ActivityDurationError,
+	ActivityIntensityError,
+	ActivitySettingsError,
+	ActivityTargetBGLError,
+	BolusInsulinDosisError,
+	BolusInsulinSecondsPassedError,
+	CarbohydrateLimitError,
+	CurrentBGLError,
+	InjectionMethodError,
+	InsulinSensitivityError,
+	InsulinToCarbsRatioError,
+	LanguageError,
+	TargetBGLError,
+	UnitError,
+	UserReminderError,
+} from "./RecommendationError";
+import { Utils } from "./Utils";
+
+export function validateParams(props: IRecommendationProps): void {
+	checkCalculatorParams(props.calculatorParams);
+	checkUnit(props.units);
+	checkInjectionMethod(props.injectionMethod);
+	checkUserReminder(props.userReminder);
+	checkLanguage(props.language);
+}
+
+export function checkLanguage(language: Languages): void {
+	switch (language) {
+		case Languages.da:
+		case Languages.en:
+			break;
+		default:
+			throw LanguageError();
+	}
+}
+
+export function checkInjectionMethod(injectionMethod: InjectionMethod): void {
+	switch (injectionMethod) {
+		case InjectionMethod.PenHalf:
+		case InjectionMethod.PenWhole:
+		case InjectionMethod.Pump:
+			break;
+		default:
+			throw InjectionMethodError();
+	}
+}
+
+export function checkUnit(unit: BGUnit): void {
+	switch (unit) {
+		case BGUnit.MG_DL:
+		case BGUnit.MMOL_L:
+			break;
+		default:
+			throw UnitError();
+	}
+}
+
+export function checkUserReminder(userReminder: number): void {
+	if (!Utils.isInClosedInterval(userReminder, REMINDER_HOURS_LIMITS)) {
+		throw UserReminderError();
+	}
+}
+
+function checkCalculatorParams(calculatorParams: IRecommendationProps["calculatorParams"]): void {
+	checkActivity(calculatorParams.activity);
+	checkCarbohydrates(calculatorParams.carbohydrates);
+	checkCurrentBGL(calculatorParams.currentBGL);
+	checkTargetBGL(calculatorParams.targetBGL);
+	checkInsulinToCarbRatio(calculatorParams.carbohydrateRatio);
+	checkInsulinSensitivity(calculatorParams.insulinSensitivity);
+	checkRecentBolusesInsulinDosis(calculatorParams.recentBoluses);
+	checkRecentBolusesSecondsPassed(calculatorParams.recentBoluses);
+}
+
+export function checkActivity(activity: IRecommendationParams["activity"]): void {
+	if (activity) {
+		checkActivityDate(activity);
+		checkActivityDuration(activity.activityDuration);
+		checkActivityIntensity(activity.activityIntensity);
+		checkActivitySettings(activity.activitySettings);
+		checkActivityTargetBGL(activity.activitySettings.target);
+	}
+}
+
+export function checkRecentBolusesInsulinDosis(recentBoluses: Array<IRecentBolus>): void {
+	recentBoluses.forEach((bolus: IRecentBolus): void => {
+		if (!Utils.isInClosedInterval(bolus.insulinDosis, INSULIN_DOSIS_LIMITS)) {
+			throw BolusInsulinDosisError();
+		}
+	});
+}
+
+export function checkRecentBolusesSecondsPassed(recentBoluses: Array<IRecentBolus>): void {
+	recentBoluses.forEach((bolus: IRecentBolus): void => {
+		if (!Utils.isInClosedInterval(bolus.secondsPassed, BOLUS_SECONDS_PASSED_LIMITS)) {
+			throw BolusInsulinSecondsPassedError();
+		}
+	});
+}
+
+export function checkActivityDuration(activityDuration: IRecommendationParams["activity"]["activityDuration"]): void {
+	if (!Utils.isInClosedInterval(activityDuration, ACTIVITY_DURATION_MINUTES_LIMITS)) {
+		throw ActivityDurationError();
+	}
+}
+
+export function checkActivityIntensity(
+	activityIntensity: IRecommendationParams["activity"]["activityIntensity"],
+): void {
+	switch (activityIntensity) {
+		case ActivityIntensity.Hard:
+		case ActivityIntensity.Moderate:
+		case ActivityIntensity.Light:
+		case ActivityIntensity.Post:
+			break;
+		default:
+			throw ActivityIntensityError();
+	}
+}
+export function checkActivityDate(activity: IRecommendationParams["activity"]): void {
+	const maximumDate = moment
+		.utc(activity.activityDate)
+		.add(activity.activityDuration + ONE_HOUR_MINUTES * 4, `minutes`);
+	if (!moment.utc().isBefore(maximumDate)) {
+		throw ActivityDateError();
+	}
+}
+
+type intensityType = Omit<IActivitySettings, "target">;
+export function checkActivitySettings(activitySettings: IRecommendationParams["activity"]["activitySettings"]): 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) {
+				if (!isInInterval && value !== null) {
+					throw ActivitySettingsError();
+				}
+			} else if (!isInInterval) {
+				throw ActivitySettingsError();
+			}
+		}
+	}
+}
+
+export function checkActivityTargetBGL(
+	activitySettings: IRecommendationParams["activity"]["activitySettings"]["target"],
+): void {
+	if (!Utils.isInClosedInterval(activitySettings, ACTIVITY_TARGET_BGL_MMOL_LIMITS)) {
+		throw ActivityTargetBGLError();
+	}
+}
+
+export function checkCurrentBGL(currentBGL: number): void {
+	if (currentBGL !== null) {
+		if (!Utils.isInClosedInterval(currentBGL, CURRENT_BGL_MMOL_LIMITS)) {
+			throw CurrentBGLError();
+		}
+	}
+}
+
+export function checkTargetBGL(targetBGL: number): void {
+	if (!Utils.isInClosedInterval(targetBGL, TARGET_BGL_MMOL_LIMITS)) {
+		throw TargetBGLError();
+	}
+}
+
+export function checkInsulinSensitivity(insulinSensitivity: number): void {
+	if (!Utils.isInClosedInterval(insulinSensitivity, INSULIN_SENSITIVITY_MMOL_LIMITS)) {
+		throw InsulinSensitivityError();
+	}
+}
+
+export function checkInsulinToCarbRatio(insulinToCarbRatio: number): void {
+	if (!Utils.isInClosedInterval(insulinToCarbRatio, INSULIN_TO_CARBS_RATIO_LIMITS)) {
+		throw InsulinToCarbsRatioError();
+	}
+}
+
+export function checkCarbohydrates(carbohydrates: number): void {
+	if (!Utils.isInClosedInterval(carbohydrates, CARBOHYDRATES_LIMTS)) {
+		throw CarbohydrateLimitError();
+	}
+}

package/src/components/Emotion.d.ts

@@ -1,14 +0,0 @@
-import React from "react";
-import { MoodEnum } from "../types/enum";
-interface IProps {
-    moodSelected(mood: MoodEnum | 0): void;
-}
-interface IState {
-    selected: MoodEnum | 0;
-}
-export default class Emotion extends React.Component<IProps, IState> {
-    state: IState;
-    handleIconPress: (selected: number, toggle: boolean) => void;
-    render(): JSX.Element;
-}
-export {};

package/src/components/Emotion.tsx

@@ -1,70 +0,0 @@
-import React from "react";
-import { Dimensions, Image, StyleSheet, Text, View } from "react-native";
-import { i18n } from "../locale/i18nUtils";
-import { MoodEnum } from "../types/enum";
-import MoodIcon from "./MoodIcon";
-
-interface IProps {
-	moodSelected(mood: MoodEnum | 0): void;
-}
-
-type value = keyof typeof MoodEnum;
-
-interface IState {
-	selected: MoodEnum | 0;
-}
-
-export default class Emotion extends React.Component<IProps, IState> {
-	public state: IState = {
-		selected: 0,
-	};
-
-	public handleIconPress = (selected: number, toggle: boolean) => {
-		const select = toggle ? selected : 0;
-		this.setState({
-			selected: select,
-		});
-		this.props.moodSelected(select);
-	};
-
-	public render() {
-		const values = Object.values(MoodEnum).filter((val) => isNaN(Number(val))) as Array<value>;
-
-		const mapped = values.map((key) => {
-			const moodValue = MoodEnum[key];
-			return (
-				<MoodIcon
-					onPress={(toggle) => this.handleIconPress(moodValue, toggle)}
-					active={moodValue === this.state.selected}
-					mood={moodValue}
-					key={moodValue}
-				/>
-			);
-		});
-
-		return (
-			<View style={emotionStyles.container}>
-				<View style={emotionStyles.feelingContainer}>
-					<Text style={emotionStyles.feelingText}>{i18n._("How are you feeling?")}</Text>
-				</View>
-				<View style={emotionStyles.moodIconContainer}>{mapped}</View>
-			</View>
-		);
-	}
-}
-
-const emotionStyles = StyleSheet.create({
-	container: {
-		flex: 1,
-	},
-	feelingContainer: {
-		marginVertical: `3%`,
-	},
-	feelingText: {
-		textAlign: `center`,
-		color: `white`,
-		fontWeight: `bold`,
-		fontSize: Dimensions.get(`screen`).width / 26,
-	},
-	moodIconContainer: { flex: 1, flexDirection: `row`, justifyContent: `center` },
-});