@aehrc/smart-forms-renderer 0.3.0 → 0.5.0

package/src/utils/enableWhen.ts

@@ -0,0 +1,303 @@
+/*
+ * Copyright 2023 Commonwealth Scientific and Industrial Research
+ * Organisation (CSIRO) ABN 41 687 119 230.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type {
+  Quantity,
+  QuestionnaireItemEnableWhen,
+  QuestionnaireResponse,
+  QuestionnaireResponseItem,
+  QuestionnaireResponseItemAnswer
+} from 'fhir/r4';
+import cloneDeep from 'lodash.clonedeep';
+import type { EnableWhenItemProperties, EnableWhenItems } from '../interfaces/enableWhen.interface';
+
+/**
+ * Create a linkedQuestionsMap that contains linked items of enableWhen items
+ * mapped to an array containing all its respective enableWhen items' linkIds
+ * returns a key-value pair of <linkedItemId, [enableWhenItem1LinkId, enableWhenItem2LinkId, enableWhenItem3LinkId]>
+ *
+ * @author Sean Fong
+ */
+export function createEnableWhenLinkedQuestions(enableWhenItems: EnableWhenItems) {
+  const linkedQuestionsMap: Record<string, string[]> = {};
+
+  for (const linkId in enableWhenItems) {
+    enableWhenItems[linkId].linked.forEach((linkedItem) => {
+      const linkQId = linkedItem.enableWhen.question;
+      if (!linkedQuestionsMap[linkQId]) {
+        linkedQuestionsMap[linkQId] = [];
+      }
+
+      if (!linkedQuestionsMap[linkQId].includes(linkId)) {
+        linkedQuestionsMap[linkQId].push(linkId);
+      }
+    });
+  }
+  return linkedQuestionsMap;
+}
+
+/**
+ * Performs switching for non-group enableWhenItems based on their item types.
+ *
+ * @author Sean Fong
+ */
+export function isEnabledAnswerTypeSwitcher(
+  enableWhen: QuestionnaireItemEnableWhen,
+  answer: QuestionnaireResponseItemAnswer
+): boolean {
+  if (enableWhen['answerBoolean'] !== undefined && enableWhen.operator === 'exists') {
+    return answerOperatorSwitcher(enableWhen.answerBoolean, answer, enableWhen.operator);
+  } else if (enableWhen['answerBoolean'] !== undefined && answer.valueBoolean !== undefined) {
+    return answerOperatorSwitcher(
+      enableWhen.answerBoolean,
+      answer.valueBoolean,
+      enableWhen.operator
+    );
+  } else if (enableWhen['answerDecimal'] && answer.valueDecimal) {
+    return answerOperatorSwitcher(
+      enableWhen.answerDecimal,
+      answer.valueDecimal,
+      enableWhen.operator
+    );
+  } else if (enableWhen['answerInteger'] !== undefined && answer.valueInteger !== undefined) {
+    return answerOperatorSwitcher(
+      enableWhen.answerInteger,
+      answer.valueInteger,
+      enableWhen.operator
+    );
+  } else if (enableWhen['answerDate'] && answer.valueDate) {
+    return answerOperatorSwitcher(enableWhen.answerDate, answer.valueDate, enableWhen.operator);
+  } else if (enableWhen['answerDateTime'] && answer.valueDateTime) {
+    return answerOperatorSwitcher(
+      enableWhen.answerDateTime,
+      answer.valueDateTime,
+      enableWhen.operator
+    );
+  } else if (enableWhen['answerTime'] && answer.valueTime) {
+    return answerOperatorSwitcher(enableWhen.answerTime, answer.valueTime, enableWhen.operator);
+  } else if (enableWhen['answerString'] && answer.valueString) {
+    return answerOperatorSwitcher(enableWhen.answerString, answer.valueString, enableWhen.operator);
+  } else if (enableWhen['answerCoding']?.code && answer.valueCoding?.code) {
+    return answerOperatorSwitcher(
+      enableWhen.answerCoding.code,
+      answer.valueCoding.code,
+      enableWhen.operator
+    );
+  } else if (enableWhen['answerQuantity'] && answer.valueQuantity) {
+    return answerOperatorSwitcher(
+      enableWhen.answerQuantity,
+      answer.valueQuantity,
+      enableWhen.operator
+    );
+  }
+  return false;
+}
+
+/**
+ * Performs switching for value and expected comparisons based on given operator
+ *
+ * @author Sean Fong
+ */
+function answerOperatorSwitcher(
+  expected: boolean | string | number | Quantity,
+  value: boolean | string | number | Quantity | QuestionnaireResponseItemAnswer,
+  operator: QuestionnaireItemEnableWhen['operator']
+): boolean {
+  // FIXME runs even when the linked textbox is not changed
+  switch (operator) {
+    case 'exists':
+      // check if value is an object and contains any answerValues
+      return typeof value === 'object' && Object.keys(value).length !== 0;
+    case '=':
+      return value === expected;
+    case '!=':
+      return value !== expected;
+    case '<':
+      return value < expected;
+    case '<=':
+      return value <= expected;
+    case '>':
+      return value > expected;
+    case '>=':
+      return value >= expected;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Read initial answer values in questionnaireResponse
+ * return a map of initial values with key-value pair <linkedItemId, initial value>
+ *
+ * @author Sean Fong
+ */
+export function readInitialAnswers(
+  questionnaireResponse: QuestionnaireResponse,
+  linkedQuestionsMap: Record<string, string[]>
+): Record<string, QuestionnaireResponseItemAnswer[]> {
+  if (!questionnaireResponse.item) return {};
+
+  const initialValuesMap: Record<string, QuestionnaireResponseItemAnswer[]> = {};
+  questionnaireResponse.item.forEach((item) => {
+    readQuestionnaireResponseItemRecursive(item, initialValuesMap, linkedQuestionsMap);
+  });
+  return initialValuesMap;
+}
+
+/**
+ * Read initial answer values of each qrItem recursively
+ *
+ * @author Sean Fong
+ */
+function readQuestionnaireResponseItemRecursive(
+  item: QuestionnaireResponseItem,
+  initialValues: Record<string, QuestionnaireResponseItemAnswer[]>,
+  linkedQuestionsMap: Record<string, string[]>
+) {
+  const items = item.item;
+  if (items && items.length > 0) {
+    // iterate through items of item recursively
+    items.forEach((item) => {
+      readQuestionnaireResponseItemRecursive(item, initialValues, linkedQuestionsMap);
+    });
+    return;
+  }
+
+  // Read initial answer value of single qrItem
+  if (linkedQuestionsMap[item.linkId] && item.answer) {
+    initialValues[item.linkId] = item.answer;
+  }
+
+  return;
+}
+
+/**
+ * Set initial answer values into enableWhenItems' answer attributes
+ * Update enabled status of each enableWhenItem simultaneously
+ *
+ * @author Sean Fong
+ */
+export function setInitialAnswers(
+  initialAnswers: Record<string, QuestionnaireResponseItemAnswer[]>,
+  items: EnableWhenItems,
+  linkedQuestionsMap: Record<string, string[]>
+): EnableWhenItems {
+  let updatedItems = cloneDeep(items);
+
+  if (initialAnswers) {
+    for (const linkId in initialAnswers) {
+      const linkedQuestions = linkedQuestionsMap[linkId];
+      const newAnswer = initialAnswers[linkId];
+
+      updatedItems = updateItemAnswer(updatedItems, linkedQuestions, linkId, newAnswer);
+    }
+  }
+  return updatedItems;
+}
+
+/**
+ * Update answer of the target linkId in every related enableWhenItem's linked items
+ * Then update the enabled status of every related enableWhenItem
+ *
+ * @author Sean Fong
+ */
+export function updateItemAnswer(
+  items: EnableWhenItems,
+  linkedQuestions: string[],
+  linkId: string,
+  newAnswer: QuestionnaireResponseItemAnswer[]
+): EnableWhenItems {
+  linkedQuestions.forEach((question) => {
+    // Update modified linked answer
+    items[question].linked.forEach((linkedItem) => {
+      if (linkedItem.enableWhen.question === linkId) {
+        linkedItem.answer = newAnswer ?? undefined;
+      }
+    });
+
+    // Update enabled status of modified enableWhenItem
+    items[question].isEnabled = checkItemIsEnabled(items[question]);
+  });
+  return items;
+}
+
+/**
+ * Check if an enableWhenItem is enabled based on the answer of its linked items
+ *
+ * @author Sean Fong
+ */
+export function checkItemIsEnabled(enableWhenItemProperties: EnableWhenItemProperties): boolean {
+  const checkedIsEnabledItems: boolean[] = [];
+
+  enableWhenItemProperties.linked.forEach((linkedItem) => {
+    if (linkedItem.answer && linkedItem.answer.length > 0) {
+      linkedItem.answer.forEach((answer) => {
+        checkedIsEnabledItems.push(isEnabledAnswerTypeSwitcher(linkedItem.enableWhen, answer));
+      });
+    }
+  });
+
+  if (checkedIsEnabledItems.length === 0) return false;
+
+  return enableWhenItemProperties.enableBehavior === 'any'
+    ? checkedIsEnabledItems.some((isEnabled) => isEnabled)
+    : checkedIsEnabledItems.every((isEnabled) => isEnabled);
+}
+
+export function assignPopulatedAnswersToEnableWhen(
+  items: EnableWhenItems,
+  questionnaireResponse: QuestionnaireResponse
+): { initialisedItems: EnableWhenItems; linkedQuestions: Record<string, string[]> } {
+  const linkedQuestions = createEnableWhenLinkedQuestions(items);
+  const initialAnswers = readInitialAnswers(questionnaireResponse, linkedQuestions);
+  items = initialiseBooleanFalses(items);
+
+  const initialisedItems =
+    Object.keys(initialAnswers).length > 0
+      ? setInitialAnswers(initialAnswers, items, linkedQuestions)
+      : items;
+
+  return { initialisedItems, linkedQuestions };
+}
+
+function initialiseBooleanFalses(items: EnableWhenItems): EnableWhenItems {
+  for (const linkId in items) {
+    const checkedIsEnabledItems: boolean[] = [];
+    const enableWhenItemProperties = items[linkId];
+
+    for (const linkedItem of enableWhenItemProperties.linked) {
+      if (linkedItem.enableWhen.answerBoolean === true && linkedItem.enableWhen.operator === '!=') {
+        checkedIsEnabledItems.push(true);
+        continue;
+      }
+
+      if (linkedItem.enableWhen.answerBoolean === false && linkedItem.enableWhen.operator === '=') {
+        checkedIsEnabledItems.push(true);
+        continue;
+      }
+
+      checkedIsEnabledItems.push(false);
+    }
+
+    enableWhenItemProperties.isEnabled =
+      enableWhenItemProperties.enableBehavior === 'any'
+        ? checkedIsEnabledItems.some((isEnabled) => isEnabled)
+        : checkedIsEnabledItems.every((isEnabled) => isEnabled);
+  }
+
+  return items;
+}

package/src/utils/enableWhenExpression.ts

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2023 Commonwealth Scientific and Industrial Research
+ * Organisation (CSIRO) ABN 41 687 119 230.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { EnableWhenExpression } from '../interfaces/enableWhen.interface';
+import type { Expression, QuestionnaireResponse } from 'fhir/r4';
+import { createFhirPathContext } from './fhirpath';
+import fhirpath from 'fhirpath';
+import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
+import _isEqual from 'lodash/isEqual';
+import { emptyResponse } from './emptyResource';
+import cloneDeep from 'lodash.clonedeep';
+
+interface EvaluateInitialEnableWhenExpressionsParams {
+  initialResponse: QuestionnaireResponse;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+  variablesFhirPath: Record<string, Expression[]>;
+}
+
+export function evaluateInitialEnableWhenExpressions(
+  params: EvaluateInitialEnableWhenExpressionsParams
+): Record<string, EnableWhenExpression> {
+  const { initialResponse, enableWhenExpressions, variablesFhirPath } = params;
+
+  // Return early if initialResponse is empty
+  if (_isEqual(initialResponse, cloneDeep(emptyResponse))) {
+    return enableWhenExpressions;
+  }
+
+  const initialExpressions: Record<string, EnableWhenExpression> = { ...enableWhenExpressions };
+
+  if (Object.keys(initialExpressions).length > 0) {
+    const fhirPathContext: Record<string, any> = createFhirPathContext(
+      initialResponse,
+      variablesFhirPath
+    );
+
+    for (const linkId in initialExpressions) {
+      try {
+        const result = fhirpath.evaluate(
+          initialResponse,
+          enableWhenExpressions[linkId].expression,
+          fhirPathContext,
+          fhirpath_r4_model
+        );
+
+        if (result.length > 0) {
+          initialExpressions[linkId].isEnabled = result[0];
+        }
+
+        // handle intersect edge case - evualate() returns empty array if result is false
+        if (enableWhenExpressions[linkId].expression.includes('intersect') && result.length === 0) {
+          initialExpressions[linkId].isEnabled = false;
+        }
+      } catch (e) {
+        console.warn(
+          e.message,
+          `LinkId: ${linkId}\nExpression: ${enableWhenExpressions[linkId].expression}`
+        );
+      }
+    }
+  }
+  return initialExpressions;
+}
+
+export function evaluateEnableWhenExpressions(
+  fhirPathContext: Record<string, any>,
+  enableWhenExpressions: Record<string, EnableWhenExpression>
+): {
+  enableWhenExpsIsUpdated: boolean;
+  updatedEnableWhenExpressions: Record<string, EnableWhenExpression>;
+} {
+  const updatedEnableWhenExpressions: Record<string, EnableWhenExpression> = {
+    ...enableWhenExpressions
+  };
+
+  let isUpdated = false;
+  for (const linkId in updatedEnableWhenExpressions) {
+    try {
+      const result = fhirpath.evaluate(
+        '',
+        enableWhenExpressions[linkId].expression,
+        fhirPathContext,
+        fhirpath_r4_model
+      );
+
+      if (result.length > 0) {
+        if (enableWhenExpressions[linkId].isEnabled !== result[0]) {
+          isUpdated = true;
+          updatedEnableWhenExpressions[linkId].isEnabled = result[0];
+        }
+      }
+
+      // handle intersect edge case - evualate() returns empty array if result is false
+      if (enableWhenExpressions[linkId].expression.includes('intersect') && result.length === 0) {
+        updatedEnableWhenExpressions[linkId].isEnabled = false;
+      }
+    } catch (e) {
+      console.warn(
+        e.message,
+        `LinkId: ${linkId}\nExpression: ${enableWhenExpressions[linkId].expression}`
+      );
+    }
+  }
+
+  return {
+    enableWhenExpsIsUpdated: isUpdated,
+    updatedEnableWhenExpressions: updatedEnableWhenExpressions
+  };
+}

package/src/utils/fhirpath.ts

@@ -0,0 +1,164 @@
+/*
+ * Copyright 2023 Commonwealth Scientific and Industrial Research
+ * Organisation (CSIRO) ABN 41 687 119 230.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import fhirpath from 'fhirpath';
+import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
+import type { Expression, QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
+import type { CalculatedExpression } from '../interfaces/calculatedExpression.interface';
+import type { EnableWhenExpression } from '../interfaces/enableWhen.interface';
+import { evaluateEnableWhenExpressions } from './enableWhenExpression';
+import { evaluateCalculatedExpressions } from './calculatedExpression';
+
+interface EvaluateUpdatedExpressionsParams {
+  updatedResponse: QuestionnaireResponse;
+  calculatedExpressions: Record<string, CalculatedExpression>;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+  variablesFhirPath: Record<string, Expression[]>;
+}
+
+export function evaluateUpdatedExpressions(params: EvaluateUpdatedExpressionsParams): {
+  isUpdated: boolean;
+  updatedEnableWhenExpressions: Record<string, EnableWhenExpression>;
+  updatedCalculatedExpressions: Record<string, CalculatedExpression>;
+} {
+  const { updatedResponse, enableWhenExpressions, calculatedExpressions, variablesFhirPath } =
+    params;
+
+  const hasExpressionToBeUpdated =
+    Object.keys(enableWhenExpressions).length > 0 || Object.keys(calculatedExpressions).length > 0;
+  if (hasExpressionToBeUpdated && updatedResponse.item) {
+    const fhirPathContext: Record<string, any> = createFhirPathContext(
+      updatedResponse,
+      variablesFhirPath
+    );
+
+    // Update enableWhenExpressions
+    const { enableWhenExpsIsUpdated, updatedEnableWhenExpressions } = evaluateEnableWhenExpressions(
+      fhirPathContext,
+      enableWhenExpressions
+    );
+
+    // Update calculatedExpressions
+    const { calculatedExpsIsUpdated, updatedCalculatedExpressions } = evaluateCalculatedExpressions(
+      fhirPathContext,
+      calculatedExpressions
+    );
+
+    const isUpdated = enableWhenExpsIsUpdated || calculatedExpsIsUpdated;
+
+    return { isUpdated, updatedEnableWhenExpressions, updatedCalculatedExpressions };
+  }
+
+  return {
+    isUpdated: false,
+    updatedEnableWhenExpressions: enableWhenExpressions,
+    updatedCalculatedExpressions: calculatedExpressions
+  };
+}
+
+export function createFhirPathContext(
+  questionnaireResponse: QuestionnaireResponse,
+  variablesFhirPath: Record<string, Expression[]>
+): Record<string, any> {
+  const fhirPathContext: Record<string, any> = { resource: questionnaireResponse };
+
+  if (!questionnaireResponse.item || questionnaireResponse.item.length === 0) {
+    return fhirPathContext;
+  }
+
+  evaluateResourceLevelFhirPath(questionnaireResponse, variablesFhirPath, fhirPathContext);
+
+  for (const topLevelItem of questionnaireResponse.item) {
+    evaluateFhirPathRecursive(topLevelItem, variablesFhirPath, fhirPathContext);
+  }
+
+  return fhirPathContext;
+}
+
+export function evaluateFhirPathRecursive(
+  item: QuestionnaireResponseItem,
+  variablesFhirPath: Record<string, Expression[]>,
+  fhirPathContext: Record<string, any>
+) {
+  const items = item.item;
+  if (items && items.length > 0) {
+    // iterate through items of item recursively
+    for (const childItem of items) {
+      evaluateFhirPathRecursive(childItem, variablesFhirPath, fhirPathContext);
+    }
+  }
+
+  evaluateItemFhirPath(item, variablesFhirPath, fhirPathContext);
+}
+
+export function evaluateItemFhirPath(
+  item: QuestionnaireResponseItem,
+  variablesFhirPath: Record<string, Expression[]>,
+  fhirPathContext: Record<string, any>
+) {
+  const variablesOfItem = variablesFhirPath[item.linkId];
+  if (!variablesOfItem || variablesOfItem.length === 0) {
+    return;
+  }
+
+  variablesOfItem.forEach((variable) => {
+    if (variable.expression) {
+      try {
+        fhirPathContext[`${variable.name}`] = fhirpath.evaluate(
+          item,
+          {
+            base: 'QuestionnaireResponse.item',
+            expression: variable.expression
+          },
+          fhirPathContext,
+          fhirpath_r4_model
+        );
+      } catch (e) {
+        console.warn(e.message, `LinkId: ${item.linkId}\nExpression: ${variable.expression}`);
+      }
+    }
+  });
+}
+
+export function evaluateResourceLevelFhirPath(
+  resource: QuestionnaireResponse,
+  variablesFhirPath: Record<string, Expression[]>,
+  fhirPathContext: Record<string, any>
+) {
+  const questionnaireLevelVariables = variablesFhirPath['QuestionnaireLevel'];
+  if (!questionnaireLevelVariables || questionnaireLevelVariables.length === 0) {
+    return;
+  }
+
+  questionnaireLevelVariables.forEach((variable) => {
+    if (variable.expression) {
+      try {
+        fhirPathContext[`${variable.name}`] = fhirpath.evaluate(
+          resource,
+          {
+            base: 'QuestionnaireResponse',
+            expression: variable.expression
+          },
+          fhirPathContext,
+          fhirpath_r4_model
+        );
+      } catch (e) {
+        console.warn(e.message, `Questionnaire-level\nExpression: ${variable.expression}`);
+      }
+    }
+  });
+}

package/src/utils/initialiseForm.ts

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2023 Commonwealth Scientific and Industrial Research
+ * Organisation (CSIRO) ABN 41 687 119 230.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { evaluateInitialEnableWhenExpressions } from './enableWhenExpression';
+import { getFirstVisibleTab } from './tabs';
+import type { Expression, QuestionnaireResponse } from 'fhir/r4';
+import type { EnableWhenExpression, EnableWhenItems } from '../interfaces/enableWhen.interface';
+import type { Tabs } from '../interfaces/tab.interface';
+import { assignPopulatedAnswersToEnableWhen } from './enableWhen';
+import type { CalculatedExpression } from '../interfaces/calculatedExpression.interface';
+import { evaluateInitialCalculatedExpressions } from './calculatedExpression';
+
+interface initialFormFromResponseParams {
+  questionnaireResponse: QuestionnaireResponse;
+  enableWhenItems: EnableWhenItems;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+  calculatedExpressions: Record<string, CalculatedExpression>;
+  variablesFhirPath: Record<string, Expression[]>;
+  tabs: Tabs;
+}
+
+export function initialiseFormFromResponse(params: initialFormFromResponseParams): {
+  initialEnableWhenItems: EnableWhenItems;
+  initialEnableWhenLinkedQuestions: Record<string, string[]>;
+  initialEnableWhenExpressions: Record<string, EnableWhenExpression>;
+  initialCalculatedExpressions: Record<string, CalculatedExpression>;
+  firstVisibleTab: number;
+} {
+  const {
+    questionnaireResponse,
+    enableWhenItems,
+    enableWhenExpressions,
+    calculatedExpressions,
+    variablesFhirPath,
+    tabs
+  } = params;
+
+  const { initialisedItems, linkedQuestions } = assignPopulatedAnswersToEnableWhen(
+    enableWhenItems,
+    questionnaireResponse
+  );
+
+  const initialEnableWhenExpressions = evaluateInitialEnableWhenExpressions({
+    initialResponse: questionnaireResponse,
+    enableWhenExpressions: enableWhenExpressions,
+    variablesFhirPath: variablesFhirPath
+  });
+
+  const initialCalculatedExpressions = evaluateInitialCalculatedExpressions({
+    initialResponse: questionnaireResponse,
+    calculatedExpressions: calculatedExpressions,
+    variablesFhirPath: variablesFhirPath
+  });
+
+  const firstVisibleTab =
+    Object.keys(tabs).length > 0
+      ? getFirstVisibleTab(tabs, initialisedItems, initialEnableWhenExpressions)
+      : 0;
+
+  return {
+    initialEnableWhenItems: initialisedItems,
+    initialEnableWhenLinkedQuestions: linkedQuestions,
+    initialEnableWhenExpressions,
+    initialCalculatedExpressions,
+    firstVisibleTab
+  };
+}