@aehrc/smart-forms-renderer 0.37.2 → 0.38.4

package/src/utils/calculatedExpression.ts

@@ -34,7 +34,7 @@ import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
 import { updateQrItemsInGroup } from './qrItem';
 import cloneDeep from 'lodash.clonedeep';
 import dayjs from 'dayjs';
-import { updateQuestionnaireResponse } from './updateQr';
+import { updateQuestionnaireResponse } from './genericRecursive';
 
 interface EvaluateInitialCalculatedExpressionsParams {
   initialResponse: QuestionnaireResponse;
@@ -323,7 +323,11 @@ function parseValueToAnswer(qItem: QuestionnaireItem, value: any): Questionnaire
     }
   }
 
-  if (typeof value === 'object') {
+  if (typeof value === 'object' && value.unit) {
+    return { valueQuantity: value };
+  }
+
+  if (typeof value === 'object' && value.system && value.code) {
     return { valueCoding: value };
   }
 

package/src/utils/{updateQr.ts → genericRecursive.ts}

@@ -24,7 +24,7 @@ import type {
 import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
 import { qrItemHasItemsOrAnswer } from './manageForm';
 
-export type RepopulateFunction<T> = (
+export type RecursiveUpdateFunction<T> = (
   qItem: QuestionnaireItem,
   qrItemOrItems: QuestionnaireResponseItem | QuestionnaireResponseItem[] | null,
   extraData: T
@@ -39,7 +39,7 @@ export type RepopulateFunction<T> = (
 export function updateQuestionnaireResponse<T>(
   questionnaire: Questionnaire,
   questionnaireResponse: QuestionnaireResponse,
-  recursiveUpdateFunction: RepopulateFunction<T>,
+  recursiveUpdateFunction: RecursiveUpdateFunction<T>,
   extraData: T
 ) {
   if (
@@ -86,3 +86,48 @@ export function updateQuestionnaireResponse<T>(
 
   return { ...questionnaireResponse, item: topLevelQrItems };
 }
+
+export type RecursiveReadArrayFunction<T> = (
+  qItem: QuestionnaireItem,
+  qrItemOrItems: QuestionnaireResponseItem | QuestionnaireResponseItem[] | null
+) => T[] | null;
+
+/**
+ * A generic (and safe) way to read an array of element(s) i.e. QuestionnaireResponseItem[], extracted Observation[] from a QuestionnaireResponse given a recursive function.
+ * This function relies heavily on mapQItemsIndex() and getQrItemsIndex() to accurately pinpoint the locations of QR items based on their positions in the Q, taking into account repeating group answers, non-filled questions, etc
+ *
+ * @author Sean Fong
+ */
+export function readQuestionnaireResponse<T>(
+  questionnaire: Questionnaire,
+  questionnaireResponse: QuestionnaireResponse,
+  recursiveReadFunction: RecursiveReadArrayFunction<T>
+): T[] {
+  if (!questionnaire.item || questionnaire.item.length === 0) {
+    return [];
+  }
+
+  const qItemsIndexMap = mapQItemsIndex(questionnaire);
+  const topLevelQRItemsByIndex = getQrItemsIndex(
+    questionnaire.item,
+    questionnaireResponse.item ?? [],
+    qItemsIndexMap
+  );
+
+  const readValueArray = [];
+  for (const [index, topLevelQItem] of questionnaire.item.entries()) {
+    const topLevelQRItemOrItems = topLevelQRItemsByIndex[index] ?? {
+      linkId: topLevelQItem.linkId,
+      text: topLevelQItem.text,
+      item: []
+    };
+
+    const readValue = recursiveReadFunction(topLevelQItem, topLevelQRItemOrItems);
+
+    if (readValue) {
+      readValueArray.push(...readValue);
+    }
+  }
+
+  return readValueArray;
+}

package/src/utils/initialise.ts

@@ -34,6 +34,8 @@ import { assignPopulatedAnswersToEnableWhen } from './enableWhen';
 import type { CalculatedExpression } from '../interfaces/calculatedExpression.interface';
 import { evaluateInitialCalculatedExpressions } from './calculatedExpression';
 import { createQuestionnaireResponseItemMap } from './questionnaireResponseStoreUtils/updatableResponseItems';
+import { readQuestionnaireResponse } from './genericRecursive';
+import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
 
 /**
  * Initialise a questionnaireResponse from a given questionnaire
@@ -58,7 +60,11 @@ export function initialiseQuestionnaireResponse(
 
   const firstTopLevelItem = questionnaire?.item?.[0];
   if (firstTopLevelItem && !questionnaireResponse.item) {
-    const initialItems = readItemInitialValues(questionnaire);
+    const initialItems = readQuestionnaireResponse(
+      questionnaire,
+      questionnaireResponse,
+      readInitialValuesRecursive
+    );
 
     if (initialItems && initialItems.length > 0) {
       questionnaireResponse.item = initialItems;
@@ -97,77 +103,81 @@ function createQuestionnaireReference(questionnaire: Questionnaire) {
   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 {
+function readInitialValuesRecursive(
+  qItem: QuestionnaireItem,
+  qrItemOrItems: QuestionnaireResponseItem | QuestionnaireResponseItem[] | null
+): QuestionnaireResponseItem[] | null {
+  // Process items with child items
+  const initialValues: QuestionnaireResponseItem[] = [];
   const childQItems = qItem.item;
   if (childQItems && childQItems.length > 0) {
-    // TODO No support for multiple rows at the moment
+    // Process repeating group items separately
     if (qItem.type === 'group' && qItem.repeats) {
-      const initialItemsFromRepeatGroup = getInitialValueAnswersFromRepeatGroup(qItem);
-      return createNewRepeatGroupQuestionnaireResponseItem(qItem, initialItemsFromRepeatGroup);
+      const initialItemsFromRepeatGroup = getInitialValueAnswersFromRepeatGroup(
+        qItem,
+        qrItemOrItems
+      );
+      const newRepeatGroupQuestionnaireResponseItem = createNewRepeatGroupQuestionnaireResponseItem(
+        qItem,
+        initialItemsFromRepeatGroup
+      );
+
+      return newRepeatGroupQuestionnaireResponseItem
+        ? [newRepeatGroupQuestionnaireResponseItem]
+        : null;
     }
 
-    const initialQRItems: QuestionnaireResponseItem[] = [];
-    for (const childQItem of childQItems) {
-      const initialChildQRItemOrItems = readItemInitialValueRecursive(childQItem);
-
-      if (Array.isArray(initialChildQRItemOrItems)) {
-        if (initialChildQRItemOrItems.length > 0) {
-          initialQRItems.push(...initialChildQRItemOrItems);
-        }
-        continue;
+    // Map qrItemOrItems into an array of qrItems
+    let childQrItems: QuestionnaireResponseItem[] = [];
+    if (qrItemOrItems) {
+      if (Array.isArray(qrItemOrItems)) {
+        childQrItems = qrItemOrItems;
+      } else {
+        childQrItems = qrItemOrItems.item ?? [];
       }
+    }
+
+    const indexMap = mapQItemsIndex(qItem);
+    const qrItemsByIndex = getQrItemsIndex(childQItems, childQrItems, indexMap);
+
+    for (const [index, childQItem] of childQItems.entries()) {
+      const childQRItemOrItems = qrItemsByIndex[index];
 
-      if (initialChildQRItemOrItems) {
-        initialQRItems.push(initialChildQRItemOrItems);
+      const childInitialValues = readInitialValuesRecursive(childQItem, childQRItemOrItems ?? null);
+
+      if (childInitialValues) {
+        initialValues.push(...childInitialValues);
       }
     }
+  }
 
-    let qrItem = createNewQuestionnaireResponseItem(qItem, getInitialValueAnswers(qItem));
+  // Create new qrItem for items with initial values
+  let qrItem = createNewQuestionnaireResponseItem(qItem, getInitialValueAnswers(qItem));
 
-    if (initialQRItems.length > 0) {
-      if (!qrItem) {
-        qrItem = {
-          linkId: qItem.linkId,
-          text: qItem.text
-        };
-      }
-      qrItem.item = initialQRItems;
+  if (initialValues.length > 0) {
+    if (!qrItem) {
+      qrItem = {
+        linkId: qItem.linkId,
+        text: qItem.text
+      };
     }
+    qrItem.item = initialValues;
+  }
 
-    return qrItem;
+  return qrItem ? [qrItem] : null;
+}
+
+function getInitialValueAnswersFromRepeatGroup(
+  qItem: QuestionnaireItem,
+  qrItemOrItems: QuestionnaireResponseItem | QuestionnaireResponseItem[] | null
+) {
+  if (!qItem.item) {
+    return [];
   }
 
-  return createNewQuestionnaireResponseItem(qItem, getInitialValueAnswers(qItem));
+  return qItem.item
+    .flatMap((childQItem) => readInitialValuesRecursive(childQItem, qrItemOrItems))
+    .filter((childQRItem): childQRItem is QuestionnaireResponseItem => !!childQRItem);
 }
 
 function getInitialValueAnswers(qItem: QuestionnaireItem): QuestionnaireResponseItemAnswer[] {
@@ -210,22 +220,6 @@ function getInitialValueAnswers(qItem: QuestionnaireItem): QuestionnaireResponse
     .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);
-}
-
 export function parseItemInitialToAnswer(
   initial: QuestionnaireItemInitial
 ): QuestionnaireResponseItemAnswer | null {

package/src/utils/itemControl.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import type { Coding, Extension, QuestionnaireItem } from 'fhir/r4';
+import type { Coding, Extension, QuestionnaireItem, QuestionnaireItemAnswerOption } from 'fhir/r4';
 import type { RegexValidation } from '../interfaces/regex.interface';
 import { structuredDataCapture } from 'fhir-sdc-helpers';
 
@@ -234,6 +234,24 @@ export function getTextDisplayPrompt(qItem: QuestionnaireItem): string {
   return '';
 }
 
+/**
+ * Get Quantity unit for items with itemControlCode unit and has a unit childItem
+ *
+ * @author Sean Fong
+ */
+export function getQuantityUnit(qItem: QuestionnaireItem): QuestionnaireItemAnswerOption | null {
+  // Otherwise, check if the item has a unit extension
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/StructureDefinition/questionnaire-unit'
+  );
+  if (itemControl && itemControl.valueCoding) {
+    return itemControl;
+  }
+
+  return null;
+}
+
 /**
  * Get decimal text display unit for items with itemControlCode unit and has a unit childItem
  *

package/src/utils/quantity.ts

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2024 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,
+  QuestionnaireItemAnswerOption,
+  QuestionnaireResponseItemAnswer
+} from 'fhir/r4';
+import { parseDecimalStringToFloat } from './parseInputs';
+
+export const quantityComparators: Quantity['comparator'][] = ['<', '<=', '>=', '>'];
+
+export function stringIsComparator(str: string | undefined): str is Quantity['comparator'] {
+  return str === '<' || str === '<=' || str === '>=' || str === '>';
+}
+
+export function createQuantityItemAnswer(
+  precision: number | null,
+  parsedNewInput: string,
+  comparatorInput: Quantity['comparator'] | null,
+  unitInput: QuestionnaireItemAnswerOption | null
+): QuestionnaireResponseItemAnswer[] {
+  if (precision) {
+    return [
+      {
+        valueQuantity: {
+          value: parseDecimalStringToFloat(parsedNewInput, precision),
+          comparator: comparatorInput ?? undefined,
+          unit: unitInput?.valueCoding?.display,
+          system: unitInput?.valueCoding?.system,
+          code: unitInput?.valueCoding?.code
+        }
+      }
+    ];
+  }
+
+  return [
+    {
+      valueQuantity: {
+        value: parseFloat(parsedNewInput),
+        comparator: comparatorInput ?? undefined,
+        unit: unitInput?.valueCoding?.display,
+        system: unitInput?.valueCoding?.system,
+        code: unitInput?.valueCoding?.code
+      }
+    }
+  ];
+}

package/src/utils/repopulateIntoResponse.ts

@@ -3,7 +3,7 @@ import type { ItemToRepopulate } from './repopulateItems';
 import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
 import { isSpecificItemControl } from './itemControl';
 import { questionnaireResponseStore, questionnaireStore } from '../stores';
-import { updateQuestionnaireResponse } from './updateQr';
+import { updateQuestionnaireResponse } from './genericRecursive';
 
 /**
  * Re-populate checked items in the re-population dialog into the current QuestionnaireResponse

package/src/utils/valueSet.ts

@@ -29,7 +29,7 @@ import type {
 import * as FHIR from 'fhirclient';
 import type { FhirResourceString } from '../interfaces/populate.interface';
 import type { VariableXFhirQuery } from '../interfaces/variables.interface';
-import type { ValueSetPromise } from '../interfaces/valueSet.interface';
+import type { ValidateCodeResponse, ValueSetPromise } from '../interfaces/valueSet.interface';
 
 const VALID_VALUE_SET_URL_REGEX =
   /https?:\/\/(www\.)?[-\w@:%.+~#=]{2,256}\.[a-z]{2,4}\b([-@\w:%+.~#?&/=]*ValueSet[-@\w:%+.~#?&/=]*)/;
@@ -65,6 +65,37 @@ export function getValueSetPromise(url: string, terminologyServerUrl: string): P
   });
 }
 
+function validateCodeResponseIsValid(response: any): response is ValidateCodeResponse {
+  return (
+    response &&
+    response.resourceType === 'Parameters' &&
+    response.parameter &&
+    response.parameter.find((p: any) => p.name === 'code') &&
+    response.parameter.find((p: any) => p.name === 'code').valueCode &&
+    response.parameter.find((p: any) => p.name === 'system') &&
+    response.parameter.find((p: any) => p.name === 'system').valueUri &&
+    response.parameter.find((p: any) => p.name === 'display') &&
+    response.parameter.find((p: any) => p.name === 'display').valueString
+  );
+}
+
+export async function validateCodePromise(
+  url: string,
+  system: string,
+  code: string,
+  terminologyServerUrl: string
+): Promise<ValidateCodeResponse | null> {
+  const validateCodeResponse = await FHIR.client({ serverUrl: terminologyServerUrl }).request({
+    url: `ValueSet/$validate-code?url=${url}&system=${system}&code=${code}`
+  });
+
+  if (validateCodeResponse && validateCodeResponseIsValid(validateCodeResponse)) {
+    return validateCodeResponse;
+  }
+
+  return null;
+}
+
 async function addTimeoutToPromise(promise: Promise<any>, timeoutMs: number) {
   const timeoutPromise = new Promise((_, reject) => {
     setTimeout(() => {