@aehrc/smart-forms-renderer 0.10.5 → 0.11.0

package/src/utils/initialise.ts

@@ -0,0 +1,379 @@
+/*
+ * 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,
+  Questionnaire,
+  QuestionnaireItem,
+  QuestionnaireItemInitial,
+  QuestionnaireResponse,
+  QuestionnaireResponseItem,
+  QuestionnaireResponseItemAnswer
+} 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';
+
+/**
+ * Initialise a conformant questionnaireResponse from a given questionnaire
+ * optionally takes in an existing questionnaireResponse to be initialised
+ *
+ * @author Sean Fong
+ */
+export function initialiseQuestionnaireResponse(
+  questionnaire: Questionnaire,
+  questionnaireResponse?: QuestionnaireResponse
+) {
+  if (!questionnaireResponse) {
+    questionnaireResponse = {
+      resourceType: 'QuestionnaireResponse',
+      status: 'in-progress'
+    };
+  }
+
+  if (!questionnaireResponse.status) {
+    questionnaireResponse.status = 'in-progress';
+  }
+
+  const firstTopLevelItem = questionnaire?.item?.[0];
+  if (firstTopLevelItem && !questionnaireResponse.item) {
+    const initialItems = readItemInitialValues(questionnaire);
+
+    questionnaireResponse.item =
+      initialItems && initialItems.length > 0
+        ? initialItems
+        : [
+            {
+              linkId: firstTopLevelItem.linkId,
+              text: firstTopLevelItem.text,
+              item: []
+            }
+          ];
+  }
+
+  if (!questionnaireResponse.questionnaire) {
+    questionnaireResponse.questionnaire = setQuestionnaireReference(questionnaire);
+  }
+
+  return questionnaireResponse;
+}
+
+function setQuestionnaireReference(questionnaire: Questionnaire) {
+  // Use {url}|{version} - the ideal way
+  if (questionnaire.url) {
+    let questionnaireReference = questionnaire.url;
+    if (questionnaire.version) {
+      questionnaireReference += '|' + questionnaire.version;
+    }
+    return questionnaireReference;
+  }
+
+  // If no url exists, use Questionnaire/{id}
+  if (questionnaire.id) {
+    return `Questionnaire/${questionnaire.id}`;
+  }
+
+  return '';
+}
+
+function readItemInitialValues(questionnaire: Questionnaire) {
+  if (!questionnaire.item || questionnaire.item.length === 0) {
+    return null;
+  }
+
+  const topLevelQrItems: QuestionnaireResponseItem[] = [];
+  for (const topLevelQItem of questionnaire.item) {
+    const updatedTopLevelQRItem = readItemInitialValueRecursive(topLevelQItem);
+
+    if (Array.isArray(updatedTopLevelQRItem)) {
+      if (updatedTopLevelQRItem.length > 0) {
+        topLevelQrItems.push(...updatedTopLevelQRItem);
+      }
+      continue;
+    }
+
+    if (updatedTopLevelQRItem) {
+      topLevelQrItems.push(updatedTopLevelQRItem);
+    }
+  }
+
+  if (topLevelQrItems.length === 0) {
+    return null;
+  }
+
+  return topLevelQrItems;
+}
+
+function readItemInitialValueRecursive(
+  qItem: QuestionnaireItem
+): QuestionnaireResponseItem[] | QuestionnaireResponseItem | null {
+  const childQItems = qItem.item;
+  if (childQItems && childQItems.length > 0) {
+    // TODO No support for multiple rows at the moment
+    if (qItem.type === 'group' && qItem.repeats) {
+      const initialItemsFromRepeatGroup = getInitialValueAnswersFromRepeatGroup(qItem);
+      return createNewRepeatGroupQuestionnaireResponseItem(qItem, initialItemsFromRepeatGroup);
+    }
+
+    const initialQRItems: QuestionnaireResponseItem[] = [];
+    for (const childQItem of childQItems) {
+      const initialChildQRItemOrItems = readItemInitialValueRecursive(childQItem);
+
+      if (Array.isArray(initialChildQRItemOrItems)) {
+        if (initialChildQRItemOrItems.length > 0) {
+          initialQRItems.push(...initialChildQRItemOrItems);
+        }
+        continue;
+      }
+
+      if (initialChildQRItemOrItems) {
+        initialQRItems.push(initialChildQRItemOrItems);
+      }
+    }
+
+    let qrItem = createNewQuestionnaireResponseItem(qItem, getInitialValueAnswers(qItem));
+
+    if (initialQRItems.length > 0) {
+      if (!qrItem) {
+        qrItem = {
+          linkId: qItem.linkId,
+          text: qItem.text
+        };
+      }
+      qrItem.item = initialQRItems;
+    }
+
+    return qrItem;
+  }
+
+  return createNewQuestionnaireResponseItem(qItem, getInitialValueAnswers(qItem));
+}
+
+function getInitialValueAnswers(qItem: QuestionnaireItem): QuestionnaireResponseItemAnswer[] {
+  // For answerOption.initialSelected
+  if (qItem.type === 'choice' && qItem.answerOption) {
+    return qItem.answerOption
+      .filter((option) => option.initialSelected)
+      .map((option): QuestionnaireResponseItemAnswer | null => {
+        if (option.valueCoding) {
+          return {
+            valueCoding: option.valueCoding
+          };
+        }
+
+        if (option.valueString) {
+          return {
+            valueString: option.valueString
+          };
+        }
+
+        if (option.valueInteger) {
+          return {
+            valueInteger: option.valueInteger
+          };
+        }
+
+        return null;
+      })
+      .filter((item): item is QuestionnaireResponseItemAnswer => !!item);
+  }
+
+  // For item.initial
+  const initialValues = qItem.initial;
+  if (!initialValues) {
+    return [];
+  }
+
+  return initialValues
+    .map((initialValue) => initialValueSwitcher(initialValue))
+    .filter((item): item is QuestionnaireResponseItemAnswer => item !== null);
+}
+
+function getInitialValueAnswersFromRepeatGroup(qItem: QuestionnaireItem) {
+  if (!qItem.item) {
+    return [];
+  }
+
+  return qItem.item
+    .map((childQItem): QuestionnaireResponseItem => {
+      return {
+        linkId: childQItem.linkId,
+        ...(childQItem.text ? { text: childQItem.text } : {}),
+        answer: getInitialValueAnswers(childQItem)
+      };
+    })
+    .filter((childQRItem) => childQRItem.answer && childQRItem.answer.length > 0);
+}
+
+function initialValueSwitcher(
+  initialValue: QuestionnaireItemInitial
+): QuestionnaireResponseItemAnswer | null {
+  if (initialValue.valueBoolean) {
+    return { valueBoolean: initialValue.valueBoolean };
+  }
+
+  if (initialValue.valueDecimal) {
+    return { valueDecimal: initialValue.valueDecimal };
+  }
+
+  if (initialValue.valueInteger) {
+    return { valueInteger: initialValue.valueInteger };
+  }
+
+  if (initialValue.valueDate) {
+    return { valueDate: initialValue.valueDate };
+  }
+
+  if (initialValue.valueDateTime) {
+    return { valueDateTime: initialValue.valueDateTime };
+  }
+
+  if (initialValue.valueTime) {
+    return { valueTime: initialValue.valueTime };
+  }
+
+  if (initialValue.valueString) {
+    return { valueString: initialValue.valueString };
+  }
+
+  if (initialValue.valueUri) {
+    return { valueUri: initialValue.valueUri };
+  }
+
+  if (initialValue.valueAttachment) {
+    return { valueAttachment: initialValue.valueAttachment };
+  }
+
+  if (initialValue.valueCoding) {
+    return { valueCoding: initialValue.valueCoding };
+  }
+
+  if (initialValue.valueQuantity) {
+    return { valueQuantity: initialValue.valueQuantity };
+  }
+
+  if (initialValue.valueReference) {
+    return { valueReference: initialValue.valueReference };
+  }
+
+  return null;
+}
+
+function createNewQuestionnaireResponseItem(
+  qItem: QuestionnaireItem,
+  initialValueAnswers: QuestionnaireResponseItemAnswer[]
+): QuestionnaireResponseItem | null {
+  if (initialValueAnswers.length === 0) {
+    return null;
+  }
+
+  // If item is non-repeating, only take the first initial value
+  if (!qItem.repeats) {
+    initialValueAnswers = [initialValueAnswers[0]];
+  }
+
+  return {
+    linkId: qItem.linkId,
+    text: qItem.text,
+    answer: initialValueAnswers
+  };
+}
+
+function createNewRepeatGroupQuestionnaireResponseItem(
+  qItem: QuestionnaireItem,
+  initialValueItems: QuestionnaireResponseItem[]
+): QuestionnaireResponseItem | null {
+  if (initialValueItems.length === 0) {
+    return null;
+  }
+
+  return {
+    linkId: qItem.linkId,
+    text: qItem.text,
+    item: initialValueItems
+  };
+}
+
+export interface initialFormFromResponseParams {
+  questionnaireResponse: QuestionnaireResponse;
+  enableWhenItems: EnableWhenItems;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+  calculatedExpressions: Record<string, CalculatedExpression>;
+  variablesFhirPath: Record<string, Expression[]>;
+  tabs: Tabs;
+  fhirPathContext: Record<string, any>;
+}
+
+export function initialiseFormFromResponse(params: initialFormFromResponseParams): {
+  initialEnableWhenItems: EnableWhenItems;
+  initialEnableWhenLinkedQuestions: Record<string, string[]>;
+  initialEnableWhenExpressions: Record<string, EnableWhenExpression>;
+  initialCalculatedExpressions: Record<string, CalculatedExpression>;
+  firstVisibleTab: number;
+  updatedFhirPathContext: Record<string, any>;
+} {
+  const {
+    questionnaireResponse,
+    enableWhenItems,
+    enableWhenExpressions,
+    calculatedExpressions,
+    variablesFhirPath,
+    tabs
+  } = params;
+  let updatedFhirPathContext = params.fhirPathContext;
+
+  const { initialisedItems, linkedQuestions } = assignPopulatedAnswersToEnableWhen(
+    enableWhenItems,
+    questionnaireResponse
+  );
+
+  const evaluateInitialEnableWhenExpressionsResult = evaluateInitialEnableWhenExpressions({
+    initialResponse: questionnaireResponse,
+    enableWhenExpressions: enableWhenExpressions,
+    variablesFhirPath: variablesFhirPath,
+    existingFhirPathContext: updatedFhirPathContext
+  });
+  const { initialEnableWhenExpressions } = evaluateInitialEnableWhenExpressionsResult;
+  updatedFhirPathContext = evaluateInitialEnableWhenExpressionsResult.updatedFhirPathContext;
+
+  const evaluateInitialCalculatedExpressionsResult = evaluateInitialCalculatedExpressions({
+    initialResponse: questionnaireResponse,
+    calculatedExpressions: calculatedExpressions,
+    variablesFhirPath: variablesFhirPath,
+    existingFhirPathContext: updatedFhirPathContext
+  });
+  const { initialCalculatedExpressions } = evaluateInitialCalculatedExpressionsResult;
+  updatedFhirPathContext = evaluateInitialEnableWhenExpressionsResult.updatedFhirPathContext;
+
+  const firstVisibleTab =
+    Object.keys(tabs).length > 0
+      ? getFirstVisibleTab(tabs, initialisedItems, initialEnableWhenExpressions)
+      : 0;
+
+  return {
+    initialEnableWhenItems: initialisedItems,
+    initialEnableWhenLinkedQuestions: linkedQuestions,
+    initialEnableWhenExpressions,
+    initialCalculatedExpressions,
+    firstVisibleTab,
+    updatedFhirPathContext
+  };
+}

package/src/utils/qItem.ts

@@ -16,11 +16,11 @@
  */
 
 import type { Extension, Questionnaire, QuestionnaireItem } from 'fhir/r4';
-import { hasHiddenExtension } from './itemControl';
 import { getChoiceControlType } from './choice';
 import { ChoiceItemControl, OpenChoiceItemControl } from '../interfaces/choice.enum';
 import { getOpenChoiceControlType } from './openChoice';
 import type { EnableWhenExpression, EnableWhenItems } from '../interfaces/enableWhen.interface';
+import { structuredDataCapture } from 'fhir-sdc-helpers';
 
 interface isHiddenParams {
   questionnaireItem: QuestionnaireItem;
@@ -39,7 +39,7 @@ interface isHiddenParams {
 export function isHidden(params: isHiddenParams): boolean {
   const { questionnaireItem, enableWhenIsActivated, enableWhenItems, enableWhenExpressions } =
     params;
-  if (hasHiddenExtension(questionnaireItem)) {
+  if (structuredDataCapture.getHidden(questionnaireItem)) {
     return true;
   }
 

package/src/utils/qrItem.ts

@@ -15,72 +15,10 @@
  * limitations under the License.
  */
 
-import type {
-  Questionnaire,
-  QuestionnaireItem,
-  QuestionnaireResponse,
-  QuestionnaireResponseItem
-} from 'fhir/r4';
+import type { QuestionnaireItem, QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
 
 import type { QrRepeatGroup } from '../interfaces/repeatGroup.interface';
 
-/**
- * Initialise a conformant questionnaireResponse from a given questionnaire
- * optionally takes in an existing questionnaireResponse to be initialised
- *
- * @author Sean Fong
- */
-export function initialiseQuestionnaireResponse(
-  questionnaire: Questionnaire,
-  questionnaireResponse?: QuestionnaireResponse
-) {
-  if (!questionnaireResponse) {
-    questionnaireResponse = {
-      resourceType: 'QuestionnaireResponse',
-      status: 'in-progress'
-    };
-  }
-
-  if (!questionnaireResponse.status) {
-    questionnaireResponse.status = 'in-progress';
-  }
-
-  const firstTopLevelItem = questionnaire?.item?.[0];
-  if (firstTopLevelItem && !questionnaireResponse.item) {
-    questionnaireResponse.item = [
-      {
-        linkId: firstTopLevelItem.linkId,
-        text: firstTopLevelItem.text,
-        item: []
-      }
-    ];
-  }
-
-  if (!questionnaireResponse.questionnaire) {
-    questionnaireResponse.questionnaire = setQuestionnaireReference(questionnaire);
-  }
-
-  return questionnaireResponse;
-}
-
-export function setQuestionnaireReference(questionnaire: Questionnaire) {
-  // Use {url}|{version} - the ideal way
-  if (questionnaire.url) {
-    let questionnaireReference = questionnaire.url;
-    if (questionnaire.version) {
-      questionnaireReference += '|' + questionnaire.version;
-    }
-    return questionnaireReference;
-  }
-
-  // If no url exists, use Questionnaire/{id}
-  if (questionnaire.id) {
-    return `Questionnaire/${questionnaire.id}`;
-  }
-
-  return '';
-}
-
 /**
  * Remove items with no answers from a given questionnaireResponse
  * Also remove any starting or trailing whitespace from valueStrings

package/src/utils/tabs.ts

@@ -18,8 +18,9 @@
 import type { Tabs } from '../interfaces/tab.interface';
 import type { EnableWhenExpression, EnableWhenItems } from '../interfaces/enableWhen.interface';
 import type { Coding, QuestionnaireItem } from 'fhir/r4';
-import { hasHiddenExtension, isSpecificItemControl } from './itemControl';
+import { isSpecificItemControl } from './itemControl';
 import { isHidden, isHiddenByEnableWhens } from './qItem';
+import { structuredDataCapture } from 'fhir-sdc-helpers';
 
 export function getFirstVisibleTab(
   tabs: Tabs,
@@ -134,7 +135,7 @@ export function constructTabsWithProperties(
     tabs[qItem.linkId] = {
       tabIndex: i,
       isComplete: false,
-      isHidden: hasHiddenExtension(qItem)
+      isHidden: structuredDataCapture.getHidden(qItem) ?? false
     };
   }
   return tabs;
@@ -201,26 +202,6 @@ export function getNextVisibleTabIndex(params: getNextVisibleTabIndexParams): nu
 
   return nextTabIndex;
 }
-/**
- *
- * Get index of first visible tab
- *
- * @author Sean Fong
- */
-export function getFirstVisibleTabIndex(
-  tabs: Tabs,
-  enableWhenIsActivated: boolean,
-  enableWhenItems: EnableWhenItems,
-  enableWhenExpressions: Record<string, EnableWhenExpression>
-): number | undefined {
-  const tabsWithVisibility = constructTabsWithVisibility({
-    tabs,
-    enableWhenIsActivated,
-    enableWhenItems,
-    enableWhenExpressions
-  });
-  return tabsWithVisibility.findIndex((tab) => tab.isVisible);
-}
 
 /**
  *

package/src/utils/valueSet.ts

@@ -28,8 +28,8 @@ import type {
 } from 'fhir/r4';
 import * as FHIR from 'fhirclient';
 import type { FhirResourceString } from '../interfaces/populate.interface';
-import type { ValueSetPromise } from '../interfaces/valueSet.interface';
 import type { VariableXFhirQuery } from '../interfaces/variables.interface';
+import type { ValueSetPromise } from '../interfaces/valueSet.interface';
 
 const VALID_VALUE_SET_URL_REGEX =
   /https?:\/\/(www\.)?[-\w@:%.+~#=]{2,256}\.[a-z]{2,4}\b([-@\w:%+.~#?&/=]*ValueSet[-@\w:%+.~#?&/=]*)/;

package/src/hooks/useBackToTop.ts

@@ -1,29 +0,0 @@
-/*
- * 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 { useEffect } from 'react';
-import { useLocation } from 'react-router-dom';
-
-function useBackToTop() {
-  const { pathname } = useLocation();
-
-  useEffect(() => {
-    window.scrollTo(0, 0);
-  }, [pathname]);
-}
-
-export default useBackToTop;

package/src/utils/initialiseForm.ts

@@ -1,91 +0,0 @@
-/*
- * 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;
-  fhirPathContext: Record<string, any>;
-}
-
-export function initialiseFormFromResponse(params: initialFormFromResponseParams): {
-  initialEnableWhenItems: EnableWhenItems;
-  initialEnableWhenLinkedQuestions: Record<string, string[]>;
-  initialEnableWhenExpressions: Record<string, EnableWhenExpression>;
-  initialCalculatedExpressions: Record<string, CalculatedExpression>;
-  firstVisibleTab: number;
-  updatedFhirPathContext: Record<string, any>;
-} {
-  const {
-    questionnaireResponse,
-    enableWhenItems,
-    enableWhenExpressions,
-    calculatedExpressions,
-    variablesFhirPath,
-    tabs
-  } = params;
-  let updatedFhirPathContext = params.fhirPathContext;
-
-  const { initialisedItems, linkedQuestions } = assignPopulatedAnswersToEnableWhen(
-    enableWhenItems,
-    questionnaireResponse
-  );
-
-  const evaluateInitialEnableWhenExpressionsResult = evaluateInitialEnableWhenExpressions({
-    initialResponse: questionnaireResponse,
-    enableWhenExpressions: enableWhenExpressions,
-    variablesFhirPath: variablesFhirPath,
-    existingFhirPathContext: updatedFhirPathContext
-  });
-  const { initialEnableWhenExpressions } = evaluateInitialEnableWhenExpressionsResult;
-  updatedFhirPathContext = evaluateInitialEnableWhenExpressionsResult.updatedFhirPathContext;
-
-  const evaluateInitialCalculatedExpressionsResult = evaluateInitialCalculatedExpressions({
-    initialResponse: questionnaireResponse,
-    calculatedExpressions: calculatedExpressions,
-    variablesFhirPath: variablesFhirPath,
-    existingFhirPathContext: updatedFhirPathContext
-  });
-  const { initialCalculatedExpressions } = evaluateInitialCalculatedExpressionsResult;
-  updatedFhirPathContext = evaluateInitialEnableWhenExpressionsResult.updatedFhirPathContext;
-
-  const firstVisibleTab =
-    Object.keys(tabs).length > 0
-      ? getFirstVisibleTab(tabs, initialisedItems, initialEnableWhenExpressions)
-      : 0;
-
-  return {
-    initialEnableWhenItems: initialisedItems,
-    initialEnableWhenLinkedQuestions: linkedQuestions,
-    initialEnableWhenExpressions,
-    initialCalculatedExpressions,
-    firstVisibleTab,
-    updatedFhirPathContext
-  };
-}