@hedia/recommendation-screen 1.0.7 → 1.1.0

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.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.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/App.jsx

@@ -1,70 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importDefault(require("react"));
-const RecommendationScreen_1 = __importDefault(require("./src/RecommendationScreen"));
-const enum_1 = require("./src/types/enum");
-class App extends react_1.default.Component {
-    constructor(props) {
-        super(props);
-        this.exitCallback = () => {
-            console.log(`Exiting...`);
-        };
-        this.removeCarbs = () => {
-            this.setState({
-                carbs: null,
-            });
-        };
-        this.changeCarbs = (carbs) => {
-            this.setState({
-                carbs,
-            });
-        };
-        this.onYes = () => {
-            console.log(`Navigate to recent bolus screen`);
-        };
-        this.updatedRecommendedInsulin = (val) => {
-            console.log(`Updated recommended insulin: `, val);
-        };
-        this.transferToLogbook = (...params) => {
-            console.log(`Transfered:`, params);
-        };
-        this.handleError = (error) => {
-            console.log(JSON.stringify(error));
-            switch (error.type) {
-                case enum_1.RecommendationErrorEnum.ActivityOutOfRange:
-                    console.log(`Handling activity out of range!`);
-                    break;
-                default:
-                    throw error;
-            }
-        };
-        const params = {
-            carbohydrateRatio: 10,
-            carbohydrates: 4,
-            currentBGL: 2.2,
-            insulinSensitivity: 4,
-            targetBGL: 6,
-            recentBoluses: [],
-        };
-        const paramsTest = {
-            currentBGL: 10.8,
-            carbohydrates: 27,
-            carbohydrateRatio: 22,
-            insulinSensitivity: 5,
-            targetBGL: 7,
-            recentBoluses: [],
-        };
-        this.state = {
-            params,
-            carbs: 25,
-            injectionMethod: enum_1.InjectionMethod.Pump,
-        };
-    }
-    render() {
-        return (<RecommendationScreen_1.default language={enum_1.Languages.en} injectionMethod={this.state.injectionMethod} calculatorParams={this.state.params} units={enum_1.BGUnit.MMOL_L} exitCallback={this.exitCallback} removeRecommendedCarbs={this.removeCarbs} onRecentInsulinYes={this.onYes} transferToLogbook={this.transferToLogbook} onError={this.handleError}/>);
-    }
-}
-exports.default = App;

package/index.d.ts

@@ -1,5 +0,0 @@
-import RecommendationScreen from "./src/RecommendationScreen";
-import { RecommendationErrorEnum } from "./src/types/enum";
-import { ActivityNullError, ActivityRangeError, CarbohydrateLimitError, InsulinLimitError, RecommendationError } from "./src/utils/RecommendationError";
-export default RecommendationScreen;
-export { ActivityNullError, ActivityRangeError, CarbohydrateLimitError, InsulinLimitError, RecommendationError, RecommendationErrorEnum, };

package/index.js

@@ -1,16 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RecommendationErrorEnum = exports.RecommendationError = exports.InsulinLimitError = exports.CarbohydrateLimitError = exports.ActivityRangeError = exports.ActivityNullError = void 0;
-const RecommendationScreen_1 = __importDefault(require("./src/RecommendationScreen"));
-const enum_1 = require("./src/types/enum");
-Object.defineProperty(exports, "RecommendationErrorEnum", { enumerable: true, get: function () { return enum_1.RecommendationErrorEnum; } });
-const RecommendationError_1 = require("./src/utils/RecommendationError");
-Object.defineProperty(exports, "ActivityNullError", { enumerable: true, get: function () { return RecommendationError_1.ActivityNullError; } });
-Object.defineProperty(exports, "ActivityRangeError", { enumerable: true, get: function () { return RecommendationError_1.ActivityRangeError; } });
-Object.defineProperty(exports, "CarbohydrateLimitError", { enumerable: true, get: function () { return RecommendationError_1.CarbohydrateLimitError; } });
-Object.defineProperty(exports, "InsulinLimitError", { enumerable: true, get: function () { return RecommendationError_1.InsulinLimitError; } });
-Object.defineProperty(exports, "RecommendationError", { enumerable: true, get: function () { return RecommendationError_1.RecommendationError; } });
-exports.default = RecommendationScreen_1.default;

package/src/RecommendationScreen.d.ts

@@ -1,43 +0,0 @@
-import React from "react";
-import { BGUnit, InjectionMethod, Languages, MoodEnum } from "./types/enum";
-import * as Calculator from "@hedia/recommendation-calculator";
-import { RecommendationError } from "./utils/RecommendationError";
-interface IResult {
-    suggested: number;
-    entered?: number;
-}
-export interface IRecommendationProps {
-    units: BGUnit;
-    language: Languages;
-    calculatorParams: Calculator.IRecommendationParams;
-    injectionMethod: InjectionMethod;
-    exitCallback(): void;
-    removeRecommendedCarbs(): void;
-    onRecentInsulinYes(): void;
-    transferToLogbook(carbs: IResult, insulin: IResult, reminder: number): void;
-    onError(error: RecommendationError): void;
-}
-interface IState {
-    remeasureTime: number;
-    showRecentInsulin: boolean;
-    insulinRecommendation: number;
-    activityReduction?: number;
-    carbRecommendation: number;
-    activeInsulin: number;
-    selectedMood: MoodEnum | 0;
-    enteredCarbs?: number;
-    enteredInsulin?: number;
-}
-export default class RecommendationScreen extends React.Component<IRecommendationProps, IState> {
-    private readonly timer;
-    constructor(props: IRecommendationProps);
-    updateRemeasureTime: (remeasureTime: number) => void;
-    handleNoRecentInsulin: () => void;
-    removeCarbRecommendation: () => void;
-    handleMoodSelected: (selectedMood: IState["selectedMood"]) => void;
-    updateCarbRecommendation: (enteredCarbs: number) => void;
-    updateInsulinRecommendation: (enteredInsulin: number) => void;
-    handleTransfer: () => void;
-    render(): JSX.Element;
-}
-export {};

package/src/RecommendationScreen.jsx

@@ -1,158 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importDefault(require("react"));
-const react_native_1 = require("react-native");
-const enum_1 = require("./types/enum");
-const Constants_1 = require("./utils/Constants");
-const Header_1 = __importStar(require("./components/Header"));
-const InfoBars_1 = __importStar(require("./components/InfoBars"));
-const RecentInsulin_1 = __importDefault(require("./components/RecentInsulin"));
-const RecommendedCarbs_1 = __importDefault(require("./components/RecommendedCarbs"));
-const RecommendedInsulin_1 = __importDefault(require("./components/RecommendedInsulin"));
-const Remeasure_1 = __importDefault(require("./components/Remeasure"));
-const Calculator = __importStar(require("@hedia/recommendation-calculator"));
-const react_2 = require("@lingui/react");
-const Emotion_1 = __importDefault(require("./components/Emotion"));
-const TransferToLogbook_1 = __importDefault(require("./components/TransferToLogbook"));
-const RecommendationError_1 = require("./utils/RecommendationError");
-const i18nUtils_1 = require("./locale/i18nUtils");
-const Utils_1 = require("./utils/Utils");
-// Ignoring long timer warnings
-// https://github.com/facebook/react-native/issues/12981#issuecomment-652745831
-react_native_1.YellowBox.ignoreWarnings([`Setting a timer`]);
-class RecommendationScreen extends react_1.default.Component {
-    constructor(props) {
-        super(props);
-        this.updateRemeasureTime = (remeasureTime) => {
-            this.setState({
-                remeasureTime,
-            });
-        };
-        this.handleNoRecentInsulin = () => {
-            this.setState({
-                showRecentInsulin: false,
-            });
-        };
-        this.removeCarbRecommendation = () => {
-            this.setState({
-                enteredCarbs: null,
-                carbRecommendation: null,
-            });
-            this.props.removeRecommendedCarbs();
-        };
-        this.handleMoodSelected = (selectedMood) => {
-            this.setState({
-                selectedMood,
-            });
-        };
-        this.updateCarbRecommendation = (enteredCarbs) => {
-            this.setState({
-                enteredCarbs,
-            });
-        };
-        this.updateInsulinRecommendation = (enteredInsulin) => {
-            this.setState({
-                enteredInsulin,
-            });
-        };
-        this.handleTransfer = () => {
-            // TODO: Handle Errors/Warnings
-            // 300 carbs.
-            // < 5 mmol && activity
-            // > 2, <= 3.5 mmol/L
-            this.props.transferToLogbook({
-                suggested: this.state.carbRecommendation,
-                entered: this.state.enteredCarbs,
-            }, {
-                suggested: this.state.insulinRecommendation,
-                entered: this.state.enteredInsulin,
-            }, this.state.remeasureTime);
-        };
-        i18nUtils_1.changeLanguage(props.language);
-        // Handle >= 1.1, <= 2 mmol/L (SevereHypoglycemia)
-        const { currentBGL, recentBoluses } = props?.calculatorParams;
-        if (currentBGL <= 2 && currentBGL >= 1.1) {
-            props.onError(RecommendationError_1.SevereHypoglycemiaError);
-        }
-        const { bolus, carbRecommendation, activityReduction } = Calculator.calculateRecommendation(props.calculatorParams);
-        this.state = {
-            remeasureTime: 1.5,
-            showRecentInsulin: recentBoluses?.length === 0,
-            insulinRecommendation: Utils_1.Utils.roundValue(bolus, props.injectionMethod),
-            activityReduction,
-            carbRecommendation,
-            activeInsulin: 0.0,
-            selectedMood: 0,
-        };
-        this.timer = setTimeout(() => {
-            props.onError(RecommendationError_1.TimeoutLimitError);
-        }, enum_1.Milliseconds.Minute * 15);
-    }
-    render() {
-        return (<react_2.I18nProvider language={this.props.language} i18n={i18nUtils_1.i18n}>
-				<react_native_1.ScrollView style={containerStyles.container}>
-					<Header_1.default exitCallback={this.props.exitCallback}/>
-					<InfoBars_1.default label={i18nUtils_1.i18n._("Active Insulin")} value={`${this.state.activeInsulin}`} units={i18nUtils_1.i18n._("units")} showZeroAsDash={false}/>
-					<InfoBars_1.default label={i18nUtils_1.i18n._("Blood Glucose Level")} value={`${this.props.calculatorParams.currentBGL}`} units={this.props.units} showZeroAsDash={true}/>
-					<react_native_1.View style={containerStyles.calcContainer}>
-						<react_native_1.View style={containerStyles.calcMargin}>
-							<react_native_1.View style={[
-            containerStyles.calcBorder,
-            {
-                borderColor: this.state.carbRecommendation
-                    ? Constants_1.BORDER_COLOUR_TEAL
-                    : Constants_1.BORDER_COLOUR_WHITE,
-            },
-        ]}>
-								<RecommendedCarbs_1.default enteredCarbs={`${this.props.calculatorParams.carbohydrates}`} changedRecommendedCarbs={this.updateCarbRecommendation} recommendedCarbs={`${this.state.enteredCarbs ?? this.state.carbRecommendation}`} removeRecommendedCarbs={this.removeCarbRecommendation} onError={this.props.onError}/>
-								<Remeasure_1.default onSliderChange={this.updateRemeasureTime} remeasureTime={this.state.remeasureTime}/>
-							</react_native_1.View>
-						</react_native_1.View>
-					</react_native_1.View>
-					{this.state.showRecentInsulin ? (<RecentInsulin_1.default onRecentInsulinYes={this.props.onRecentInsulinYes} onRecentInsulinNo={this.handleNoRecentInsulin}/>) : (<RecommendedInsulin_1.default injectionMethod={this.props.injectionMethod} insulinRecommendation={this.state.enteredInsulin ?? this.state.insulinRecommendation} activityReduction={this.state.activityReduction} updateRecommendedInsulin={this.updateInsulinRecommendation} onError={this.props.onError}/>)}
-					<Emotion_1.default moodSelected={this.handleMoodSelected}/>
-					<TransferToLogbook_1.default visible={!this.state.showRecentInsulin} transfer={this.handleTransfer}/>
-				</react_native_1.ScrollView>
-			</react_2.I18nProvider>);
-    }
-}
-exports.default = RecommendationScreen;
-const containerStyles = react_native_1.StyleSheet.create({
-    container: {
-        flex: 1,
-        backgroundColor: Constants_1.BACKGROUND_COLOUR_PURPLE,
-    },
-    calcContainer: {
-        flex: 1,
-    },
-    calcMargin: {
-        flex: 1,
-        margin: Header_1.headerStyles.margin.margin,
-    },
-    calcBorder: {
-        ...InfoBars_1.infoStyles.border,
-        borderColor: Constants_1.BORDER_COLOUR_TEAL,
-    },
-});

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 {};