@aehrc/smart-forms-renderer 0.6.7 → 0.7.0

package/src/hooks/useTerminologyServerQuery.ts

@@ -16,23 +16,23 @@
  */
 
 import { useQuery } from '@tanstack/react-query';
-import type { Coding, ValueSet } from 'fhir/r4';
-import { getValueSetCodings, getValueSetPromise } from '../utils/valueSet';
+import type { Coding, QuestionnaireItem, ValueSet } from 'fhir/r4';
+import { getTerminologyServerUrl, getValueSetCodings, getValueSetPromise } from '../utils/valueSet';
 
 import type { AlertColor } from '@mui/material/Alert';
 import useQuestionnaireStore from '../stores/useQuestionnaireStore';
+import useTerminologyServerStore from '../stores/useTerminologyServerStore';
 
 function useTerminologyServerQuery(
-  answerValueSetUrl: string | undefined,
+  qItem: QuestionnaireItem,
   maxList: number,
   input: string,
-  searchTerm: string,
-  terminologyServerUrl?: string
+  searchTerm: string
 ): { options: Coding[]; loading: boolean; feedback?: { message: string; color: AlertColor } } {
   const processedValueSetUrls = useQuestionnaireStore((state) => state.processedValueSetUrls);
+  const defaultTerminologyServerUrl = useTerminologyServerStore((state) => state.url);
 
   let fullUrl = '';
-
   let options: Coding[] = [];
   let loading = false;
   let feedback: { message: string; color: AlertColor } | undefined;
@@ -46,6 +46,7 @@ function useTerminologyServerQuery(
   }
 
   // Restructure url to include filter and count parameters
+  let answerValueSetUrl = qItem.answerValueSet;
   if (answerValueSetUrl) {
     if (answerValueSetUrl.startsWith('#')) {
       answerValueSetUrl = answerValueSetUrl.slice(1);
@@ -62,6 +63,7 @@ function useTerminologyServerQuery(
   }
 
   // Perform query
+  const terminologyServerUrl = getTerminologyServerUrl(qItem) ?? defaultTerminologyServerUrl;
   const { isInitialLoading, error, data } = useQuery<ValueSet>(
     ['expandValueSet', fullUrl],
     () => getValueSetPromise(fullUrl, terminologyServerUrl),

package/src/hooks/useValueSetCodings.ts

@@ -28,6 +28,7 @@ import fhirpath from 'fhirpath';
 import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
 import useSmartConfigStore from '../stores/useSmartConfigStore';
 import useQuestionnaireStore from '../stores/useQuestionnaireStore';
+import useTerminologyServerStore from '../stores/useTerminologyServerStore';
 
 function useValueSetCodings(qItem: QuestionnaireItem) {
   const patient = useSmartConfigStore((state) => state.patient);
@@ -40,6 +41,8 @@ function useValueSetCodings(qItem: QuestionnaireItem) {
   const addCodingToCache = useQuestionnaireStore((state) => state.addCodingToCache);
   const { xFhirQueryVariables } = useQuestionnaireStore((state) => state.variables);
 
+  const defaultTerminologyServerUrl = useTerminologyServerStore((state) => state.url);
+
   const valueSetUrl = qItem.answerValueSet;
   let initialCodings = useMemo(() => {
     // set options from cached answer options if present
@@ -127,8 +130,8 @@ function useValueSetCodings(qItem: QuestionnaireItem) {
     const valueSetUrl = qItem.answerValueSet;
     if (!valueSetUrl || codings.length > 0) return;
 
-    const terminologyServer = getTerminologyServerUrl(qItem);
-    const promise = getValueSetPromise(valueSetUrl, terminologyServer);
+    const terminologyServerUrl = getTerminologyServerUrl(qItem) ?? defaultTerminologyServerUrl;
+    const promise = getValueSetPromise(valueSetUrl, terminologyServerUrl);
     if (promise) {
       promise
         .then((valueSet: ValueSet) => {

package/src/stores/useQuestionnaireStore.ts

@@ -38,6 +38,7 @@ import { createQuestionnaireModel } from '../utils/questionnaireStoreUtils/creat
 import { initialiseFormFromResponse } from '../utils/initialiseForm';
 import { emptyQuestionnaire, emptyResponse } from '../utils/emptyResource';
 import cloneDeep from 'lodash.clonedeep';
+import useTerminologyServerStore from './useTerminologyServerStore';
 
 export interface UseQuestionnaireStoreType {
   sourceQuestionnaire: Questionnaire;
@@ -57,7 +58,8 @@ export interface UseQuestionnaireStoreType {
   buildSourceQuestionnaire: (
     questionnaire: Questionnaire,
     questionnaireResponse?: QuestionnaireResponse,
-    additionalVariables?: Record<string, object>
+    additionalVariables?: Record<string, object>,
+    terminologyServerUrl?: string
   ) => Promise<void>;
   destroySourceQuestionnaire: () => void;
   switchTab: (newTabIndex: number) => void;
@@ -87,9 +89,14 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
   buildSourceQuestionnaire: async (
     questionnaire,
     questionnaireResponse = cloneDeep(emptyResponse),
-    additionalVariables = {}
+    additionalVariables = {},
+    terminologyServerUrl = useTerminologyServerStore.getState().url
   ) => {
-    const questionnaireModel = await createQuestionnaireModel(questionnaire, additionalVariables);
+    const questionnaireModel = await createQuestionnaireModel(
+      questionnaire,
+      additionalVariables,
+      terminologyServerUrl
+    );
 
     const {
       initialEnableWhenItems,

package/src/stores/useTerminologyServerStore.ts

@@ -0,0 +1,34 @@
+/*
+ * 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 { create } from 'zustand';
+
+const ONTOSERVER_R4 = 'https://r4.ontoserver.csiro.au/fhir';
+
+export interface UseTerminologyServerStoreType {
+  url: string;
+  setUrl: (newUrl: string) => void;
+  resetUrl: () => void;
+}
+
+const useTerminologyServerStore = create<UseTerminologyServerStoreType>()((set) => ({
+  url: ONTOSERVER_R4,
+  setUrl: (newUrl: string) => set(() => ({ url: newUrl })),
+  resetUrl: () => set(() => ({ url: ONTOSERVER_R4 }))
+}));
+
+export default useTerminologyServerStore;

package/src/theme/overrides/Overrides.ts

@@ -21,7 +21,6 @@ import Input from './Input';
 import Table from './Table';
 import Button from './Button';
 import Backdrop from './Backdrop';
-import Typography from './Typography';
 import Autocomplete from './Autocomplete';
 import Accordion from './Accordion';
 import SpeedDial from './SpeedDial';
@@ -36,7 +35,6 @@ function ComponentsOverrides(theme: Theme) {
     Paper(),
     Button(theme),
     Backdrop(theme),
-    Typography(theme),
     Autocomplete(theme),
     SpeedDial(theme)
   );

package/src/utils/qItem.ts

@@ -32,7 +32,7 @@ interface isHiddenParams {
 /**
  * Test the given QItem on a series of checks to verify if the item should be displayed
  * Check if qItem has hidden attribute
- * Check if qItem fufilled its enableWhen criteria
+ * Check if qItem fulfilled its enableWhen criteria
  *
  * @author Sean Fong
  */

package/src/utils/questionnaireStoreUtils/createQuestionaireModel.ts

@@ -30,7 +30,8 @@ import { addAdditionalVariables } from './addAdditionalVariables';
 
 export async function createQuestionnaireModel(
   questionnaire: Questionnaire,
-  additionalVariables: Record<string, object>
+  additionalVariables: Record<string, object>,
+  terminologyServerUrl: string
 ): Promise<QuestionnaireModel> {
   if (!questionnaire.item) {
     return createEmptyModel();
@@ -43,7 +44,10 @@ export async function createQuestionnaireModel(
   let variables: Variables = extractQuestionnaireLevelVariables(questionnaire);
   variables = addAdditionalVariables(variables, additionalVariables);
 
-  const extractContainedValueSetsResult = extractContainedValueSets(questionnaire);
+  const extractContainedValueSetsResult = extractContainedValueSets(
+    questionnaire,
+    terminologyServerUrl
+  );
   let valueSetPromises = extractContainedValueSetsResult.valueSetPromises;
   let processedValueSetCodings = extractContainedValueSetsResult.processedValueSetCodings;
   const processedValueSetUrls = extractContainedValueSetsResult.processedValueSetUrls;
@@ -51,7 +55,8 @@ export async function createQuestionnaireModel(
   const extractOtherExtensionsResult = extractOtherExtensions(
     questionnaire,
     variables,
-    valueSetPromises
+    valueSetPromises,
+    terminologyServerUrl
   );
 
   const { enableWhenItems, enableWhenExpressions, calculatedExpressions, answerExpressions } =
@@ -62,7 +67,8 @@ export async function createQuestionnaireModel(
   const resolveValueSetsResult = await resolveValueSets(
     variables,
     valueSetPromises,
-    processedValueSetCodings
+    processedValueSetCodings,
+    terminologyServerUrl
   );
 
   variables = resolveValueSetsResult.variables;

package/src/utils/questionnaireStoreUtils/extractContainedValueSets.ts

@@ -19,7 +19,10 @@ import type { ValueSetPromise } from '../../interfaces/valueSet.interface';
 import { getValueSetCodings, getValueSetPromise } from '../valueSet';
 import type { Coding, Questionnaire, ValueSet } from 'fhir/r4';
 
-export function extractContainedValueSets(questionnaire: Questionnaire): {
+export function extractContainedValueSets(
+  questionnaire: Questionnaire,
+  terminologyServerUrl: string
+): {
   processedValueSetCodings: Record<string, Coding[]>;
   processedValueSetUrls: Record<string, string>;
   valueSetPromises: Record<string, ValueSetPromise>;
@@ -47,7 +50,7 @@ export function extractContainedValueSets(questionnaire: Questionnaire): {
     const valueSetUrl = getValueSetUrlFromContained(entry);
     if (valueSetUrl) {
       valueSetPromises[entry.id] = {
-        promise: getValueSetPromise(valueSetUrl)
+        promise: getValueSetPromise(valueSetUrl, terminologyServerUrl)
       };
       continue;
     }

package/src/utils/questionnaireStoreUtils/extractOtherExtensions.ts

@@ -41,7 +41,8 @@ interface ReturnParamsRecursive {
 export function extractOtherExtensions(
   questionnaire: Questionnaire,
   variables: Variables,
-  valueSetPromises: Record<string, ValueSetPromise>
+  valueSetPromises: Record<string, ValueSetPromise>,
+  terminologyServerUrl: string
 ): ReturnParamsRecursive {
   const enableWhenItems: Record<string, EnableWhenItemProperties> = {};
   const enableWhenExpressions: Record<string, EnableWhenExpression> = {};
@@ -67,7 +68,8 @@ export function extractOtherExtensions(
       enableWhenExpressions,
       calculatedExpressions,
       answerExpressions,
-      valueSetPromises
+      valueSetPromises,
+      defaultTerminologyServerUrl: terminologyServerUrl
     });
   }
 
@@ -89,6 +91,7 @@ interface extractExtensionsFromItemRecursiveParams {
   calculatedExpressions: Record<string, CalculatedExpression>;
   answerExpressions: Record<string, AnswerExpression>;
   valueSetPromises: Record<string, ValueSetPromise>;
+  defaultTerminologyServerUrl: string;
 }
 
 function extractExtensionsFromItemRecursive(
@@ -101,7 +104,8 @@ function extractExtensionsFromItemRecursive(
     enableWhenExpressions,
     calculatedExpressions,
     answerExpressions,
-    valueSetPromises
+    valueSetPromises,
+    defaultTerminologyServerUrl
   } = params;
 
   const items = item.item;
@@ -145,7 +149,7 @@ function extractExtensionsFromItemRecursive(
   const valueSetUrl = item.answerValueSet;
   if (valueSetUrl) {
     if (!valueSetPromises[valueSetUrl] && !valueSetUrl.startsWith('#')) {
-      const terminologyServerUrl = getTerminologyServerUrl(item);
+      const terminologyServerUrl = getTerminologyServerUrl(item) ?? defaultTerminologyServerUrl;
       valueSetPromises[valueSetUrl] = {
         promise: getValueSetPromise(valueSetUrl, terminologyServerUrl)
       };

package/src/utils/questionnaireStoreUtils/resolveValueSets.ts

@@ -28,7 +28,8 @@ import type { ValueSetPromise } from '../../interfaces/valueSet.interface';
 export async function resolveValueSets(
   variables: Variables,
   valueSetPromises: Record<string, ValueSetPromise>,
-  processedValueSetCodings: Record<string, Coding[]>
+  processedValueSetCodings: Record<string, Coding[]>,
+  terminologyServerUrl: string
 ): Promise<{ variables: Variables; processedValueSetCodings: Record<string, Coding[]> }> {
   // Create a <valueSetUrl, XFhirQueryVariableName> map
   const valueSetToXFhirQueryVariableNameMap: Record<string, string> =
@@ -37,7 +38,7 @@ export async function resolveValueSets(
   if (Object.keys(valueSetToXFhirQueryVariableNameMap).length > 0) {
     for (const valueSetUrl in valueSetToXFhirQueryVariableNameMap) {
       valueSetPromises[valueSetUrl] = {
-        promise: getValueSetPromise(valueSetUrl)
+        promise: getValueSetPromise(valueSetUrl, terminologyServerUrl)
       };
     }
   }

package/src/utils/tabs.ts

@@ -19,7 +19,7 @@ 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 { isHiddenByEnableWhens } from './qItem';
+import { isHidden, isHiddenByEnableWhens } from './qItem';
 
 export function getFirstVisibleTab(
   tabs: Tabs,
@@ -253,3 +253,56 @@ export function getContextDisplays(item: QuestionnaireItem): QuestionnaireItem[]
       isSpecificItemControl(childItem, 'context-display') && childItem.type === 'display'
   );
 }
+
+interface IsTabHiddenParams {
+  qItem: QuestionnaireItem;
+  contextDisplayItems: QuestionnaireItem[];
+  isTab: boolean;
+  enableWhenIsActivated: boolean;
+  enableWhenItems: EnableWhenItems;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+  completedTabsCollapsed: boolean;
+}
+
+export function isTabHidden(params: IsTabHiddenParams): boolean {
+  const {
+    qItem,
+    contextDisplayItems,
+    isTab,
+    enableWhenIsActivated,
+    enableWhenItems,
+    enableWhenExpressions,
+    completedTabsCollapsed
+  } = params;
+
+  if (
+    !isTab ||
+    isHidden({
+      questionnaireItem: qItem,
+      enableWhenIsActivated,
+      enableWhenItems,
+      enableWhenExpressions
+    })
+  ) {
+    return true;
+  }
+
+  if (completedTabsCollapsed) {
+    const completedDisplayItem = contextDisplayItems.find(
+      (contextDisplayItem) => contextDisplayItem.text === 'Complete'
+    );
+    if (
+      completedDisplayItem &&
+      !isHidden({
+        questionnaireItem: completedDisplayItem,
+        enableWhenIsActivated,
+        enableWhenItems,
+        enableWhenExpressions
+      })
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/utils/valueSet.ts

@@ -35,7 +35,6 @@ const VALID_VALUE_SET_URL_REGEX =
   /https?:\/\/(www\.)?[-\w@:%.+~#=]{2,256}\.[a-z]{2,4}\b([-@\w:%+.~#?&/=]*ValueSet[-@\w:%+.~#?&/=]*)/;
 
 const VALID_FHIRPATH_VARIABLE_REGEX = /%(.*?)\./;
-const ONTOSERVER_ENDPOINT = 'https://r4.ontoserver.csiro.au/fhir/';
 
 export function getTerminologyServerUrl(qItem: QuestionnaireItem): string | undefined {
   const itemControl = qItem.extension?.find(
@@ -48,18 +47,18 @@ export function getTerminologyServerUrl(qItem: QuestionnaireItem): string | unde
   return undefined;
 }
 
-export function getValueSetPromise(url: string, terminologyServer?: string): Promise<ValueSet> {
+export function getValueSetPromise(url: string, terminologyServerUrl: string): Promise<ValueSet> {
   let valueSetUrl = url;
 
   if (url.includes('ValueSet/$expand?url=')) {
     const splitUrl = url.split('ValueSet/$expand?url=');
-    terminologyServer = splitUrl[0];
+    terminologyServerUrl = splitUrl[0];
     valueSetUrl = splitUrl[1];
   }
 
   valueSetUrl = valueSetUrl.replace('|', '&version=');
 
-  return FHIR.client({ serverUrl: terminologyServer ?? ONTOSERVER_ENDPOINT }).request({
+  return FHIR.client({ serverUrl: terminologyServerUrl }).request({
     url: 'ValueSet/$expand?url=' + valueSetUrl
   });
 }