@hedia/recommendation-screen 2.1.73 → 2.1.74-alpha.1

package/lib/commonjs/RecommendationScreen.js

@@ -0,0 +1,768 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RecommendationScreen = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _reactNative = require("react-native");
+var _reactNativeKeyboardAwareScrollView = require("react-native-keyboard-aware-scroll-view");
+var Calculator = _interopRequireWildcard(require("@hedia/recommendation-calculator"));
+var _types = require("@hedia/types");
+var _Activity = _interopRequireDefault(require("./components/activity/Activity"));
+var _ExitModal = _interopRequireDefault(require("./components/ExitModal"));
+var _InfoBars = _interopRequireDefault(require("./components/InfoBars"));
+var _Emotion = _interopRequireDefault(require("./components/mood/Emotion"));
+var _RecentInsulin = _interopRequireDefault(require("./components/RecentInsulin"));
+var _RecommendationModal = _interopRequireDefault(require("./components/RecommendationModal"));
+var _RecommendedCarbs = _interopRequireDefault(require("./components/RecommendedCarbs"));
+var _RecommendedInsulin = _interopRequireDefault(require("./components/RecommendedInsulin"));
+var _Remeasure = _interopRequireDefault(require("./components/Remeasure"));
+var _fonts = require("./components/styles/fonts");
+var _Text = _interopRequireDefault(require("./components/Text"));
+var _TimeoutModal = _interopRequireDefault(require("./components/TimeoutModal"));
+var _TransferToLogbook = _interopRequireDefault(require("./components/TransferToLogbook"));
+var _translate = require("./locales/translate");
+var _enum = require("./types/enum");
+var _AttentionMessages = require("./utils/AttentionMessages");
+var _Constants = require("./utils/Constants");
+var _RecommendationUtils = require("./utils/RecommendationUtils");
+var _Utils = require("./utils/Utils");
+var _Validations = require("./utils/Validations");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  InfoBarTestIds,
+  RecommendationScreenTestIds
+} = _enum.Testing.Id;
+
+// Ignoring long timer warnings
+// https://github.com/facebook/react-native/issues/12981#issuecomment-652745831
+_reactNative.LogBox.ignoreLogs([`Setting a timer`]);
+
+/** Represents both a suggestion by HDA and an actual amount of either insulin or carbohydrates. */
+
+/**
+ * The RecommendationScreen is the React component that passes relevant inputs to the recommendation calculation module and presents
+ * the resulting recommendation along with related messages or warnings to the user.
+ * The RecommendationScreen component accepts properties with the user’s settings/preferences and other inputs needed for calculating a recommendation.
+ * @noInheritDoc
+ */
+class RecommendationScreen extends _react.default.Component {
+  /** Reference to the timer that prompts the user to make a new calculation after 15 minutes. */
+
+  /**
+   * The carbohydrate recommendation for the user.
+   * This value is saved in a member variable because we want to store it unmodified if the logbook entry
+   * gets saved regardless of what other changes were made on the recommendation screen.
+   */
+
+  /**
+   * A guard against displaying wrong or dangerous information to the user.
+   * If an error has occurred, this variable will be set to true and an empty placeholder will be rendered instead of the normal recommendation screen.
+   */
+  hasError = false;
+  /** The timestamp when the current recommendation was made. For determining if the recommendation is too old and should be hidden from the user. */
+
+  /**
+   * Steps:
+   * 1. Call the super() method with the props.
+   * 2. Execute the following steps and if an exception is thrown, catch it, set the hasError member variable to true and call the onError callback prop with the caught exception as argument:
+   * 	- Call the validateParams() method with the props as argument
+   * 	- Set the recommendationDate member to the current date and time
+   * 	- Set the language by using the language prop as argument for calling changeLanguage()
+   * 	- Unpack recentBoluses from the calculatorParams prop.
+   * 	- Use the calculatorParams prop as argument for calling calculateRecommendation() and unpack all of the resulting values.
+   * 	- Call the onRecommendationDisplayed() callback prop if the recommendation is visible
+   * 	- Copy the carbRecommendation to the suggestedCarbs member variable.
+   * 	- Set the following state variables:
+   * 		- Set remeasureTime to the return value from calling the getBGLevelRemeasurementReminder() method.
+   * 		- Set isRecommendationDisplayed to be false if the length of recentBoluses is 0 or false otherwise.
+   * 		- Set insulinRecommendation to be the bolus insulin recommendation rounded using roundValue().
+   * 		- Set wasLimited to the wasLimited return value from calling calculateRecommendation() above.
+   * 		- Set activityReduction to the reduction returned from the calculation result.
+   * 		- Set carbRecommendation to the recommendation returned from the calculation result.
+   * 		- Set activeInsulin to the estimation returned from the calculation result.
+   * 		- Set enteredCarbs, enteredInsulin, selectedMood to null.
+   * 		- Set recommendationModal to be true if wasLimited is true or if carbRecommendation after being rounded is truthy or if the return value from calling the getBGLevelAttentionMessage() method is truthy.
+   * 		- Set onlyShowLimitationMessage, showTimeoutModal to be false.
+   *		- Set showExitModal with the value of the showExitModal prop.
+   * 3. Start a 15 minute timer assigned to the timer member variable using the setTimeout() function. When the timer expires, call the showTimeoutModal() method.
+   * @param props The data required to initialise the Recommendation Screen
+   */
+  constructor(props) {
+    super(props);
+    try {
+      (0, _Validations.validateParams)(props);
+      (0, _translate.changeLocale)(props.language);
+      this.recommendationDate = new Date();
+      const {
+        recentBoluses
+      } = props.calculatorParams;
+      const {
+        bolus,
+        carbRecommendation,
+        activityReduction,
+        wasLimited,
+        activeInsulin
+      } = Calculator.calculateRecommendation(props.calculatorParams);
+      this.suggestedCarbs = carbRecommendation;
+      const isRecommendationDisplayed = recentBoluses?.length !== 0;
+      if (isRecommendationDisplayed) {
+        this.props.onRecommendationDisplayed();
+      }
+      this.state = {
+        remeasureTime: this.getBGLevelRemeasurementReminder(),
+        isRecommendationDisplayed,
+        insulinRecommendation: _Utils.Utils.roundValue(bolus, props.injectionMethod),
+        wasLimited,
+        activityReduction,
+        carbRecommendation,
+        activeInsulin,
+        enteredCarbs: null,
+        enteredInsulin: null,
+        selectedMood: null,
+        recommendationModal: wasLimited || !!Math.round(carbRecommendation) || !!this.getBGLevelAttentionMessage(),
+        onlyShowLimitationMessage: false,
+        showExitModal: props.showExitModal,
+        showTimeoutModal: false,
+        timeoutModalAction: null,
+        exitModalAction: null
+      };
+      this.timer = setTimeout(this.showTimeoutModal, _types.Milliseconds.Minute * 15);
+    } catch (error) {
+      this.hasError = true;
+      props.onError(error);
+    }
+  }
+
+  /**
+   * Called immediately after a component is mounted. Setting state here will trigger re-rendering.
+   *
+   * Steps:
+   * 1. If there is no error, create a listener to call the handleAppStateChange() method when the app state changes.
+   */
+  componentDidMount() {
+    if (!this.hasError) {
+      this.appStateSubscription = _reactNative.AppState.addEventListener(`change`, this.handleAppStateChange);
+    }
+  }
+
+  /**
+   * Called immediately before a component is destroyed.
+   * Perform any necessary cleanup in this method, such as cancelled network requests, or cleaning up any DOM elements created in componentDidMount.
+   *
+   * Clear the 15 minute timer that was set in the constructor during initialisation so it doesn't keep running and gets triggered after the recommendation screen was closed.
+   *
+   * Steps:
+   * 1. Call clearTimeout on the timer member variable.
+   * 2. Remove the listener for app state changes that was set by the componentDidMount() method.
+   */
+  componentWillUnmount() {
+    if (this.timer !== undefined) {
+      clearTimeout(this.timer);
+    }
+    this.appStateSubscription?.remove();
+  }
+
+  /**
+   * Called immediately after updating occurs. This method is not called for the initial render.
+   * Use this as an opportunity to operate on the DOM when the component has been updated.
+   * Steps:
+   * 1. If the showExitModal prop is true and it was false before, call the onExit() method.
+   * @param showExitModal The previous showExitModal props of the component.
+   */
+  componentDidUpdate(_ref) {
+    let {
+      showExitModal
+    } = _ref;
+    if (this.props.showExitModal && showExitModal !== this.props.showExitModal) {
+      this.onExit();
+    }
+  }
+
+  /**
+   * Steps:
+   * 1. Evaluate a boolean called isOlderThan15Minutes to indicate whether the recommendationDate member variable represents a time more than 15 minutes ago.
+   * 2. If nextAppState is ‘active’ and isOlderThan15Minutes is true then call the showTimeoutModal() method.
+   * @param nextAppState The new state of the app.
+   */
+  handleAppStateChange = nextAppState => {
+    const time = this.recommendationDate.getTime();
+    const isOlderThan15Minutes = new Date().getTime() - time > _types.Milliseconds.Minute * 15;
+    if (nextAppState === `active` && isOlderThan15Minutes) {
+      this.showTimeoutModal();
+    }
+  };
+
+  /**
+   * Steps:
+   * 1. Set the showTimeoutModal state variable to be true.
+   * */
+  showTimeoutModal = () => {
+    this.setState({
+      showTimeoutModal: true
+    });
+  };
+
+  /**
+   * Make a new insulin calculation and set the result to be displayed to the user.
+   *
+   * Steps:
+   * 1. Use calculatorParams as an argument for calling calculateRecommendation(). Unpack bolus, wasLimited, and activityReduction from the result.
+   * 2. Set the following state variables:
+   * 	- Set insulinRecommendation to the bolus rounded using the roundValue() function.
+   * 	- Set enteredInsulin to be undefined.
+   * 	- Set wasLimited to be the value returned from the insulin calculator.
+   * 	- Set activityReduction to be the value returned from the insulin calculator.
+   * 	- Set showLimitationMessage to be the wasLimited value returned from the insulin calculator.
+   * @param calculatorParams The input values for the bolus calculator itself.
+   */
+  recalculateInsulin = calculatorParams => {
+    const {
+      bolus,
+      wasLimited,
+      activityReduction
+    } = Calculator.calculateRecommendation(calculatorParams);
+    this.setState({
+      insulinRecommendation: _Utils.Utils.roundValue(bolus, this.props.injectionMethod),
+      enteredInsulin: null,
+      wasLimited,
+      activityReduction,
+      onlyShowLimitationMessage: wasLimited
+    });
+  };
+
+  /**
+   * Handle presses on the exit button in the header bar.
+   *
+   * Steps:
+   * 1. If the insulin recommendation is being displayed (the isRecommendationDisplayed state variable is true):
+   *  	- Set the showExitModal state variable to true.
+   * 2. Else:
+   *  	- Call the exitCallback prop callback function.
+   */
+  onExit = () => {
+    if (this.state?.isRecommendationDisplayed) {
+      this.setState({
+        showExitModal: true
+      });
+    } else {
+      this.props.exitCallback();
+    }
+  };
+
+  /**
+   * Hide the modal that shows attention messages.
+   *
+   * Steps:
+   * 1. Set the recommendationModal state variable to false.
+   */
+  hideAttentionModal = () => {
+    this.setState({
+      recommendationModal: false,
+      onlyShowLimitationMessage: false
+    });
+  };
+
+  /**
+   * Handle presses on the transfer button in the exit modal.
+   */
+  onPressTransferExitModal = () => {
+    this.setState({
+      showExitModal: false,
+      exitModalAction: _enum.ExitModalActions.Transfer
+    });
+  };
+
+  /**
+   * Handle presses on the close calculation button in the exit modal.
+   */
+  onPressCloseExitModal = () => {
+    this.setState({
+      showExitModal: false,
+      exitModalAction: _enum.ExitModalActions.CloseCalculation
+    });
+  };
+
+  /**
+   * Handle presses on the hide button in the exit modal.
+   */
+  onPressHideExitModal = () => {
+    this.setState({
+      showExitModal: false,
+      exitModalAction: _enum.ExitModalActions.Hide
+    });
+  };
+
+  /**
+   * Call the chosen modal action on the didHide modal callback .
+   */
+  onExitModalDidHide = () => {
+    switch (this.state.exitModalAction) {
+      case _enum.ExitModalActions.Transfer:
+        this.handleTransfer();
+        break;
+      case _enum.ExitModalActions.CloseCalculation:
+        this.props.closeCalculationCallback();
+        break;
+      case _enum.ExitModalActions.Hide:
+        this.props.hideExitModal();
+        break;
+    }
+  };
+
+  /**
+   * Handle presses on the close calculation button in the timeout modal.
+   */
+  onPressCloseCalculationTimeoutModal = () => {
+    this.setState({
+      showTimeoutModal: false,
+      timeoutModalAction: _enum.TimeoutModalActions.CloseCalculation
+    });
+  };
+
+  /**
+   * Handle presses on the restart calculation button in the timeout modal.
+   */
+  onPressRestartCalculationTimeoutModal = () => {
+    this.setState({
+      showTimeoutModal: false,
+      timeoutModalAction: _enum.TimeoutModalActions.RestartCalculation
+    });
+  };
+
+  /**
+   * Handle presses on the transfer button in the timeout modal.
+   */
+  onPressTransferTimeoutModal = () => {
+    this.setState({
+      showTimeoutModal: false,
+      timeoutModalAction: _enum.TimeoutModalActions.Transfer
+    });
+  };
+
+  /**
+   * Call the chosen modal action on the didHide modal callback .
+   */
+  onTimeoutModalDidHide = () => {
+    switch (this.state.timeoutModalAction) {
+      case _enum.TimeoutModalActions.RestartCalculation:
+        this.props.restartCalculation();
+        break;
+      case _enum.TimeoutModalActions.Transfer:
+        this.props.onSaveToLogbook();
+        this.handleTransfer();
+        break;
+      case _enum.TimeoutModalActions.CloseCalculation:
+        this.props.onReturnToDashboard();
+        this.props.closeCalculationCallback();
+        break;
+    }
+  };
+
+  /**
+   * Used as a callback function for the Remeasure component to update the state when the remeasure time slider’s value changes.
+   *
+   * Steps:
+   * 1. Set the remeasureTime state variable to the value of the remeasureTime argument.
+   * @param remeasureTime The number of hours for which to wait before reminding the user to measure their BGL again. 0 indicates that the user should not be reminded.
+   */
+  updateRemeasureTime = remeasureTime => {
+    this.setState({
+      remeasureTime
+    });
+  };
+
+  /**
+   * Handle what happens if the user taps “No” to the question about injecting insulin within the last 4 hours.
+   * The card that prompts the user to answer if they have injected insulin within the last 4 hours shall be hidden and
+   * the screen shall automatically be scrolled to the bottom so the user can see the now visible “Transfer to logbook” button.
+   *
+   * Steps:
+   * 1. Set the isRecommendationDisplayed state variable to be true.
+   * 2. Call the onRecommendationDisplayed prop callback function.
+   * 3. As a callback to the setState() method, define a new anonymous function that calls setTimeout() with a duration of 0 milliseconds.
+   *    When the time expires, call the scrollToEnd() method of the scrollView member, with the animated argument set to true.
+   *    This ensures that the scroll event happens after all other events that get queued to happen at the same time,
+   *    so all relevant elements are visible on the screen and the scroll happens reliably.
+   */
+  handleNoRecentInsulin = () => {
+    this.props.onRecentInsulinNo();
+    this.setState({
+      isRecommendationDisplayed: true
+    }, () => {
+      this.props.onRecommendationDisplayed();
+      setTimeout(() => {
+        this.scrollView?.scrollToEnd(true);
+      }, 0);
+    });
+  };
+
+  /**
+   * Handle what happens when the user changes the content of the additional carbohydrates input field.
+   *
+   * Steps:
+   * 1. Set the enteredCarbs state variable to the value of the enteredCarbs argument.
+   * 2. As a callback to the setState() method, define a new anonymous function that calls the recalculateInsulin() function using
+   *    a copy of the calculatorParams prop where the carbohydrates property has been overwritten to be
+   *    the sum of the carbohydrates property of the calculatorParams prop and the enteredCarbs argument.
+   * @param enteredCarbs The amount of carbohydrates in grams that has been entered in the additional carbohydrates input field.
+   */
+  updateCarbRecommendation = enteredCarbs => {
+    const providedCarbs = this.props.calculatorParams.carbohydrates;
+    this.setState({
+      enteredCarbs
+    }, () => {
+      this.recalculateInsulin({
+        ...this.props.calculatorParams,
+        carbohydrates: providedCarbs + enteredCarbs
+      });
+    });
+  };
+
+  /**
+   * Handle what happens when the cross button by the additional carbohydrates button is tapped.
+   *
+   * Steps:
+   * 1. Set both the enteredCarbs and the carbRecommendation state variables to null.
+   * 2. As a callback to the setState() method, define a new anonymous function that calls the recalculateInsulin() function using a copy of the calculatorParams prop.
+   */
+  removeCarbRecommendation = () => {
+    this.setState({
+      enteredCarbs: null,
+      carbRecommendation: null
+    }, () => this.recalculateInsulin({
+      ...this.props.calculatorParams
+    }));
+  };
+
+  /**
+   * Handle what happens when the user is recommended to eat additional carbohydrates but taps the decline button.
+   *
+   * Steps:
+   * 1. Call the hideAttentionModal() method.
+   * 2. Call the removeCarbRecommendation() method.
+   * 3. Call the carbRecommendationAnswer() prop callback function with false as argument.
+   */
+  declineCarbRecommendation = () => {
+    this.hideAttentionModal();
+    this.removeCarbRecommendation();
+    this.props.carbRecommendationAnswer(false);
+  };
+
+  /**
+   * Handle what happens when the user is recommended to eat additional carbohydrates and they tap the accept button.
+   *
+   * Steps:
+   * 1. Call the hideAttentionModal() method.
+   * 2. Call the carbRecommendationAnswer() prop callback function with true as argument.
+   */
+  acceptCarbRecommendation = () => {
+    this.hideAttentionModal();
+    this.props.carbRecommendationAnswer(true);
+  };
+
+  /**
+   * Used as a callback function for the Emotion component to update the state when a mood icon is tapped.
+   *
+   * Steps:
+   * 1. Set the selectedMood state variable to the value of the selectedMood argument.
+   * @param selectedMood he mood that should be selected going forward or null if no mood should be selected.
+   */
+  handleMoodSelected = selectedMood => {
+    this.setState({
+      selectedMood
+    });
+  };
+
+  /**
+   * Handle what happens when the user changes the content of the insulin input field.
+   *
+   * Steps:
+   * 1. Set the enteredInsulin state variable to the value of the enteredInsulin argument.
+   * @param enteredInsulin The amount of insulin (in units) that has been entered in the insulin input field.
+   */
+  updateInsulinRecommendation = enteredInsulin => {
+    this.setState({
+      enteredInsulin
+    });
+  };
+
+  /**
+   * Handle what happens when the “Transfer to Logbook” button is pressed.
+   * Namely, the entered data should be saved in a logbook entry and the recommendation screen should be closed.
+   *
+   * Steps:
+   * 1. Unpack the enteredCarbs, enteredInsulin, insulinRecommendation, remeasureTime, and showExitModal state variables
+   * 2. Create an IResult object called carbs consisting of suggestedCarbs and enteredCarbs.
+   * 3. Create an IResult object called Insulin consisting of insulinRecommendation and enteredInsulin.
+   * 4. Call the transferToLogbook prop callback function with the following arguments:
+   * 	- Set the carbs argument to the carbs IResult object.
+   * 	- Set the insulin argument to the insulin IResult object.
+   * 	- Set the reminder argument to the remeasureTime state variable.
+   * 	- Set the recommendationDate argument to the recommendationDate member variable.
+   */
+  handleTransfer = () => {
+    const {
+      enteredCarbs,
+      enteredInsulin,
+      insulinRecommendation,
+      remeasureTime,
+      selectedMood
+    } = this.state;
+    const carbs = {
+      suggested: this.suggestedCarbs,
+      entered: enteredCarbs
+    };
+    const insulin = {
+      suggested: insulinRecommendation,
+      entered: enteredInsulin
+    };
+    this.props.transferToLogbook(carbs, insulin, remeasureTime, this.recommendationDate, selectedMood);
+  };
+
+  /**
+   * Get the attention message that should be displayed for the user to draw their attention to noteworthy circumstances regarding their current blood glucose level.
+   *
+   * Steps:
+   * 1. Unpack calculatorParams and latestLogbookFrom6Hours from the props.
+   * 2. Unpack currentBGL and activity from calculatorparams.
+   * 3. Get bgLevel, the categorisation of the blood glucose level, by calling the getBGLevel() function with the currentBGL and latestLogbookFrom6Hours as arguments.
+   * 4. Return the attention message that is returned when calling getAttentionMessage() using bgLevel and activity as arguments.
+   * @returns A string describing what the user needs to be aware of regarding their current blood glucose level.
+   * If there is nothing noteworthy, null will be returned instead.
+   */
+  getBGLevelAttentionMessage = () => {
+    const {
+      calculatorParams,
+      latestLogbookFrom6Hours
+    } = this.props;
+    const {
+      currentBGL,
+      activity
+    } = calculatorParams;
+    const bgLevel = (0, _RecommendationUtils.getBGLevel)(currentBGL, latestLogbookFrom6Hours);
+    return (0, _RecommendationUtils.getAttentionMessage)(bgLevel, activity);
+  };
+
+  /**
+   * Get the initial value for the remeasurement reminder time slider depending on the user’s entered information.
+   *
+   * Steps:
+   * 1. Unpack calculatorParams, userReminder, and latestLogbookFrom6Hours from the props.
+   * 2. Unpack currentBGL, activity,  and carbohydrates from calculatorParams.
+   * 3. Get bgLevel, the categorisation of the blood glucose level, by calling the getBGLevel() function with the currentBGL and latestLogbookFrom6Hours as arguments.
+   * 4. Return the attention message that is returned when calling getReminder() using bgLevel, carbohydrates, userReminder, and activity as arguments.
+   * @returns The time interval in hours that should be used as the initial value for the remeasurement reminder time slider.
+   */
+  getBGLevelRemeasurementReminder = () => {
+    const {
+      calculatorParams,
+      userReminder,
+      latestLogbookFrom6Hours
+    } = this.props;
+    const {
+      currentBGL,
+      activity,
+      carbohydrates
+    } = calculatorParams;
+    const bgLevel = (0, _RecommendationUtils.getBGLevel)(currentBGL, latestLogbookFrom6Hours);
+    return (0, _RecommendationUtils.getReminder)(bgLevel, carbohydrates, userReminder, activity);
+  };
+
+  /**
+   * Get the attention message that should be displayed to the user to let them know that the insulin recommendation that
+   * is being displayed to them was limited by the maximum insulin threshold.
+   *
+   * Steps:
+   * 1. Unpack the wasLimited and activityReduction state variables.
+   * 2. Return the result from calling getLimitationMessage() with wasLimited and activityReduction as arguments.
+   * @returns A message to inform the user how the insulin recommendation was limited. If there is no limitation attention message, null will be returned instead.
+   */
+  getLimitationAttentionMessage = () => {
+    const {
+      wasLimited,
+      activityReduction
+    } = this.state;
+    return (0, _RecommendationUtils.getLimitationMessage)(wasLimited, activityReduction);
+  };
+
+  /** Render a JSX element for displaying the insulin recommendation screen. */
+  render() {
+    if (this.hasError) {
+      return /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+        style: styles.container
+      });
+    }
+    const {
+      activeInsulin,
+      recommendationModal,
+      carbRecommendation: carbRecommendationProp,
+      enteredCarbs,
+      enteredInsulin,
+      insulinRecommendation,
+      activityReduction,
+      isRecommendationDisplayed
+    } = this.state;
+    const {
+      BloodGlucose: BGValueTestID,
+      BloodKetone: BKValueTestID,
+      ActiveInsulin: ActiveInsulinValueTestID
+    } = InfoBarTestIds.Value;
+    const {
+      ActiveInsulin: ActiveInsulinUnitTestID,
+      BloodGlucose: BGUnitTestID,
+      BloodKetone: BKUnitTestID
+    } = InfoBarTestIds.Unit;
+    const carbRecommendation = carbRecommendationProp !== null ? Math.round(carbRecommendationProp) : null;
+    const recommendedCarbs = enteredCarbs ?? carbRecommendation;
+    const foodBorderColor = recommendedCarbs !== null && recommendedCarbs > 0 ? _Constants.colors.teal : _Constants.colors.dustyDarkBlue;
+    const {
+      calculatorParams,
+      bloodGlucoseUnit,
+      currentBKL,
+      bloodKetoneUnit
+    } = this.props;
+    const {
+      currentBGL,
+      carbohydrates: providedCarbs
+    } = calculatorParams;
+    const displayedBGL = currentBGL ? _Utils.Utils.displayedBGLValue(currentBGL, bloodGlucoseUnit) : null;
+    const displayedBKL = currentBKL !== null && bloodKetoneUnit ? _Utils.Utils.displayedBKLValue(currentBKL, bloodKetoneUnit) : null;
+    return /*#__PURE__*/_react.default.createElement(_react.default.Fragment, null, /*#__PURE__*/_react.default.createElement(_reactNativeKeyboardAwareScrollView.KeyboardAwareScrollView, {
+      testID: RecommendationScreenTestIds.RecommendationScrollView,
+      enableResetScrollToCoords: false,
+      style: styles.container,
+      ref: view => {
+        if (view !== null) {
+          this.scrollView = view;
+        }
+      }
+    }, /*#__PURE__*/_react.default.createElement(_Text.default, {
+      style: styles.header
+    }, (0, _translate.t)(`Insulin recommendation`)), /*#__PURE__*/_react.default.createElement(_InfoBars.default, {
+      label: (0, _translate.t)(`Active Insulin`),
+      value: activeInsulin ? `${activeInsulin.toFixed(1)}` : null,
+      unit: (0, _translate.t)(`units`),
+      showNullAsDash: false,
+      testID: {
+        unitID: ActiveInsulinUnitTestID,
+        valueID: ActiveInsulinValueTestID
+      }
+    }), /*#__PURE__*/_react.default.createElement(_InfoBars.default, {
+      label: (0, _translate.t)(`Blood Glucose Level`),
+      value: displayedBGL,
+      unit: this.props.bloodGlucoseUnit,
+      showNullAsDash: true,
+      testID: {
+        unitID: BGUnitTestID,
+        valueID: BGValueTestID
+      }
+    }), /*#__PURE__*/_react.default.createElement(_InfoBars.default, {
+      label: (0, _translate.t)(`Blood Ketone Level`),
+      value: displayedBKL,
+      unit: this.props.bloodKetoneUnit,
+      showNullAsDash: true,
+      testID: {
+        unitID: BKUnitTestID,
+        valueID: BKValueTestID
+      }
+    }), /*#__PURE__*/_react.default.createElement(_reactNative.View, {
+      style: [styles.carbsBorder, {
+        borderColor: foodBorderColor
+      }]
+    }, /*#__PURE__*/_react.default.createElement(_RecommendedCarbs.default, {
+      enteredCarbs: `${providedCarbs}`,
+      changedRecommendedCarbs: this.updateCarbRecommendation,
+      recommendedCarbs: `${recommendedCarbs}`,
+      removeRecommendedCarbs: this.removeCarbRecommendation
+    })), this.props.calculatorParams.activity && this.props.activityDisplayProps && /*#__PURE__*/_react.default.createElement(_Activity.default, {
+      activity: this.props.calculatorParams.activity,
+      activityType: this.props.activityDisplayProps.activityType,
+      activityTitle: this.props.activityDisplayProps.activityTitle,
+      activityReduction: activityReduction
+    }), /*#__PURE__*/_react.default.createElement(_Remeasure.default, {
+      onSliderChange: this.updateRemeasureTime,
+      remeasureTime: this.state.remeasureTime
+    }), !isRecommendationDisplayed ? /*#__PURE__*/_react.default.createElement(_RecentInsulin.default, {
+      onRecentInsulinYes: this.props.onRecentInsulinYes,
+      onRecentInsulinNo: this.handleNoRecentInsulin
+    }) : /*#__PURE__*/_react.default.createElement(_RecommendedInsulin.default, {
+      injectionMethod: this.props.injectionMethod,
+      insulinRecommendation: insulinRecommendation,
+      enteredInsulin: enteredInsulin,
+      activityReduction: activityReduction,
+      updateRecommendedInsulin: this.updateInsulinRecommendation
+    }), /*#__PURE__*/_react.default.createElement(_TransferToLogbook.default, {
+      visible: isRecommendationDisplayed,
+      transfer: this.handleTransfer
+    }), /*#__PURE__*/_react.default.createElement(_Emotion.default, {
+      moodSelected: this.handleMoodSelected,
+      currentMood: this.state.selectedMood
+    }), /*#__PURE__*/_react.default.createElement(_RecommendationModal.default, {
+      isVisible: recommendationModal || this.state.onlyShowLimitationMessage,
+      onlyShowLimitationMessage: this.state.onlyShowLimitationMessage,
+      suggestedCarbohydrates: carbRecommendationProp,
+      attentionMessage: this.getBGLevelAttentionMessage(),
+      limitationMessage: this.getLimitationAttentionMessage(),
+      onClickOkButton: this.hideAttentionModal,
+      onAcceptCarbohydrates: this.acceptCarbRecommendation,
+      onDeclineCarbohydrates: this.declineCarbRecommendation
+    })), /*#__PURE__*/_react.default.createElement(_ExitModal.default, {
+      isVisible: this.state.showExitModal,
+      title: (0, _translate.t)(`Save data before closing?`),
+      message: (0, _translate.t)(`Your saved data will be used for future calculations.`),
+      textFirstOption: (0, _translate.t)(`Save to logbook`),
+      textSecondOption: (0, _translate.t)(`Close calculation`),
+      firstOption: this.onPressTransferExitModal,
+      secondOption: this.onPressCloseExitModal,
+      onClose: this.onPressHideExitModal,
+      onModalHide: this.onExitModalDidHide
+    }), isRecommendationDisplayed ? /*#__PURE__*/_react.default.createElement(_TimeoutModal.default, {
+      isVisible: this.state.showTimeoutModal,
+      title: _AttentionMessages.Messages.TimeoutPrompTitle(),
+      message: _AttentionMessages.Messages.TimeoutRecommendationVisible(this.recommendationDate),
+      textFirstOption: (0, _translate.t)(`Yes, save to logbook`),
+      textSecondOption: (0, _translate.t)(`No, return to dashboard`),
+      firstOption: this.onPressTransferTimeoutModal,
+      secondOption: this.onPressCloseCalculationTimeoutModal,
+      onModalHide: this.onTimeoutModalDidHide
+    }) : /*#__PURE__*/_react.default.createElement(_TimeoutModal.default, {
+      isVisible: this.state.showTimeoutModal,
+      title: _AttentionMessages.Messages.TimeoutPrompTitle(),
+      message: _AttentionMessages.Messages.TimeoutRecommendationNotVisible(),
+      textFirstOption: (0, _translate.t)(`Start new calculation`),
+      textSecondOption: (0, _translate.t)(`Return to dashboard`),
+      firstOption: this.onPressRestartCalculationTimeoutModal,
+      secondOption: this.onPressCloseCalculationTimeoutModal,
+      onModalHide: this.onTimeoutModalDidHide
+    }));
+  }
+}
+exports.RecommendationScreen = RecommendationScreen;
+const styles = _reactNative.StyleSheet.create({
+  container: {
+    flex: 1,
+    paddingHorizontal: 18,
+    backgroundColor: _Constants.colors.darkBlue
+  },
+  limitationModalContainer: {
+    ..._reactNative.StyleSheet.absoluteFillObject,
+    justifyContent: `center`,
+    backgroundColor: _Constants.colors.transparentBlack
+  },
+  carbsBorder: {
+    borderWidth: 1,
+    borderRadius: 5,
+    padding: 16
+  },
+  header: {
+    ..._fonts.FONTS.Poppins.medium_Base,
+    color: _Constants.colors.dustyBlue,
+    marginBottom: 22,
+    textAlign: `center`
+  }
+});
+//# sourceMappingURL=RecommendationScreen.js.map