@aehrc/smart-forms-renderer 0.3.0 → 0.5.0

package/src/utils/questionnaireStoreUtils/extractOtherExtensions.ts

@@ -0,0 +1,239 @@
+/*
+ * 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 { Expression, Extension, Questionnaire, QuestionnaireItem } from 'fhir/r4';
+import type { CalculatedExpression } from '../../interfaces/calculatedExpression.interface';
+import type {
+  EnableWhenExpression,
+  EnableWhenItemProperties,
+  EnableWhenLinkedItem
+} from '../../interfaces/enableWhen.interface';
+import type { AnswerExpression } from '../../interfaces/answerExpression.interface';
+import type { ValueSetPromise } from '../../interfaces/valueSet.interface';
+import { getAnswerExpression } from '../itemControl';
+import { getTerminologyServerUrl, getValueSetPromise } from '../valueSet';
+import type { Variables } from '../../interfaces/variables.interface';
+import { getFhirPathVariables, getXFhirQueryVariables } from './extractVariables';
+
+interface ReturnParamsRecursive {
+  variables: Variables;
+  enableWhenItems: Record<string, EnableWhenItemProperties>;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+  calculatedExpressions: Record<string, CalculatedExpression>;
+  answerExpressions: Record<string, AnswerExpression>;
+  valueSetPromises: Record<string, ValueSetPromise>;
+}
+
+export function extractOtherExtensions(
+  questionnaire: Questionnaire,
+  variables: Variables,
+  valueSetPromises: Record<string, ValueSetPromise>
+): ReturnParamsRecursive {
+  const enableWhenItems: Record<string, EnableWhenItemProperties> = {};
+  const enableWhenExpressions: Record<string, EnableWhenExpression> = {};
+  const calculatedExpressions: Record<string, CalculatedExpression> = {};
+  const answerExpressions: Record<string, AnswerExpression> = {};
+
+  if (!questionnaire.item || questionnaire.item.length === 0) {
+    return {
+      variables: variables,
+      enableWhenItems: {},
+      enableWhenExpressions: {},
+      calculatedExpressions: {},
+      answerExpressions: {},
+      valueSetPromises: valueSetPromises
+    };
+  }
+
+  for (const topLevelItem of questionnaire.item) {
+    extractExtensionsFromItemRecursive({
+      item: topLevelItem,
+      variables,
+      enableWhenItems,
+      enableWhenExpressions,
+      calculatedExpressions,
+      answerExpressions,
+      valueSetPromises
+    });
+  }
+
+  return {
+    variables,
+    enableWhenItems,
+    enableWhenExpressions,
+    calculatedExpressions,
+    answerExpressions,
+    valueSetPromises
+  };
+}
+
+interface extractExtensionsFromItemRecursiveParams {
+  item: QuestionnaireItem;
+  variables: Variables;
+  enableWhenItems: Record<string, EnableWhenItemProperties>;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+  calculatedExpressions: Record<string, CalculatedExpression>;
+  answerExpressions: Record<string, AnswerExpression>;
+  valueSetPromises: Record<string, ValueSetPromise>;
+}
+
+function extractExtensionsFromItemRecursive(
+  params: extractExtensionsFromItemRecursiveParams
+): ReturnParamsRecursive {
+  const {
+    item,
+    variables,
+    enableWhenItems,
+    enableWhenExpressions,
+    calculatedExpressions,
+    answerExpressions,
+    valueSetPromises
+  } = params;
+
+  const items = item.item;
+  if (items && items.length > 0) {
+    // iterate through items of item recursively
+    for (const childItem of items) {
+      extractExtensionsFromItemRecursive({
+        ...params,
+        item: childItem
+      });
+    }
+  }
+
+  // Read enable when items, enablehen/calculated/answer expressions, valueSets and variables from qItem
+  const enableWhenItemProperties = getEnableWhenItemProperties(item);
+  if (enableWhenItemProperties) {
+    enableWhenItems[item.linkId] = enableWhenItemProperties;
+  }
+
+  const enableWhenExpression = getEnableWhenExpression(item);
+  if (enableWhenExpression) {
+    enableWhenExpressions[item.linkId] = {
+      expression: `${enableWhenExpression.expression}`
+    };
+  }
+
+  const calculatedExpression = getCalculatedExpression(item);
+  if (calculatedExpression) {
+    calculatedExpressions[item.linkId] = {
+      expression: `${calculatedExpression.expression}`
+    };
+  }
+
+  const answerExpression = getAnswerExpression(item);
+  if (answerExpression) {
+    answerExpressions[item.linkId] = {
+      expression: `${answerExpression.expression}`
+    };
+  }
+
+  const valueSetUrl = item.answerValueSet;
+  if (valueSetUrl) {
+    if (!valueSetPromises[valueSetUrl] && !valueSetUrl.startsWith('#')) {
+      const terminologyServerUrl = getTerminologyServerUrl(item);
+      valueSetPromises[valueSetUrl] = {
+        promise: getValueSetPromise(valueSetUrl, terminologyServerUrl)
+      };
+    }
+  }
+
+  if (item.extension) {
+    variables.fhirPathVariables[item.linkId] = getFhirPathVariables(item.extension);
+
+    for (const expression of getXFhirQueryVariables(item.extension)) {
+      if (expression.name) {
+        variables.xFhirQueryVariables[expression.name] = {
+          valueExpression: expression
+        };
+      }
+    }
+  }
+
+  return {
+    variables,
+    enableWhenItems,
+    enableWhenExpressions,
+    calculatedExpressions,
+    answerExpressions,
+    valueSetPromises
+  };
+}
+
+/**
+ * Get enableWhen items' linked items and enableBehaviour attribute and save them in an EnableWhenItemProperties object
+ *
+ * @author Sean Fong
+ */
+export function getEnableWhenItemProperties(
+  qItem: QuestionnaireItem
+): EnableWhenItemProperties | null {
+  const enableWhen = qItem.enableWhen;
+  if (enableWhen) {
+    const enableWhenItemProperties: EnableWhenItemProperties = { linked: [], isEnabled: false };
+    enableWhenItemProperties.linked = enableWhen.map((linkedItem): EnableWhenLinkedItem => {
+      return { enableWhen: linkedItem };
+    });
+
+    if (qItem.enableBehavior) {
+      enableWhenItemProperties.enableBehavior = qItem.enableBehavior;
+    }
+
+    return enableWhenItemProperties;
+  }
+  return null;
+}
+
+/**
+ * Check if an enableWhenExpression extension is present
+ *
+ * @author Sean Fong
+ */
+export function getEnableWhenExpression(qItem: QuestionnaireItem): Expression | null {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url ===
+        'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-enableWhenExpression' &&
+      extension.valueExpression?.language === 'text/fhirpath'
+  );
+  if (itemControl) {
+    if (itemControl.valueExpression) {
+      return itemControl.valueExpression;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if an calculatedExpression extension is present
+ *
+ * @author Sean Fong
+ */
+export function getCalculatedExpression(qItem: QuestionnaireItem): Expression | null {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url ===
+        'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-calculatedExpression' &&
+      extension.valueExpression?.language === 'text/fhirpath'
+  );
+  if (itemControl) {
+    if (itemControl.valueExpression) {
+      return itemControl.valueExpression;
+    }
+  }
+  return null;
+}

package/src/utils/questionnaireStoreUtils/extractTabs.ts

@@ -0,0 +1,37 @@
+/*
+ * 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 { constructTabsWithProperties, isTabContainer } from '../tabs';
+import type { Questionnaire } from 'fhir/r4';
+import type { Tabs } from '../../interfaces/tab.interface';
+
+export function extractTabs(questionnaire: Questionnaire): Tabs {
+  if (!questionnaire.item || questionnaire.item.length === 0) {
+    return {};
+  }
+
+  let totalTabs = {};
+  for (const topLevelItem of questionnaire.item) {
+    const items = topLevelItem.item;
+    const topLevelItemIsTabContainer = isTabContainer(topLevelItem);
+
+    const tabs = constructTabsWithProperties(items, topLevelItemIsTabContainer);
+    totalTabs = { ...totalTabs, ...tabs };
+  }
+
+  return totalTabs;
+}

package/src/utils/questionnaireStoreUtils/extractVariables.ts

@@ -0,0 +1,77 @@
+/*
+ * 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 { Expression, Extension, Questionnaire } from 'fhir/r4';
+import type { Variables } from '../../interfaces/variables.interface';
+
+export function extractQuestionnaireLevelVariables(questionnaire: Questionnaire): Variables {
+  const variables: Variables = { fhirPathVariables: {}, xFhirQueryVariables: {} };
+
+  variables.fhirPathVariables['QuestionnaireLevel'] = [];
+
+  if (!questionnaire.extension || questionnaire.extension.length === 0) {
+    return variables;
+  }
+
+  variables.fhirPathVariables['QuestionnaireLevel'] = getFhirPathVariables(questionnaire.extension);
+
+  for (const exp of getXFhirQueryVariables(questionnaire.extension)) {
+    if (exp.name) {
+      variables.xFhirQueryVariables[exp.name] = {
+        valueExpression: exp
+      };
+    }
+  }
+
+  return variables;
+}
+
+/**
+ * Get fhirpath variables from an array of extensions
+ *
+ * @author Sean Fong
+ */
+export function getFhirPathVariables(extensions: Extension[]): Expression[] {
+  return (
+    extensions
+      .filter(
+        (extension) =>
+          extension.url === 'http://hl7.org/fhir/StructureDefinition/variable' &&
+          extension.valueExpression?.language === 'text/fhirpath'
+      )
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      .map((extension) => extension.valueExpression!)
+  );
+}
+
+/**
+ * Get x-fhir-query variables from an array of extensions
+ *
+ * @author Sean Fong
+ */
+export function getXFhirQueryVariables(extensions: Extension[]): Expression[] {
+  return (
+    extensions
+      .filter(
+        (extension) =>
+          extension.url === 'http://hl7.org/fhir/StructureDefinition/variable' &&
+          extension.valueExpression?.language === 'application/x-fhir-query'
+      )
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      .map((extension) => extension.valueExpression!)
+  );
+}

package/src/utils/questionnaireStoreUtils/resolveValueSets.ts

@@ -0,0 +1,68 @@
+/*
+ * 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 { Coding } from 'fhir/r4';
+import {
+  createValueSetToXFhirQueryVariableNameMap,
+  getValueSetCodings,
+  getValueSetPromise,
+  resolvePromises
+} from '../valueSet';
+import type { Variables } from '../../interfaces/variables.interface';
+import type { ValueSetPromise } from '../../interfaces/valueSet.interface';
+
+export async function resolveValueSets(
+  variables: Variables,
+  valueSetPromises: Record<string, ValueSetPromise>,
+  processedValueSetCodings: Record<string, Coding[]>
+): Promise<{ variables: Variables; processedValueSetCodings: Record<string, Coding[]> }> {
+  // Create a <valueSetUrl, XFhirQueryVariableName> map
+  const valueSetToXFhirQueryVariableNameMap: Record<string, string> =
+    createValueSetToXFhirQueryVariableNameMap(variables.xFhirQueryVariables);
+
+  if (Object.keys(valueSetToXFhirQueryVariableNameMap).length > 0) {
+    for (const valueSetUrl in valueSetToXFhirQueryVariableNameMap) {
+      valueSetPromises[valueSetUrl] = {
+        promise: getValueSetPromise(valueSetUrl)
+      };
+    }
+  }
+
+  // Resolve promises and store valueSet codings in preprocessedValueSetCodings AND XFhirQueryVariables
+  const resolvedPromises = await resolvePromises(valueSetPromises);
+
+  for (const valueSetUrl in resolvedPromises) {
+    const valueSet = resolvedPromises[valueSetUrl].valueSet;
+
+    if (valueSet) {
+      if (valueSetToXFhirQueryVariableNameMap[valueSetUrl]) {
+        // valueSetUrl is in x-fhir-query variables, save to variable
+        const variableName = valueSetToXFhirQueryVariableNameMap[valueSetUrl];
+        const variable = variables.xFhirQueryVariables[variableName];
+        variables.xFhirQueryVariables[variableName] = {
+          ...variable,
+          result: resolvedPromises[valueSetUrl].valueSet
+        };
+      } else {
+        // valueSetUrl is in x-fhir-query variables, save to preprocessedValueSetCodings
+        processedValueSetCodings[valueSetUrl] = getValueSetCodings(valueSet);
+      }
+    }
+  }
+
+  return { variables, processedValueSetCodings };
+}

package/src/utils/removeHidden.ts

@@ -0,0 +1,162 @@
+/*
+ * 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 {
+  Questionnaire,
+  QuestionnaireItem,
+  QuestionnaireResponse,
+  QuestionnaireResponseItem
+} from 'fhir/r4';
+import {
+  EnableWhenExpression,
+  EnableWhenItems
+} from 'smart-forms-app/src/types/enableWhen.interface';
+import { isHidden } from './qItem';
+
+interface removeHiddenAnswersParams {
+  questionnaire: Questionnaire;
+  questionnaireResponse: QuestionnaireResponse;
+  enableWhenIsActivated: boolean;
+  enableWhenItems: EnableWhenItems;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+}
+
+/**
+ * Recursively go through the questionnaireResponse and remove qrItems whose qItems are hidden in the form
+ *
+ * @author Sean Fong
+ */
+export function removeHiddenAnswers(params: removeHiddenAnswersParams): QuestionnaireResponse {
+  const {
+    questionnaire,
+    questionnaireResponse,
+    enableWhenIsActivated,
+    enableWhenItems,
+    enableWhenExpressions
+  } = params;
+
+  const topLevelQItems = questionnaire.item;
+  const topLevelQRItems = questionnaireResponse.item;
+  if (
+    !topLevelQItems ||
+    topLevelQItems.length === 0 ||
+    !topLevelQRItems ||
+    topLevelQRItems.length === 0
+  ) {
+    return questionnaireResponse;
+  }
+
+  topLevelQRItems.forEach((qrItem, i) => {
+    const qItem = topLevelQItems[i];
+    const newTopLevelQRItem = readQuestionnaireResponseItemRecursive({
+      qItem,
+      qrItem,
+      enableWhenIsActivated,
+      enableWhenItems,
+      enableWhenExpressions
+    });
+    if (newTopLevelQRItem && questionnaireResponse.item) {
+      questionnaireResponse.item[i] = { ...newTopLevelQRItem };
+    }
+  });
+
+  return questionnaireResponse;
+}
+
+interface readQuestionnaireResponseItemRecursiveParams {
+  qItem: QuestionnaireItem;
+  qrItem: QuestionnaireResponseItem;
+  enableWhenIsActivated: boolean;
+  enableWhenItems: EnableWhenItems;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+}
+
+function readQuestionnaireResponseItemRecursive(
+  params: readQuestionnaireResponseItemRecursiveParams
+): QuestionnaireResponseItem | null {
+  const { qItem, qrItem, enableWhenIsActivated, enableWhenItems, enableWhenExpressions } = params;
+
+  const qItems = qItem.item;
+  const qrItems = qrItem.item;
+
+  // Process group items
+  if (qItems && qItems.length > 0) {
+    // Return nothing if corresponding qItem is hidden
+    if (
+      isHidden({
+        questionnaireItem: qItem,
+        enableWhenIsActivated,
+        enableWhenItems,
+        enableWhenExpressions
+      })
+    )
+      return null;
+
+    if (qrItems && qrItems.length > 0) {
+      const newQrItems: QuestionnaireResponseItem[] = [];
+
+      // Loop over qItems - but end loop if we either reach the end of qItems or qrItems
+      // Under normal circumstances we will reach the end of both arrays together
+      for (
+        let qItemIndex = 0, qrItemIndex = 0;
+        qItemIndex < qItems.length || qrItemIndex < qrItems.length;
+        qItemIndex++
+      ) {
+        // Save qrItem if linkIds of current qItem and qrItem are the same
+        if (qrItems[qrItemIndex] && qItems[qItemIndex].linkId === qrItems[qrItemIndex].linkId) {
+          const newQrItem = readQuestionnaireResponseItemRecursive({
+            qItem: qItems[qItemIndex],
+            qrItem: qrItems[qrItemIndex],
+            enableWhenIsActivated,
+            enableWhenItems,
+            enableWhenExpressions
+          });
+
+          if (newQrItem) {
+            newQrItems.push(newQrItem);
+          }
+
+          // Decrement qItem index if the next qrItem is an answer from a repeatGroup
+          // Essentially persisting the current qItem linked to be matched up with the next qrItem linkId
+          if (
+            qrItems.length !== qrItemIndex + 1 &&
+            qrItems[qrItemIndex].linkId === qrItems[qrItemIndex + 1].linkId
+          ) {
+            qItemIndex--;
+          }
+
+          // Only Increment qrItem index whenever the current qrItem linkId matches up with the current qItem
+          qrItemIndex++;
+        }
+      }
+      return { ...qrItem, item: newQrItems };
+    }
+
+    // Also perform checking if answer exists
+    return qrItem['answer'] ? qrItem : null;
+  }
+
+  // Process non-group items
+  return isHidden({
+    questionnaireItem: qItem,
+    enableWhenIsActivated,
+    enableWhenItems,
+    enableWhenExpressions
+  })
+    ? null
+    : { ...qrItem };
+}