@aehrc/smart-forms-renderer 1.0.0-alpha.21 → 1.0.0-alpha.23

package/src/stores/questionnaireStore.ts

@@ -50,6 +50,8 @@ import { insertCompleteAnswerOptionsIntoQuestionnaire } from '../utils/questionn
 import type { InitialExpression } from '../interfaces/initialExpression.interface';
 import type { QItemOverrideComponentProps, SdcUiOverrideComponentProps } from '../interfaces';
 import type { ComponentType } from 'react';
+import type { TargetConstraint } from '../interfaces/targetConstraint.interface';
+import { readTargetConstraintLocationLinkIds } from '../utils/targetConstraint';
 
 /**
  * QuestionnaireStore properties and methods
@@ -65,6 +67,8 @@ import type { ComponentType } from 'react';
  * @property currentPageIndex - Index of the current page
  * @property variables - Questionnaire variables object containing FHIRPath and x-fhir-query variables
  * @property launchContexts - Key-value pair of launch contexts `Record<launch context name, launch context properties>`
+ * @property targetConstraints - Key-value pair of target constraints `Record<target constraint key, target constraint properties>`
+ * @property targetConstraintLinkIds - Key-value pair of linkIds against target constraint key(s) `Record<linkId, target constraint keys>`
  * @property enableWhenItems - EnableWhenItems object containing enableWhen items and their linked questions
  * @property enableWhenLinkedQuestions - Key-value pair of linked questions to enableWhen items `Record<linkId, linkIds of linked questions>`
  * @property enableWhenIsActivated - Flag to turn enableWhen checks on/off
@@ -109,6 +113,8 @@ export interface QuestionnaireStoreType {
   currentPageIndex: number;
   variables: Variables;
   launchContexts: Record<string, LaunchContext>;
+  targetConstraints: Record<string, TargetConstraint>;
+  targetConstraintLinkIds: Record<string, string[]>;
   enableWhenItems: EnableWhenItems;
   enableWhenLinkedQuestions: Record<string, string[]>;
   enableWhenIsActivated: boolean;
@@ -183,6 +189,8 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
   currentPageIndex: 0,
   variables: { fhirPathVariables: {}, xFhirQueryVariables: {} },
   launchContexts: {},
+  targetConstraints: {},
+  targetConstraintLinkIds: {},
   calculatedExpressions: {},
   initialExpressions: {},
   enableWhenExpressions: { singleExpressions: {}, repeatExpressions: {} },
@@ -229,6 +237,7 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
 
     // Initialise form with questionnaire response and properties in questionnaire model
     const {
+      initialTargetConstraints,
       initialEnableWhenItems,
       initialEnableWhenLinkedQuestions,
       initialEnableWhenExpressions,
@@ -239,10 +248,11 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
       fhirPathTerminologyCache: updatedFhirPathTerminologyCache
     } = await initialiseFormFromResponse({
       questionnaireResponse,
+      targetConstraints: questionnaireModel.targetConstraints,
       enableWhenItems: questionnaireModel.enableWhenItems,
       enableWhenExpressions: questionnaireModel.enableWhenExpressions,
       calculatedExpressions: questionnaireModel.calculatedExpressions,
-      variablesFhirPath: questionnaireModel.variables.fhirPathVariables,
+      variables: questionnaireModel.variables,
       tabs: questionnaireModel.tabs,
       pages: questionnaireModel.pages,
       fhirPathContext: fhirPathContext,
@@ -250,6 +260,12 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
       terminologyServerUrl: terminologyServerUrl
     });
 
+    // Read target constraint locations
+    const targetConstraintLinkIds = readTargetConstraintLocationLinkIds(
+      questionnaire,
+      initialTargetConstraints
+    );
+
     set({
       sourceQuestionnaire: questionnaire,
       itemTypes: questionnaireModel.itemTypes,
@@ -260,6 +276,8 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
       currentPageIndex: firstVisiblePage,
       variables: questionnaireModel.variables,
       launchContexts: questionnaireModel.launchContexts,
+      targetConstraints: initialTargetConstraints,
+      targetConstraintLinkIds: targetConstraintLinkIds,
       enableWhenItems: initialEnableWhenItems,
       enableWhenLinkedQuestions: initialEnableWhenLinkedQuestions,
       enableWhenExpressions: initialEnableWhenExpressions,
@@ -286,6 +304,8 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
       currentPageIndex: 0,
       variables: { fhirPathVariables: {}, xFhirQueryVariables: {} },
       launchContexts: {},
+      targetConstraints: {},
+      targetConstraintLinkIds: {},
       enableWhenItems: { singleItems: {}, repeatItems: {} },
       enableWhenLinkedQuestions: {},
       enableWhenExpressions: { singleExpressions: {}, repeatExpressions: {} },
@@ -364,7 +384,7 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
       await mutateRepeatEnableWhenExpressionInstances({
         questionnaireResponse: questionnaireResponseStore.getState().updatableResponse,
         questionnaireResponseItemMap: questionnaireResponseStore.getState().updatableResponseItems,
-        variablesFhirPath: get().variables.fhirPathVariables,
+        variables: get().variables,
         existingFhirPathContext: get().fhirPathContext,
         fhirPathTerminologyCache: get().fhirPathTerminologyCache,
         enableWhenExpressions: enableWhenExpressions,
@@ -387,6 +407,7 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
     const updatedResponseItemMap = createQuestionnaireResponseItemMap(updatedResponse);
     const {
       isUpdated,
+      updatedTargetConstraints,
       updatedEnableWhenExpressions,
       updatedCalculatedExpressions,
       updatedFhirPathContext,
@@ -394,9 +415,10 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
     } = await evaluateUpdatedExpressions({
       updatedResponse,
       updatedResponseItemMap,
+      targetConstraints: get().targetConstraints,
       enableWhenExpressions: get().enableWhenExpressions,
       calculatedExpressions: get().calculatedExpressions,
-      variablesFhirPath: get().variables.fhirPathVariables,
+      variables: get().variables,
       existingFhirPathContext: get().fhirPathContext,
       fhirPathTerminologyCache: get().fhirPathTerminologyCache,
       terminologyServerUrl: terminologyServerStore.getState().url
@@ -404,6 +426,7 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
 
     if (isUpdated) {
       set(() => ({
+        targetConstraints: updatedTargetConstraints,
         enableWhenExpressions: updatedEnableWhenExpressions,
         calculatedExpressions: updatedCalculatedExpressions,
         fhirPathContext: updatedFhirPathContext,
@@ -436,7 +459,7 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
       initialResponse: populatedResponse,
       initialResponseItemMap: initialResponseItemMap,
       calculatedExpressions: get().calculatedExpressions,
-      variablesFhirPath: get().variables.fhirPathVariables,
+      variables: get().variables,
       existingFhirPathContext: get().fhirPathContext,
       fhirPathTerminologyCache: get().fhirPathTerminologyCache,
       terminologyServerUrl: terminologyServerStore.getState().url
@@ -453,6 +476,7 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
     );
 
     const {
+      initialTargetConstraints,
       initialEnableWhenItems,
       initialEnableWhenLinkedQuestions,
       initialEnableWhenExpressions,
@@ -460,10 +484,11 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
       firstVisiblePage
     } = await initialiseFormFromResponse({
       questionnaireResponse: updatedResponse,
+      targetConstraints: get().targetConstraints,
       enableWhenItems: get().enableWhenItems,
       enableWhenExpressions: get().enableWhenExpressions,
       calculatedExpressions: initialCalculatedExpressions,
-      variablesFhirPath: get().variables.fhirPathVariables,
+      variables: get().variables,
       tabs: get().tabs,
       pages: get().pages,
       fhirPathContext: updatedFhirPathContext,
@@ -474,6 +499,7 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
     fhirPathTerminologyCache = evaluateInitialCalculatedExpressionsResult.fhirPathTerminologyCache;
 
     set(() => ({
+      targetConstraints: initialTargetConstraints,
       enableWhenItems: initialEnableWhenItems,
       enableWhenLinkedQuestions: initialEnableWhenLinkedQuestions,
       enableWhenExpressions: initialEnableWhenExpressions,

package/src/utils/calculatedExpression.ts

@@ -19,7 +19,6 @@ import type { CalculatedExpression } from '../interfaces/calculatedExpression.in
 import fhirpath from 'fhirpath';
 import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
 import type {
-  Expression,
   Questionnaire,
   QuestionnaireItem,
   QuestionnaireItemAnswerOption,
@@ -34,12 +33,13 @@ import { updateQrItemsInGroup } from './qrItem';
 import dayjs from 'dayjs';
 import { updateQuestionnaireResponse } from './genericRecursive';
 import isEqual from 'lodash.isequal';
+import type { Variables } from '../interfaces';
 
 interface EvaluateInitialCalculatedExpressionsParams {
   initialResponse: QuestionnaireResponse;
   initialResponseItemMap: Record<string, QuestionnaireResponseItem[]>;
   calculatedExpressions: Record<string, CalculatedExpression[]>;
-  variablesFhirPath: Record<string, Expression[]>;
+  variables: Variables;
   existingFhirPathContext: Record<string, any>;
   fhirPathTerminologyCache: Record<string, any>;
   terminologyServerUrl: string;
@@ -56,7 +56,7 @@ export async function evaluateInitialCalculatedExpressions(
     initialResponse,
     initialResponseItemMap,
     calculatedExpressions,
-    variablesFhirPath,
+    variables,
     existingFhirPathContext,
     terminologyServerUrl
   } = params;
@@ -81,7 +81,7 @@ export async function evaluateInitialCalculatedExpressions(
   const fhirPathEvalResult = await createFhirPathContext(
     initialResponse,
     initialResponseItemMap,
-    variablesFhirPath,
+    variables,
     existingFhirPathContext,
     fhirPathTerminologyCache,
     terminologyServerUrl

package/src/utils/enableWhenExpression.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import type { Expression, QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
+import type { QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
 import { createFhirPathContext, handleFhirPathResult } from './fhirpath';
 import fhirpath from 'fhirpath';
 import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
@@ -24,12 +24,13 @@ import type {
   EnableWhenRepeatExpression,
   EnableWhenSingleExpression
 } from '../interfaces/enableWhen.interface';
+import type { Variables } from '../interfaces';
 
 interface EvaluateInitialEnableWhenExpressionsParams {
   initialResponse: QuestionnaireResponse;
   initialResponseItemMap: Record<string, QuestionnaireResponseItem[]>;
   enableWhenExpressions: EnableWhenExpressions;
-  variablesFhirPath: Record<string, Expression[]>;
+  variables: Variables;
   existingFhirPathContext: Record<string, any>;
   fhirPathTerminologyCache: Record<string, any>;
   terminologyServerUrl: string;
@@ -46,7 +47,7 @@ export async function evaluateInitialEnableWhenExpressions(
     initialResponse,
     initialResponseItemMap,
     enableWhenExpressions,
-    variablesFhirPath,
+    variables,
     existingFhirPathContext,
     terminologyServerUrl
   } = params;
@@ -58,7 +59,7 @@ export async function evaluateInitialEnableWhenExpressions(
   const fhirPathEvalResult = await createFhirPathContext(
     initialResponse,
     initialResponseItemMap,
-    variablesFhirPath,
+    variables,
     existingFhirPathContext,
     fhirPathTerminologyCache,
     terminologyServerUrl
@@ -325,7 +326,7 @@ export async function evaluateEnableWhenExpressions(
 interface MutateRepeatEnableWhenExpressionInstancesParams {
   questionnaireResponse: QuestionnaireResponse;
   questionnaireResponseItemMap: Record<string, QuestionnaireResponseItem[]>;
-  variablesFhirPath: Record<string, Expression[]>;
+  variables: Variables;
   existingFhirPathContext: Record<string, any>;
   fhirPathTerminologyCache: Record<string, any>;
   enableWhenExpressions: EnableWhenExpressions;
@@ -341,7 +342,7 @@ export async function mutateRepeatEnableWhenExpressionInstances(
   const {
     questionnaireResponse,
     questionnaireResponseItemMap,
-    variablesFhirPath,
+    variables,
     fhirPathTerminologyCache,
     existingFhirPathContext,
     enableWhenExpressions,
@@ -356,7 +357,7 @@ export async function mutateRepeatEnableWhenExpressionInstances(
   const fhirPathEvalResult = await createFhirPathContext(
     questionnaireResponse,
     questionnaireResponseItemMap,
-    variablesFhirPath,
+    variables,
     existingFhirPathContext,
     fhirPathTerminologyCache,
     terminologyServerUrl

package/src/utils/fhirpath.ts

@@ -22,13 +22,17 @@ import type { CalculatedExpression } from '../interfaces/calculatedExpression.in
 import type { EnableWhenExpressions } from '../interfaces/enableWhen.interface';
 import { evaluateEnableWhenExpressions } from './enableWhenExpression';
 import { evaluateCalculatedExpressions } from './calculatedExpression';
+import { evaluateTargetConstraints } from './targetConstraint';
+import type { TargetConstraint } from '../interfaces/targetConstraint.interface';
+import type { Variables, VariableXFhirQuery } from '../interfaces';
 
 interface EvaluateUpdatedExpressionsParams {
   updatedResponse: QuestionnaireResponse;
   updatedResponseItemMap: Record<string, QuestionnaireResponseItem[]>;
+  targetConstraints: Record<string, TargetConstraint>;
   calculatedExpressions: Record<string, CalculatedExpression[]>;
   enableWhenExpressions: EnableWhenExpressions;
-  variablesFhirPath: Record<string, Expression[]>;
+  variables: Variables;
   existingFhirPathContext: Record<string, any>;
   fhirPathTerminologyCache: Record<string, any>;
   terminologyServerUrl: string;
@@ -38,6 +42,7 @@ export async function evaluateUpdatedExpressions(
   params: EvaluateUpdatedExpressionsParams
 ): Promise<{
   isUpdated: boolean;
+  updatedTargetConstraints: Record<string, TargetConstraint>;
   updatedEnableWhenExpressions: EnableWhenExpressions;
   updatedCalculatedExpressions: Record<string, CalculatedExpression[]>;
   updatedFhirPathContext: Record<string, any>;
@@ -46,9 +51,10 @@ export async function evaluateUpdatedExpressions(
   const {
     updatedResponse,
     updatedResponseItemMap,
+    targetConstraints,
     enableWhenExpressions,
     calculatedExpressions,
-    variablesFhirPath,
+    variables,
     existingFhirPathContext,
     terminologyServerUrl
   } = params;
@@ -57,9 +63,10 @@ export async function evaluateUpdatedExpressions(
   const noExpressionsToBeUpdated =
     Object.keys(enableWhenExpressions).length === 0 &&
     Object.keys(calculatedExpressions).length === 0;
-  if (noExpressionsToBeUpdated || !updatedResponse.item) {
+  if (noExpressionsToBeUpdated) {
     return {
       isUpdated: false,
+      updatedTargetConstraints: targetConstraints,
       updatedEnableWhenExpressions: enableWhenExpressions,
       updatedCalculatedExpressions: calculatedExpressions,
       updatedFhirPathContext: existingFhirPathContext,
@@ -70,7 +77,7 @@ export async function evaluateUpdatedExpressions(
   const fhirPathEvalResult = await createFhirPathContext(
     updatedResponse,
     updatedResponseItemMap,
-    variablesFhirPath,
+    variables,
     existingFhirPathContext,
     fhirPathTerminologyCache,
     terminologyServerUrl
@@ -79,6 +86,14 @@ export async function evaluateUpdatedExpressions(
   const updatedFhirPathContext = fhirPathEvalResult.fhirPathContext;
   fhirPathTerminologyCache = fhirPathEvalResult.fhirPathTerminologyCache;
 
+  // Update targetConstraints
+  const { targetConstraintsIsUpdated, updatedTargetConstraints } = await evaluateTargetConstraints(
+    updatedFhirPathContext,
+    fhirPathTerminologyCache,
+    targetConstraints,
+    terminologyServerUrl
+  );
+
   // Update enableWhenExpressions
   const { enableWhenExpsIsUpdated, updatedEnableWhenExpressions } =
     await evaluateEnableWhenExpressions(
@@ -97,10 +112,12 @@ export async function evaluateUpdatedExpressions(
       terminologyServerUrl
     );
 
-  const isUpdated = enableWhenExpsIsUpdated || calculatedExpsIsUpdated;
+  const isUpdated =
+    enableWhenExpsIsUpdated || calculatedExpsIsUpdated || targetConstraintsIsUpdated;
 
   return {
     isUpdated,
+    updatedTargetConstraints,
     updatedEnableWhenExpressions,
     updatedCalculatedExpressions,
     updatedFhirPathContext,
@@ -111,7 +128,7 @@ export async function evaluateUpdatedExpressions(
 export async function createFhirPathContext(
   questionnaireResponse: QuestionnaireResponse,
   questionnaireResponseItemMap: Record<string, QuestionnaireResponseItem[]>,
-  variablesFhirPath: Record<string, Expression[]>,
+  variables: Variables,
   existingFhirPathContext: Record<string, any>,
   fhirPathTerminologyCache: Record<string, any>,
   terminologyServerUrl: string
@@ -119,6 +136,9 @@ export async function createFhirPathContext(
   fhirPathContext: Record<string, any>;
   fhirPathTerminologyCache: Record<string, any>;
 }> {
+  const { fhirPathVariables: variablesFhirPath, xFhirQueryVariables: variablesXFhirQuery } =
+    variables;
+
   // Add latest resource to fhirPathContext
   let fhirPathContext: Record<string, any> = {
     ...existingFhirPathContext,
@@ -126,6 +146,12 @@ export async function createFhirPathContext(
     rootResource: questionnaireResponse
   };
 
+  // Add empty x-fhir-query variables to fhirPathContext to prevent false-positive warnings
+  fhirPathContext = addEmptyXFhirQueryVariablesToFhirPathContext(
+    fhirPathContext,
+    variablesXFhirQuery
+  );
+
   // Evaluate resource-level variables
   const fhirPathEvalResult = await evaluateQuestionnaireLevelVariables(
     questionnaireResponse,
@@ -155,13 +181,32 @@ export async function createFhirPathContext(
   }
 
   // Items don't exist in questionnaireResponseItemMap, but we still have to add them into the fhirPathContext as empty arrays
+  const qrItemMapIsEmpty = Object.keys(questionnaireResponseItemMap).length === 0;
   for (const linkId in variablesFhirPath) {
-    fhirPathContext = addEmptyLinkIdVariables(linkId, variablesFhirPath, fhirPathContext);
+    fhirPathContext = addEmptyLinkIdVariables(
+      linkId,
+      variablesFhirPath,
+      fhirPathContext,
+      qrItemMapIsEmpty
+    );
   }
 
   return { fhirPathContext, fhirPathTerminologyCache };
 }
 
+export function addEmptyXFhirQueryVariablesToFhirPathContext(
+  fhirPathContext: Record<string, any>,
+  variablesXFhirQuery: Record<string, VariableXFhirQuery>
+) {
+  for (const variableName in variablesXFhirQuery) {
+    if (!fhirPathContext[variableName]) {
+      fhirPathContext[variableName] = [];
+    }
+  }
+
+  return fhirPathContext;
+}
+
 export async function evaluateLinkIdVariables(
   item: QuestionnaireResponseItem,
   variablesFhirPath: Record<string, Expression[]>,
@@ -213,7 +258,8 @@ export async function evaluateLinkIdVariables(
 export function addEmptyLinkIdVariables(
   linkId: string,
   variablesFhirPath: Record<string, Expression[]>,
-  fhirPathContext: Record<string, any>
+  fhirPathContext: Record<string, any>,
+  qrItemMapIsEmpty: boolean
 ) {
   const linkIdVariables = variablesFhirPath[linkId];
   if (!linkIdVariables || linkIdVariables.length === 0) {
@@ -222,7 +268,9 @@ export function addEmptyLinkIdVariables(
 
   for (const variable of linkIdVariables) {
     if (variable.expression && variable.name) {
-      if (fhirPathContext[`${variable.name}`] === undefined) {
+      // If the variable is not evaluated, add it as an empty array
+      // Also, when questionnaireResponseItemMap is empty, no items exist in the questionnaireResponse, therefore no variables are evaluated
+      if (fhirPathContext[`${variable.name}`] === undefined || qrItemMapIsEmpty) {
         fhirPathContext[`${variable.name}`] = [];
       }
     }

package/src/utils/initialise.ts

@@ -19,7 +19,6 @@ import { evaluateInitialEnableWhenExpressions } from './enableWhenExpression';
 import { getFirstVisibleTab } from './tabs';
 import { getFirstVisiblePage } from './page';
 import type {
-  Expression,
   Questionnaire,
   QuestionnaireItem,
   QuestionnaireItemInitial,
@@ -36,6 +35,9 @@ import { evaluateInitialCalculatedExpressions } from './calculatedExpression';
 import { createQuestionnaireResponseItemMap } from './questionnaireResponseStoreUtils/updatableResponseItems';
 import { readQuestionnaireResponse } from './genericRecursive';
 import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
+import type { TargetConstraint } from '../interfaces/targetConstraint.interface';
+import { evaluateInitialTargetConstraints } from './targetConstraint';
+import type { Variables } from '../interfaces';
 
 /**
  * Initialise a questionnaireResponse from a given questionnaire
@@ -311,10 +313,11 @@ function createNewRepeatGroupQuestionnaireResponseItem(
 
 export interface initialFormFromResponseParams {
   questionnaireResponse: QuestionnaireResponse;
+  targetConstraints: Record<string, TargetConstraint>;
   enableWhenItems: EnableWhenItems;
   enableWhenExpressions: EnableWhenExpressions;
   calculatedExpressions: Record<string, CalculatedExpression[]>;
-  variablesFhirPath: Record<string, Expression[]>;
+  variables: Variables;
   tabs: Tabs;
   pages: Pages;
   fhirPathContext: Record<string, any>;
@@ -323,6 +326,7 @@ export interface initialFormFromResponseParams {
 }
 
 export async function initialiseFormFromResponse(params: initialFormFromResponseParams): Promise<{
+  initialTargetConstraints: Record<string, TargetConstraint>;
   initialEnableWhenItems: EnableWhenItems;
   initialEnableWhenLinkedQuestions: Record<string, string[]>;
   initialEnableWhenExpressions: EnableWhenExpressions;
@@ -334,10 +338,11 @@ export async function initialiseFormFromResponse(params: initialFormFromResponse
 }> {
   const {
     questionnaireResponse,
+    targetConstraints,
     enableWhenItems,
     enableWhenExpressions,
     calculatedExpressions,
-    variablesFhirPath,
+    variables,
     tabs,
     pages,
     fhirPathContext,
@@ -353,24 +358,35 @@ export async function initialiseFormFromResponse(params: initialFormFromResponse
     questionnaireResponse
   );
 
+  const evaluateInitialTargetConstraintsResult = await evaluateInitialTargetConstraints({
+    initialResponse: questionnaireResponse,
+    initialResponseItemMap: initialResponseItemMap,
+    targetConstraints: targetConstraints,
+    variables: variables,
+    existingFhirPathContext: fhirPathContext,
+    fhirPathTerminologyCache: fhirPathTerminologyCache,
+    terminologyServerUrl
+  });
+  const { initialTargetConstraints } = evaluateInitialTargetConstraintsResult;
+  fhirPathTerminologyCache = evaluateInitialTargetConstraintsResult.fhirPathTerminologyCache;
+
   const evaluateInitialEnableWhenExpressionsResult = await evaluateInitialEnableWhenExpressions({
     initialResponse: questionnaireResponse,
     initialResponseItemMap: initialResponseItemMap,
     enableWhenExpressions: enableWhenExpressions,
-    variablesFhirPath: variablesFhirPath,
+    variables: variables,
     existingFhirPathContext: fhirPathContext,
     fhirPathTerminologyCache: fhirPathTerminologyCache,
     terminologyServerUrl: terminologyServerUrl
   });
   const { initialEnableWhenExpressions } = evaluateInitialEnableWhenExpressionsResult;
-  updatedFhirPathContext = evaluateInitialEnableWhenExpressionsResult.updatedFhirPathContext;
   fhirPathTerminologyCache = evaluateInitialEnableWhenExpressionsResult.fhirPathTerminologyCache;
 
   const evaluateInitialCalculatedExpressionsResult = await evaluateInitialCalculatedExpressions({
     initialResponse: questionnaireResponse,
     initialResponseItemMap: initialResponseItemMap,
     calculatedExpressions: calculatedExpressions,
-    variablesFhirPath: variablesFhirPath,
+    variables: variables,
     existingFhirPathContext: fhirPathContext,
     fhirPathTerminologyCache: fhirPathTerminologyCache,
     terminologyServerUrl
@@ -389,6 +405,7 @@ export async function initialiseFormFromResponse(params: initialFormFromResponse
       : 0;
 
   return {
+    initialTargetConstraints,
     initialEnableWhenItems: initialisedItems,
     initialEnableWhenLinkedQuestions: linkedQuestions,
     initialEnableWhenExpressions,

package/src/utils/itemControl.ts

@@ -471,6 +471,21 @@ export function getMaxValueFeedback(qItem: QuestionnaireItem) {
   return null;
 }
 
+export function getRequiredFeedback(qItem: QuestionnaireItem) {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'https://smartforms.csiro.au/ig/StructureDefinition/required-feedback'
+  );
+  if (itemControl) {
+    const extensionString = itemControl.valueString;
+    if (extensionString) {
+      return extensionString;
+    }
+  }
+
+  return null;
+}
+
 /**
  * Check if the item  has a sdc-questionnaire-minQuantity and minQuantity extension
  * @author Janardhan Vignarajan

package/src/utils/manageForm.ts

@@ -65,6 +65,9 @@ export async function buildForm(
   questionnaireResponseStore.getState().buildSourceResponse(initialisedQuestionnaireResponse);
   await questionnaireStore.getState().updatePopulatedProperties(initialisedQuestionnaireResponse);
 
+  // Adding another call to buildSourceResponse so invalidItems is truly updated - not great, but a cheap fix
+  questionnaireResponseStore.getState().buildSourceResponse(initialisedQuestionnaireResponse);
+
   if (readOnly) {
     questionnaireStore.getState().setFormAsReadOnly(readOnly);
   }

package/src/utils/questionnaireStoreUtils/createQuestionaireModel.ts

@@ -31,6 +31,8 @@ import { resolveValueSets } from './resolveValueSets';
 import { addAdditionalVariables } from './addAdditionalVariables';
 import { getLinkIdPreferredTerminologyServerTuples, getLinkIdTypeTuples } from '../qItem';
 import { addDisplayToAnswerOptions, addDisplayToProcessedCodings } from './addDisplayToCodings';
+import type { TargetConstraint } from '../../interfaces/targetConstraint.interface';
+import { extractTargetConstraints } from './extractTargetConstraint';
 
 export async function createQuestionnaireModel(
   questionnaire: Questionnaire,
@@ -49,6 +51,8 @@ export async function createQuestionnaireModel(
   const pages: Pages = extractPages(questionnaire);
 
   const launchContexts: Record<string, LaunchContext> = extractLaunchContexts(questionnaire);
+  const targetConstraints: Record<string, TargetConstraint> =
+    extractTargetConstraints(questionnaire);
 
   let variables: Variables = extractQuestionnaireLevelVariables(questionnaire);
   variables = addAdditionalVariables(variables, additionalVariables);
@@ -109,6 +113,7 @@ export async function createQuestionnaireModel(
     pages,
     variables,
     launchContexts,
+    targetConstraints,
     enableWhenItems,
     enableWhenExpressions,
     calculatedExpressions,
@@ -130,6 +135,7 @@ function createEmptyModel(): QuestionnaireModel {
     pages: {},
     variables: { fhirPathVariables: {}, xFhirQueryVariables: {} },
     launchContexts: {},
+    targetConstraints: {},
     calculatedExpressions: {},
     initialExpressions: {},
     enableWhenExpressions: { singleExpressions: {}, repeatExpressions: {} },

package/src/utils/questionnaireStoreUtils/extractTargetConstraint.ts

@@ -0,0 +1,71 @@
+import type { Extension, Questionnaire } from 'fhir/r4';
+import type {
+  TargetConstraint,
+  TargetConstraintExpression,
+  TargetConstraintHuman,
+  TargetConstraintKey,
+  TargetConstraintLocation,
+  TargetConstraintSeverity
+} from '../../interfaces/targetConstraint.interface';
+
+export function constructTargetConstraint(extension: Extension): TargetConstraint | null {
+  const targetConstraintUrl = extension.url;
+  const targetConstraintKey = extension.extension?.find(
+    (ext) => ext.url === 'key' && typeof ext.valueId === 'string'
+  ) as TargetConstraintKey | undefined;
+
+  const targetConstraintSeverity = extension.extension?.find(
+    (ext) =>
+      ext.url === 'severity' &&
+      ext.valueCode &&
+      (ext.valueCode === 'error' || ext.valueCode === 'warning')
+  ) as TargetConstraintSeverity | undefined;
+
+  const targetConstraintExpression = extension.extension?.find(
+    (ext) => ext.url === 'expression' && ext.valueExpression
+  ) as TargetConstraintExpression | undefined;
+
+  const targetConstraintHuman = extension.extension?.find(
+    (ext) => ext.url === 'human' && ext.valueString
+  ) as TargetConstraintHuman | undefined;
+
+  const hasTargetConstraintLocation = extension.extension?.find(
+    (ext) => ext.url === 'location' && ext.valueString
+  ) as TargetConstraintLocation | undefined;
+
+  if (
+    targetConstraintUrl === 'http://hl7.org/fhir/StructureDefinition/targetConstraint' &&
+    targetConstraintKey &&
+    targetConstraintSeverity &&
+    targetConstraintExpression &&
+    targetConstraintHuman
+  ) {
+    return {
+      key: targetConstraintKey.valueId,
+      severityCode: targetConstraintSeverity.valueCode,
+      valueExpression: targetConstraintExpression.valueExpression,
+      human: targetConstraintHuman.valueString,
+      location: hasTargetConstraintLocation?.valueString
+    };
+  }
+
+  return null;
+}
+
+export function extractTargetConstraints(
+  questionnaire: Questionnaire
+): Record<string, TargetConstraint> {
+  if (!questionnaire.extension || questionnaire.extension.length === 0) {
+    return {};
+  }
+
+  const targetConstraints: Record<string, TargetConstraint> = {};
+  for (const ext of questionnaire.extension) {
+    const targetConstraint = constructTargetConstraint(ext);
+    if (targetConstraint?.key) {
+      targetConstraints[targetConstraint?.key] = targetConstraint;
+    }
+  }
+
+  return targetConstraints;
+}