@aehrc/smart-forms-renderer 0.3.0 → 0.5.0

package/src/utils/itemControl.ts

@@ -0,0 +1,367 @@
+/*
+ * 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,
+  Expression,
+  Extension,
+  QuestionnaireItem,
+  QuestionnaireResponse
+} from 'fhir/r4';
+import type { RegexValidation } from '../interfaces/regex.interface';
+
+/**
+ * Check if the extension has an itemControl code equal to the given itemControlCode
+ *
+ * @author Sean Fong
+ */
+export function isSpecificItemControl(qItem: QuestionnaireItem, itemControlCode: string): boolean {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/StructureDefinition/questionnaire-itemControl'
+  );
+  if (itemControl) {
+    const code = itemControl.valueCodeableConcept?.coding?.find(
+      (coding: Coding) => coding.code === itemControlCode
+    );
+    if (code) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if the extension has an displayCategory code equal to the given displayCategory
+ *
+ * @author Sean Fong
+ */
+export function isSpecificDisplayCategory(
+  qItem: QuestionnaireItem,
+  itemControlCode: string
+): boolean {
+  const displayCategory = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/StructureDefinition/questionnaire-displayCategory'
+  );
+  if (displayCategory) {
+    const code = displayCategory.valueCodeableConcept?.coding?.find(
+      (coding: Coding) => coding.code === itemControlCode
+    );
+    if (code) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if the extension has url for items that use shortText
+ *
+ * @author Sean Fong
+ */
+export function getShortText(qItem: QuestionnaireItem): string | null {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-shortText'
+  );
+  if (itemControl) {
+    if (itemControl.valueString) {
+      return itemControl.valueString;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if the extension has url for hidden questions
+ *
+ * @author Sean Fong
+ */
+export function hasHiddenExtension(qItem: QuestionnaireItem): boolean {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/StructureDefinition/questionnaire-hidden'
+  );
+
+  if (itemControl) {
+    if (itemControl.valueBoolean) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if an answerExpression extension is present
+ *
+ * @author Sean Fong
+ */
+export function getAnswerExpression(qItem: QuestionnaireItem): Expression | null {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url ===
+        'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-answerExpression' &&
+      extension.valueExpression?.language === 'text/fhirpath'
+  );
+  if (itemControl) {
+    if (itemControl.valueExpression) {
+      return itemControl.valueExpression;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if the extension has url for items that use open label
+ *
+ * @author Sean Fong
+ */
+export function getOpenLabelText(qItem: QuestionnaireItem): string | null {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-openLabel'
+  );
+  if (itemControl) {
+    if (itemControl.valueString) {
+      return itemControl.valueString;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if the decimal value has a quantity precision for the decimal value
+ *
+ * @author Sean Fong
+ */
+export function getDecimalPrecision(qItem: QuestionnaireItem): number | null {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/StructureDefinition/quantity-precision'
+  );
+  if (itemControl) {
+    if (itemControl.valueInteger) {
+      return itemControl.valueInteger;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if the extension has a url for xhtml rendering
+ *
+ * @author Sean Fong
+ */
+export function getXHtmlString(qItem: QuestionnaireItem): string | null {
+  let xHtmlString = null;
+  if (qItem.extension) {
+    xHtmlString = getXHtmlStringFromExtension(qItem.extension);
+    if (xHtmlString) {
+      return xHtmlString;
+    }
+  }
+
+  if (qItem._text?.extension) {
+    xHtmlString = getXHtmlStringFromExtension(qItem._text?.extension);
+    if (xHtmlString) {
+      return xHtmlString;
+    }
+  }
+
+  return null;
+}
+
+export function getXHtmlStringFromExtension(extensions: Extension[]): string | null {
+  const itemControl = extensions?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/StructureDefinition/rendering-xhtml'
+  );
+
+  if (itemControl) {
+    if (itemControl.valueString) {
+      return itemControl.valueString;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if the item label (text) has a valueMarkdown extension
+ *
+ * @author Sean Fong
+ */
+export function getMarkdownString(qItem: QuestionnaireItem): string | null {
+  const itemControl = qItem._text?.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/StructureDefinition/rendering-markdown'
+  );
+
+  if (itemControl) {
+    if (itemControl.valueMarkdown) {
+      return itemControl.valueMarkdown;
+    }
+  }
+  return null;
+}
+
+/**
+ * Get questionnaire name from questionnaireResponse
+ * If questionnaireResponse does not have a name, fallback to questionnaireResponse questionnaireId
+ *
+ * @author Sean Fong
+ */
+export function getQuestionnaireNameFromResponse(
+  questionnaireResponse: QuestionnaireResponse
+): string {
+  const itemControl = questionnaireResponse._questionnaire?.extension?.find(
+    (extension: Extension) => extension.url === 'http://hl7.org/fhir/StructureDefinition/display'
+  );
+
+  if (itemControl) {
+    if (itemControl.valueString) {
+      return itemControl.valueString.charAt(0).toUpperCase() + itemControl.valueString.slice(1);
+    }
+  }
+
+  return questionnaireResponse.id ?? 'Unnamed Response';
+}
+
+/**
+ * Get text display prompt for items with itemControlCode prompt and has a prompt childItem
+ *
+ * @author Sean Fong
+ */
+export function getTextDisplayPrompt(qItem: QuestionnaireItem): string {
+  if (qItem.item) {
+    for (const childItem of qItem.item) {
+      if (childItem.type === 'display' && isSpecificItemControl(childItem, 'prompt')) {
+        const promptText = `${childItem.text}`;
+        return promptText[0].toUpperCase() + promptText.substring(1);
+      }
+    }
+  }
+  return '';
+}
+
+/**
+ * Check if item is readonly
+ *
+ * @author Sean Fong
+ */
+export function getReadOnly(qItem: QuestionnaireItem): boolean {
+  return !!qItem.readOnly;
+}
+
+/**
+ * Get decimal text display unit for items with itemControlCode unit and has a unit childItem
+ *
+ * @author Sean Fong
+ */
+export function getTextDisplayUnit(qItem: QuestionnaireItem): string {
+  if (qItem.item) {
+    for (const childItem of qItem.item) {
+      if (childItem.type === 'display' && isSpecificItemControl(childItem, 'unit')) {
+        return `${childItem.text}`;
+      }
+    }
+  }
+  return '';
+}
+
+/**
+ * Get text display instructions for items with itemControlCode instructions and has an instructions childItem
+ *
+ * @author Sean Fong
+ */
+export function getTextDisplayInstructions(qItem: QuestionnaireItem): string {
+  if (qItem.item) {
+    for (const childItem of qItem.item) {
+      if (childItem.type === 'display' && isSpecificDisplayCategory(childItem, 'instructions')) {
+        return `${childItem.text}`;
+      }
+    }
+  }
+  return '';
+}
+
+/**
+ * Get entry format if its extension is present
+ * i.e. DD-MM-YYYY for dates, HH:MM for times etc.
+ *
+ * @author Sean Fong
+ */
+export function getEntryFormat(qItem: QuestionnaireItem): string {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/StructureDefinition/entryFormat'
+  );
+
+  if (itemControl) {
+    if (itemControl.valueString) {
+      return itemControl.valueString;
+    }
+  }
+  return '';
+}
+
+/**
+ * Get entry format if its extension is present
+ * i.e. DD-MM-YYYY for dates, HH:MM for times etc.
+ *
+ * @author Sean Fong
+ */
+export function getRegexValidation(qItem: QuestionnaireItem): RegexValidation | null {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) => extension.url === 'http://hl7.org/fhir/StructureDefinition/regex'
+  );
+
+  // Get regex expression from extension
+  if (itemControl) {
+    const extensionString = itemControl.valueString;
+    if (extensionString) {
+      let regexString;
+      if (extensionString.includes('matches(')) {
+        regexString = extensionString.substring(
+          extensionString.indexOf("matches('") + "matches('".length,
+          extensionString.lastIndexOf("')")
+        );
+      } else {
+        regexString = extensionString;
+      }
+
+      return { expression: new RegExp(regexString), feedback: null };
+    }
+  }
+
+  // Get regex expression from item types if regex extensions not present
+  if (qItem.type === 'url') {
+    return { expression: new RegExp(/^\S*$/), feedback: 'URLs should not contain any whitespaces' };
+  }
+
+  return null;
+}
+
+/**
+ * Get maximum length of characters allowed if present
+ *
+ * @author Sean Fong
+ */
+export function getMaxLength(qItem: QuestionnaireItem): number | null {
+  return qItem.maxLength ?? null;
+}

package/src/utils/mapItem.ts

@@ -0,0 +1,97 @@
+/*
+ * 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 { QuestionnaireItem, QuestionnaireResponseItem } from 'fhir/r4';
+import { isRepeatItemAndNotCheckbox } from './qItem';
+
+/**
+ * Generate an array of QuestionnaireResponseItems corresponding to its QuestionnaireItem indexes an array.
+ * QuestionnaireItems without a corresponding QuestionnaireResponseItem is set as undefined.
+ * i.e. QItems = [QItem0, QItem1, QItem2]. Only QItem0 and QItem2 have QrItems
+ * Generated array: [QrItem0, undefined, QrItem2]
+ *
+ * @author Sean Fong
+ */
+export function getQrItemsIndex(
+  qItems: QuestionnaireItem[],
+  qrItems: QuestionnaireResponseItem[],
+  qItemsIndexMap: Record<string, number>
+): (QuestionnaireResponseItem | QuestionnaireResponseItem[])[] {
+  // Generate a <linkId, QrItem OR QrItems> dictionary
+  const qrItemsCollected: Record<string, QuestionnaireResponseItem | QuestionnaireResponseItem[]> =
+    {};
+  for (const qrItem of qrItems) {
+    const linkId = qrItem.linkId;
+
+    // If item already exists, it has multiple qrItems and is therefore a repeat group
+    if (qrItemsCollected[linkId]) {
+      let storedValue = qrItemsCollected[linkId];
+
+      // Create an array out of initial stored value if it is not an array initially
+      if (!Array.isArray(storedValue)) {
+        storedValue = [storedValue];
+      }
+
+      // Push new qrItem into array
+      storedValue.push(qrItem);
+      qrItemsCollected[linkId] = storedValue;
+    } else {
+      const qItemIndex = qItemsIndexMap[linkId];
+
+      // Assign either a qrItem array or a single qrItem based on whether it is a repeatGroup or not
+      const isRepeatGroup =
+        isRepeatItemAndNotCheckbox(qItems[qItemIndex]) && qItems[qItemIndex].type === 'group';
+
+      qrItemsCollected[linkId] = isRepeatGroup ? [qrItem] : qrItem;
+    }
+  }
+
+  // Generate an array of QuestionnaireResponseItems corresponding to its QuestionnaireItem indexes in sequence
+  // Qitems with no answers has a default value of undefined
+  return qItems.reduce(
+    (mapping: (QuestionnaireResponseItem | QuestionnaireResponseItem[])[], qItem, i) => {
+      const qrItemOrItems = qrItemsCollected[qItem.linkId];
+      // If qItem is a repeat group, default its value to an array instead of undefined
+      if (isRepeatItemAndNotCheckbox(qItem) && qItem.type === 'group') {
+        mapping[i] = qrItemOrItems ? qrItemsCollected[qItem.linkId] : [];
+      } else {
+        mapping[i] = qrItemsCollected[qItem.linkId];
+      }
+      return mapping;
+    },
+    []
+  );
+}
+
+/**
+ * Generate a dictionary of QuestionnaireItems linkIds mapped to their respective array indexes <linkId, QItemIndex>
+ * i.e. { ee2589d5: 0, f9aaa187: 1, 88cab112: 2 }
+ * where ee2589d5, f9aaa187 and 88cab112 are linkIds of QItem0, QItem1 and QItem2 respectively
+ *
+ * @author Sean Fong
+ */
+export function mapQItemsIndex(qGroup: QuestionnaireItem): Record<string, number> {
+  if (!qGroup.item) {
+    return {};
+  }
+
+  // generate a <linkId, QItemIndex> dictionary
+  return qGroup.item.reduce((mapping: Record<string, number>, item, i) => {
+    mapping[item.linkId] = i;
+    return mapping;
+  }, {});
+}

package/src/utils/openChoice.ts

@@ -0,0 +1,179 @@
+/*
+ * 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,
+  QuestionnaireItem,
+  QuestionnaireItemAnswerOption,
+  QuestionnaireResponseItem,
+  QuestionnaireResponseItemAnswer
+} from 'fhir/r4';
+import { CheckBoxOptionType, QItemOpenChoiceControl } from '../interfaces/choice.enum';
+import { isSpecificItemControl } from './itemControl';
+import { findInAnswerOptions, findInAnswerValueSetCodings } from './choice';
+
+/**
+ * Update open-choice checkbox group answers based on checkbox changes
+ *
+ * @author Sean Fong
+ */
+export function updateQrOpenChoiceCheckboxAnswers(
+  changedOptionAnswer: string | null,
+  changedOpenLabelAnswer: string | null,
+  answers: QuestionnaireResponseItemAnswer[],
+  answerOptions: QuestionnaireItemAnswerOption[] | Coding[],
+  qrChoiceCheckbox: QuestionnaireResponseItem,
+  checkboxOptionType: CheckBoxOptionType,
+  isMultiSelection: boolean
+): QuestionnaireResponseItem | null {
+  if (changedOptionAnswer) {
+    const newAnswer =
+      checkboxOptionType === CheckBoxOptionType.AnswerOption
+        ? findInAnswerOptions(answerOptions, changedOptionAnswer)
+        : findInAnswerValueSetCodings(answerOptions, changedOptionAnswer);
+    if (!newAnswer) return null;
+
+    if (isMultiSelection && answers.length > 0) {
+      // check if new answer exists in existing answers
+      const newAnswerInAnswers =
+        checkboxOptionType === CheckBoxOptionType.AnswerOption
+          ? findInAnswerOptions(answers, changedOptionAnswer)
+          : findInAnswerValueSetCodings(answers, changedOptionAnswer);
+
+      if (newAnswerInAnswers) {
+        // remove new answer from qrAnswers
+        const newAnswers = [...answers].filter(
+          (answer) => JSON.stringify(answer) !== JSON.stringify(newAnswerInAnswers)
+        );
+        return { ...qrChoiceCheckbox, answer: newAnswers };
+      } else {
+        // add new answer to qrAnswers
+        return { ...qrChoiceCheckbox, answer: [...answers, newAnswer] };
+      }
+    } else {
+      return answers.some((answer) => JSON.stringify(answer) === JSON.stringify(newAnswer))
+        ? { ...qrChoiceCheckbox, answer: [] }
+        : { ...qrChoiceCheckbox, answer: [newAnswer] };
+    }
+  } else if (changedOpenLabelAnswer !== null) {
+    const newOpenLabelAnswer = { valueString: changedOpenLabelAnswer };
+    const oldOpenLabelAnswer: QuestionnaireResponseItemAnswer | null = getOldOpenLabelAnswer(
+      answers,
+      answerOptions
+    );
+
+    if (answers.length === 0) {
+      if (changedOpenLabelAnswer === '') {
+        return { linkId: qrChoiceCheckbox.linkId, text: qrChoiceCheckbox.text };
+      } else {
+        return { ...qrChoiceCheckbox, answer: [newOpenLabelAnswer] };
+      }
+    }
+
+    if (isMultiSelection) {
+      if (!oldOpenLabelAnswer) {
+        // append newOpenLabel if oldOpenLabel doesnt exist
+        return {
+          ...qrChoiceCheckbox,
+          answer: [...answers, newOpenLabelAnswer]
+        };
+      } else {
+        // An oldOpenLabel already exists
+        // Remove oldOpenLabel from answers
+        const answersWithoutOpenLabel = [...answers].filter(
+          (answer) => JSON.stringify(answer) !== JSON.stringify(oldOpenLabelAnswer)
+        );
+
+        if (
+          JSON.stringify(newOpenLabelAnswer) === JSON.stringify(oldOpenLabelAnswer) ||
+          changedOpenLabelAnswer === ''
+        ) {
+          // User unchecks openLabel checkbox or clears field
+          if (answersWithoutOpenLabel.length > 0) {
+            return { ...qrChoiceCheckbox, answer: answersWithoutOpenLabel };
+          } else {
+            return { linkId: qrChoiceCheckbox.linkId, text: qrChoiceCheckbox.text };
+          }
+        } else {
+          // User changes openLabel value
+          return {
+            ...qrChoiceCheckbox,
+            answer: [...answersWithoutOpenLabel, newOpenLabelAnswer]
+          };
+        }
+      }
+    } else {
+      if (!oldOpenLabelAnswer || newOpenLabelAnswer !== oldOpenLabelAnswer) {
+        // set newOpenLabel as sole answer if oldOpenLabel doesnt exist OR if user changed openLabel value
+        return { ...qrChoiceCheckbox, answer: [newOpenLabelAnswer] };
+      } else {
+        // User unchecks openLabel checkbox
+        return { ...qrChoiceCheckbox, answer: [] };
+      }
+    }
+  } else {
+    // Default condition which will not happen
+    return { ...qrChoiceCheckbox };
+  }
+}
+
+export function getOldOpenLabelAnswer(
+  answers: QuestionnaireResponseItemAnswer[],
+  options: QuestionnaireItemAnswerOption[]
+): QuestionnaireResponseItemAnswer | null {
+  const openLabelAnswers = answers.filter((answer) => options.indexOf(answer) === -1);
+  return openLabelAnswers.length > 0 ? openLabelAnswers[0] : null;
+}
+
+/**
+ * Get openChoice control type from qItem
+ * defaults to select if no control code is provided
+ *
+ * @author Sean Fong
+ */
+export function getOpenChoiceControlType(qItem: QuestionnaireItem) {
+  if (isSpecificItemControl(qItem, 'autocomplete')) {
+    return QItemOpenChoiceControl.Autocomplete;
+  } else if (isSpecificItemControl(qItem, 'check-box')) {
+    return QItemOpenChoiceControl.Checkbox;
+  } else if (isSpecificItemControl(qItem, 'radio-button')) {
+    return QItemOpenChoiceControl.Radio;
+  } else {
+    return QItemOpenChoiceControl.Select;
+  }
+}
+
+/**
+ * Get string label from given answerOption
+ *
+ * @author Sean Fong
+ */
+export function getAnswerOptionLabel(option: QuestionnaireItemAnswerOption | string): string {
+  if (typeof option === 'string') {
+    return option;
+  }
+
+  if (option['valueCoding']) {
+    return `${option.valueCoding.display}`;
+  } else if (option['valueString']) {
+    return option.valueString;
+  } else if (option['valueInteger']) {
+    return option.valueInteger.toString();
+  } else {
+    return '';
+  }
+}

package/src/utils/parseInputs.ts

@@ -0,0 +1,58 @@
+/*
+ * 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.
+ */
+
+export function parseValidInteger(input: string): number {
+  const validNumericString = parseValidNumericString(input);
+
+  return parseInt(validNumericString);
+}
+
+export function parseValidNumericString(input: string): string {
+  const hasNumber = /\d/;
+  if (!hasNumber.test(input)) {
+    return '0';
+  }
+
+  return input;
+}
+
+export function parseDecimalStringWithPrecision(input: string, precision: number | null): string {
+  input = parseValidNumericString(input);
+
+  let parsedInput = parseFloat(input).toString();
+
+  // restore decimal digits if parseFloat() removes them
+  const decimalPoint = input.indexOf('.');
+  if (decimalPoint !== -1) {
+    const decimalDigits = input.slice(decimalPoint);
+    if (parsedInput.indexOf('.') === -1) {
+      parsedInput += decimalDigits;
+    }
+  }
+
+  // truncate decimal digits based on precision
+  const parsedDecimalPoint = input.indexOf('.');
+  if (precision && parsedDecimalPoint !== -1) {
+    parsedInput = parsedInput.substring(0, parsedDecimalPoint + precision + 1);
+  }
+
+  return parsedInput;
+}
+
+export function parseDecimalStringToFloat(input: string, precision: number): number {
+  return parseFloat(parseFloat(input).toFixed(precision));
+}