@aehrc/smart-forms-renderer 1.0.0-alpha.98 → 1.0.0

package/src/utils/getExpressionsFromItem.ts

@@ -75,8 +75,7 @@ export function getCalculatedExpressions(qItem: QuestionnaireItem): CalculatedEx
     )
     .filter((calculatedExpression) => calculatedExpression.expression !== '');
 
-  // For item._text - calculatedExpressions and cqfExpressions
-  // FIXME this is a band aid addition, eventually we want to fully support cqfExpressions
+  // For item._text - cqfExpressions and calculatedExpressions (for backwards compatibility)
   const calculatedAndCqfExpressionsInText = [
     ...findCqfExpressionsInExtensions(qItem._text?.extension ?? []),
     ...findCalculatedExpressionsInExtensions(qItem._text?.extension ?? [])
@@ -89,6 +88,18 @@ export function getCalculatedExpressions(qItem: QuestionnaireItem): CalculatedEx
     )
     .filter((calculatedExpression) => calculatedExpression.expression !== '');
 
+  // For item._text.aria-label - ItemTextAriaLabelExpression
+  const itemTextAriaLabelExpressionInText = findItemTextAriaLabelExpressionInExtensions(
+    qItem._text?.extension ?? []
+  )
+    .map(
+      (calculatedExpression): CalculatedExpression => ({
+        expression: calculatedExpression.valueExpression?.expression ?? '',
+        from: 'item._text.aria-label'
+      })
+    )
+    .filter((calculatedExpression) => calculatedExpression.expression !== '');
+
   // For item._answerValueSet - cqfExpressions
   const cqfExpressionsInAnswerValueSet = [
     ...findCqfExpressionsInExtensions(qItem._answerValueSet?.extension ?? [])
@@ -104,6 +115,7 @@ export function getCalculatedExpressions(qItem: QuestionnaireItem): CalculatedEx
   return [
     ...calculatedExpressionsInItem,
     ...calculatedAndCqfExpressionsInText,
+    ...itemTextAriaLabelExpressionInText,
     ...cqfExpressionsInAnswerValueSet
   ];
 }
@@ -125,6 +137,25 @@ function findCqfExpressionsInExtensions(extensions: Extension[]): Extension[] {
   );
 }
 
+/**
+ * Find all FHIRPath aria-label expression custom extensions within a list of extensions.
+ *
+ * This looks for extensions with the custom
+ * `QuestionnaireItemTextAriaLabelExpression` URL and ensures their
+ * `valueExpression.language` is `text/fhirpath`.
+ *
+ * @param {Extension[]} extensions - The list of extensions to search.
+ * @returns {Extension[]} An array of matching extensions (empty if none found).
+ */
+function findItemTextAriaLabelExpressionInExtensions(extensions: Extension[]): Extension[] {
+  return extensions.filter(
+    (extension) =>
+      extension.url ===
+        'https://smartforms.csiro.au/ig/StructureDefinition/QuestionnaireItemTextAriaLabelExpression' &&
+      extension.valueExpression?.language === 'text/fhirpath'
+  );
+}
+
 /**
  * Get answerExpression.valueExpression if its present in item
  *

package/src/utils/index.ts

@@ -15,8 +15,10 @@
  * limitations under the License.
  */
 
+export type { BuildFormParams, RepopulateFormParams } from './manageForm';
 export {
   buildForm,
+  repopulateForm,
   destroyForm,
   getResponse,
   removeEmptyAnswersFromResponse,

package/src/utils/inputSanitization.ts

@@ -55,12 +55,12 @@ const DANGEROUS_PATTERNS = [
   /onmousemove/i,
 
   // Alert and other dangerous functions
-  /alert\s*\(/i,
-  /confirm\s*\(/i,
-  /prompt\s*\(/i,
-  /eval\s*\(/i,
-  /setTimeout\s*\(/i,
-  /setInterval\s*\(/i,
+  /alert\(/i,
+  /confirm\(/i,
+  /prompt\(/i,
+  /eval\(/i,
+  /setTimeout\(/i,
+  /setInterval\(/i,
 
   // HTML encoded characters that could be used for bypassing
   /%3C/i, // <

package/src/utils/manageForm.ts

@@ -1,7 +1,9 @@
 import type { Questionnaire, QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
+import type { RendererConfig } from '../stores';
 import {
   questionnaireResponseStore,
   questionnaireStore,
+  rendererConfigStore,
   smartConfigStore,
   terminologyServerStore
 } from '../stores';
@@ -13,31 +15,100 @@ import { updateQuestionnaireResponse } from './genericRecursive';
 import { removeInternalRepeatIdsRecursive } from './removeRepeatId';
 import type { ComponentType } from 'react';
 import type { QItemOverrideComponentProps, SdcUiOverrideComponentProps } from '../interfaces';
+import { formUpdateQueueStore } from '../stores/formUpdateQueueStore';
+
+/**
+ * Parameters for `buildForm()`.
+ */
+export interface BuildFormParams {
+  /**
+   * The Questionnaire resource to be rendered.
+   */
+  questionnaire: Questionnaire;
+
+  /**
+   * An optional pre-populated, draft, or loaded QuestionnaireResponse to initialise the form with.
+   * If not provided, an empty QuestionnaireResponse will be created.
+   */
+  questionnaireResponse?: QuestionnaireResponse;
+
+  /**
+   * Whether to apply read-only mode to all items in the form view.
+   */
+  readOnly?: boolean;
+
+  /**
+   * A terminology server URL to fetch terminology data.
+   * If available, preferredTerminologyServer SDC extension still takes precedence over this.
+   * If not provided, a fallback public Ontoserver terminology server will be used.
+   */
+  terminologyServerUrl?: string;
+
+  /**
+   * Additional key-value pairs of SDC variables and values to feed into the renderer's FhirPathContext.
+   * Likely used for passing in data from a pre-population module.
+   * Example: `{ 'ObsBodyHeight': <Bundle of height observations> }`.
+   */
+  additionalContext?: Record<string, any>;
+
+  /**
+   * Whether to preserve the current navigation state (e.g. current page in paged forms, current tab in tabbed forms) when rebuilding the form.
+   * This is useful when you want to perform re-population or other updates without losing the user's current position in the form.
+   */
+  preserveNavigationState?: boolean;
+
+  /**
+   * Optional renderer styling and behavioural configurations to have fine-grained control over the styling and behaviour of the renderer.
+   */
+  rendererConfigOptions?: RendererConfig;
+
+  /**
+   * Key-value pairs of React component overrides for specific Questionnaire Items via linkId.
+   * Example: `{ 'linkId123': MyCustomComponent }`
+   */
+  qItemOverrideComponents?: Record<string, ComponentType<QItemOverrideComponentProps>>;
+
+  /**
+   * Key-value pairs of React component overrides for SDC UI Controls, as defined in:
+   * https://hl7.org/fhir/extensions/ValueSet-questionnaire-item-control.html
+   * Example: `{ 'example-code': MyCustomUIComponent }`
+   */
+  sdcUiOverrideComponents?: Record<string, ComponentType<SdcUiOverrideComponentProps>>;
+}
 
 /**
  * Build the form with an initial Questionnaire and an optional filled QuestionnaireResponse.
  * If a QuestionnaireResponse is not provided, an empty QuestionnaireResponse is set as the initial QuestionnaireResponse.
- * There are other optional properties such as applying readOnly, providing a terminology server url and additional variables.
  *
- * @param questionnaire - Questionnaire to be rendered
- * @param questionnaireResponse - Pre-populated/draft/loaded QuestionnaireResponse to be rendered (optional)
- * @param readOnly - Applies read-only mode to all items in the form view
- * @param terminologyServerUrl - Terminology server url to fetch terminology. If not provided, the default terminology server will be used. (optional)
- * @param additionalVariables - Additional key-value pair of SDC variables + values to be fed into the renderer's FhirPathContext `Record<name, value>` (likely coming from a pre-population module) e.g. `{ 'ObsBodyHeight': <Bundle of height observations> } }`.
- * @param qItemOverrideComponents - Key-value pair of React component overrides for Questionnaire Items via linkId `Record<linkId, React component>`
- * @param sdcUiOverrideComponents - Key-value pair of React component overrides for SDC UI Controls https://hl7.org/fhir/extensions/ValueSet-questionnaire-item-control.html `Record<SDC UI code, React component>`
+ * The build process also supports:
+ * - Applying readOnly mode to all items in the form view
+ * - Providing a default terminology server URL (fallbacks to a public Ontoserver instance if not provided)
+ * - Passing additional SDC variables into the FhirPathContext (e.g. for pre-population purposes)
+ * - Adjusting renderer styling and behaviour via `rendererConfigStore`
+ * - Overriding QuestionnaireItem rendering via `qItemOverrideComponents`
+ * - Overriding SDC UI controls via `sdcUiOverrideComponents`
+ *
+ * @param params - {@link BuildFormParams} containing the configuration for building the form
  *
  * @author Sean Fong
  */
-export async function buildForm(
-  questionnaire: Questionnaire,
-  questionnaireResponse?: QuestionnaireResponse,
-  readOnly?: boolean,
-  terminologyServerUrl?: string,
-  additionalVariables?: Record<string, any>,
-  qItemOverrideComponents?: Record<string, ComponentType<QItemOverrideComponentProps>>,
-  sdcUiOverrideComponents?: Record<string, ComponentType<SdcUiOverrideComponentProps>>
-): Promise<void> {
+export async function buildForm(params: BuildFormParams): Promise<void> {
+  const {
+    questionnaire,
+    questionnaireResponse,
+    readOnly = false,
+    terminologyServerUrl,
+    additionalContext,
+    rendererConfigOptions,
+    qItemOverrideComponents,
+    sdcUiOverrideComponents
+  } = params;
+
+  // Destroy previous questionnaire and questionnaireResponse state before building a new one
+  if (rendererConfigOptions) {
+    rendererConfigStore.getState().setRendererConfig(rendererConfigOptions);
+  }
+
   // Reset terminology server
   if (terminologyServerUrl) {
     terminologyServerStore.getState().setUrl(terminologyServerUrl);
@@ -51,26 +122,79 @@ export async function buildForm(
     .buildSourceQuestionnaire(
       questionnaire,
       undefined,
-      additionalVariables,
+      additionalContext,
       terminologyServerUrl,
-      undefined,
+      readOnly,
       qItemOverrideComponents,
       sdcUiOverrideComponents
     );
 
+  // Initialise an empty questionnaireResponse from a given questionnaire
+  // Optionally takes in an existing questionnaireResponse to be initialised
   const initialisedQuestionnaireResponse = initialiseQuestionnaireResponse(
     questionnaire,
     questionnaireResponse
   );
-  questionnaireResponseStore.getState().buildSourceResponse(initialisedQuestionnaireResponse);
-  await questionnaireStore.getState().updatePopulatedProperties(initialisedQuestionnaireResponse);
 
-  // Adding another call to buildSourceResponse so invalidItems is truly updated - not great, but a cheap fix
+  // Set initialised QuestionnaireResponse as the source response in the store
   questionnaireResponseStore.getState().buildSourceResponse(initialisedQuestionnaireResponse);
 
-  if (readOnly) {
-    questionnaireStore.getState().setFormAsReadOnly(readOnly);
+  // Process expressions asynchronously
+  await questionnaireStore.getState().updateExpressions(initialisedQuestionnaireResponse, true);
+
+  // Reset tabs and pages to the first tab/page if needed
+  // If anyone requests for an option to preserve navigation state in the future, we can add a parameter for it
+  const { currentTabIndex, currentPageIndex } = questionnaireStore.getState();
+  if (currentTabIndex !== 0) {
+    questionnaireStore.getState().resetToFirstVisibleTab();
+  }
+  if (currentPageIndex !== 0) {
+    questionnaireStore.getState().resetToFirstVisiblePage();
+  }
+}
+
+/**
+ * Parameters for `repopulateForm()`.
+ */
+export interface RepopulateFormParams {
+  /**
+   * The re-populated QuestionnaireResponse to set as the new source response.
+   */
+  questionnaireResponse: QuestionnaireResponse;
+
+  /**
+   * Optional additional key-value pairs of SDC variables and values to feed into the renderer's FhirPathContext.
+   * Useful for pre-population or enriching the context used by calculatedExpressions.
+   * Example: `{ 'ObsBloodPressure': <Bundle of BP observations> }`
+   */
+  additionalContext?: Record<string, any>;
+}
+
+/**
+ * Re-populate the form with a provided (already filled) QuestionnaireResponse.
+ *
+ * This function does not modify the Questionnaire state.
+ * It replaces the current QuestionnaireResponse state in the store and triggers a form update so that SDC expressions are re-evaluated against the new response.
+ *
+ * @param params - {@link RepopulateFormParams} containing the configuration for repopulating the form
+ *
+ * @author Sean Fong
+ */
+export function repopulateForm(params: RepopulateFormParams): void {
+  const { questionnaireResponse, additionalContext } = params;
+
+  // Update additionalContext if provided
+  if (additionalContext) {
+    questionnaireStore.getState().setAdditionalContext(additionalContext);
   }
+
+  // Set re-populated QuestionnaireResponse as the source response in the store
+  questionnaireResponseStore.getState().buildSourceResponse(questionnaireResponse);
+
+  // Enqueue an initial form update to process expressions
+  formUpdateQueueStore.getState().enqueueFormUpdate({
+    questionnaireResponse: questionnaireResponse
+  });
 }
 
 /**

package/src/utils/parameterisedValueSets.ts

@@ -6,7 +6,12 @@ import type {
 } from 'fhir/r4';
 import type { BindingParameter, ProcessedValueSet } from '../interfaces/valueSet.interface';
 import type { Variables } from '../interfaces';
-import { createFhirPathContext, handleFhirPathResult } from './fhirpath';
+import {
+  cacheTerminologyResult,
+  createFhirPathContext,
+  handleFhirPathResult,
+  isExpressionCached
+} from './fhirpath';
 import fhirpath from 'fhirpath';
 import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
 import type { ComputedNewAnswers } from '../interfaces/computedUpdates.interface';
@@ -143,8 +148,7 @@ export async function evaluateInitialDynamicValueSets(
 
     for (const bindingParameter of processedValueSet.bindingParameters) {
       if (bindingParameter.fhirPathExpression) {
-        const cacheKey = JSON.stringify(bindingParameter.fhirPathExpression); // Use expression as cache key
-        if (fhirPathTerminologyCache[cacheKey]) {
+        if (isExpressionCached(bindingParameter.fhirPathExpression, fhirPathTerminologyCache)) {
           continue;
         }
 
@@ -163,7 +167,11 @@ export async function evaluateInitialDynamicValueSets(
 
           // If fhirPathResult is an async terminology call, cache the result
           if (fhirPathResult instanceof Promise) {
-            fhirPathTerminologyCache[cacheKey] = result;
+            cacheTerminologyResult(
+              bindingParameter.fhirPathExpression,
+              result,
+              fhirPathTerminologyCache
+            );
           }
 
           /*
@@ -208,7 +216,7 @@ export async function evaluateDynamicValueSets(
   processedValueSets: Record<string, ProcessedValueSet>,
   terminologyServerUrl: string
 ): Promise<{
-  processedValueSetsIsUpdated: boolean;
+  isUpdated: boolean;
   updatedProcessedValueSets: Record<string, ProcessedValueSet>;
   computedNewAnswers: ComputedNewAnswers;
 }> {
@@ -222,8 +230,7 @@ export async function evaluateDynamicValueSets(
 
     for (const bindingParameter of processedValueSet.bindingParameters) {
       if (bindingParameter.fhirPathExpression) {
-        const cacheKey = JSON.stringify(bindingParameter.fhirPathExpression); // Use expression as cache key
-        if (fhirPathTerminologyCache[cacheKey]) {
+        if (isExpressionCached(bindingParameter.fhirPathExpression, fhirPathTerminologyCache)) {
           continue;
         }
 
@@ -242,7 +249,11 @@ export async function evaluateDynamicValueSets(
 
           // If fhirPathResult is an async terminology call, cache the result
           if (fhirPathResult instanceof Promise) {
-            fhirPathTerminologyCache[cacheKey] = result;
+            cacheTerminologyResult(
+              bindingParameter.fhirPathExpression,
+              result,
+              fhirPathTerminologyCache
+            );
           }
 
           /*
@@ -281,7 +292,7 @@ export async function evaluateDynamicValueSets(
   }
 
   return {
-    processedValueSetsIsUpdated: isUpdated,
+    isUpdated,
     updatedProcessedValueSets: processedValueSets,
     computedNewAnswers
   };

package/src/utils/targetConstraint.ts

@@ -16,7 +16,12 @@
  */
 
 import type { Questionnaire, QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
-import { createFhirPathContext, handleFhirPathResult } from './fhirpath';
+import {
+  cacheTerminologyResult,
+  createFhirPathContext,
+  handleFhirPathResult,
+  isExpressionCached
+} from './fhirpath';
 import fhirpath from 'fhirpath';
 import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
 import type { TargetConstraint } from '../interfaces/targetConstraint.interface';
@@ -67,8 +72,7 @@ export async function evaluateInitialTargetConstraints(
       continue;
     }
 
-    const cacheKey = JSON.stringify(expression); // Use expression as cache key
-    if (fhirPathTerminologyCache[cacheKey]) {
+    if (isExpressionCached(expression, fhirPathTerminologyCache)) {
       continue;
     }
 
@@ -103,7 +107,7 @@ export async function evaluateInitialTargetConstraints(
 
       // If fhirPathResult is an async terminology call, cache the result
       if (fhirPathResult instanceof Promise) {
-        fhirPathTerminologyCache[cacheKey] = result;
+        cacheTerminologyResult(expression, result, fhirPathTerminologyCache);
       }
     } catch (e) {
       console.warn(e.message, `Target Constraint Key: ${key}\nExpression: ${expression}`);
@@ -123,7 +127,7 @@ export async function evaluateTargetConstraints(
   targetConstraints: Record<string, TargetConstraint>,
   terminologyServerUrl: string
 ): Promise<{
-  targetConstraintsIsUpdated: boolean;
+  isUpdated: boolean;
   updatedTargetConstraints: Record<string, TargetConstraint>;
 }> {
   let isUpdated = false;
@@ -134,8 +138,7 @@ export async function evaluateTargetConstraints(
       continue;
     }
 
-    const cacheKey = JSON.stringify(expression); // Use expression as cache key
-    if (fhirPathTerminologyCache[cacheKey]) {
+    if (isExpressionCached(expression, fhirPathTerminologyCache)) {
       continue;
     }
 
@@ -167,7 +170,7 @@ export async function evaluateTargetConstraints(
 
       // If fhirPathResult is an async terminology call, cache the result
       if (fhirPathResult instanceof Promise) {
-        fhirPathTerminologyCache[cacheKey] = result;
+        cacheTerminologyResult(expression, result, fhirPathTerminologyCache);
       }
     } catch (e) {
       console.warn(e.message, `Target Constraint Key: ${key}\nExpression: ${expression}`);
@@ -175,7 +178,7 @@ export async function evaluateTargetConstraints(
   }
 
   return {
-    targetConstraintsIsUpdated: isUpdated,
+    isUpdated: isUpdated,
     updatedTargetConstraints: targetConstraints
   };
 }

package/src/utils/ucumQuantityConversion.ts

@@ -0,0 +1,195 @@
+/*
+ * Copyright 2025 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 { CalculatedExpression } from '../interfaces';
+import type { Quantity, QuestionnaireItem } from 'fhir/r4';
+import { getItemTerminologyServerToUse } from './preferredTerminologyServer';
+import { validateCodePromise } from './valueSet';
+import type {
+  CodeParameter,
+  DisplayParameter,
+  SystemParameter,
+  ValidateCodeResponse
+} from '../interfaces/valueSet.interface';
+
+const UCUM_VALUE_SET_URL = 'http://hl7.org/fhir/ValueSet/ucum-units';
+const UCUM_SYSTEM = 'http://unitsofmeasure.org';
+
+/**
+ * Validates if a value represents a quantity with a unit enclosed in single quotes,
+ * supporting escaped single quotes within the unit.
+ *
+ * @param input - The value to validate.
+ * @returns {boolean} Returns true if the input matches the pattern: a number followed by a space and a unit enclosed in single quotes, (allowing escaped single quotes); otherwise, false.
+ */
+export function isQuantityString(input: unknown): input is string {
+  const regex = /^\d+(?:\.\d+)?\s+'(?:\\'|[^'])*'$/;
+  return typeof input === 'string' && regex.test(input);
+}
+
+interface UcumQuantityPromise {
+  numericValueString: string;
+  promise: Promise<ValidateCodeResponse | null>;
+}
+
+/**
+ * Validates a UCUM unit code from a FHIR Quantity string using a terminology server.
+ * Based on https://hl7.org/fhirpath/N1/#toquantityunit-string-quantity.
+ *
+ * @param rawValue - Quantity string (e.g. "10 'mg'").
+ * @param qItem - The QuestionnaireItem metadata.
+ * @param itemPreferredTerminologyServers - Map of item-specific terminology servers.
+ * @param defaultTerminologyServerUrl - Fallback terminology server URL.
+ * @returns Promise resolving to a ValidateCodeResponse or null.
+ */
+export function validateQuantityUcumCode(
+  rawValue: string,
+  qItem: Omit<QuestionnaireItem, 'item'>,
+  itemPreferredTerminologyServers: Record<string, string>,
+  defaultTerminologyServerUrl: string
+): UcumQuantityPromise {
+  // Based on https://hl7.org/fhirpath/N1/#toquantityunit-string-quantity
+  const [numericValueString, unitCode] = rawValue.split(' ');
+  const unitCodeFormatted = unitCode.replace(/'/g, '');
+
+  const terminologyServerUrl = getItemTerminologyServerToUse(
+    qItem,
+    itemPreferredTerminologyServers,
+    defaultTerminologyServerUrl
+  );
+
+  return {
+    numericValueString,
+    promise: validateCodePromise(
+      UCUM_VALUE_SET_URL,
+      UCUM_SYSTEM,
+      unitCodeFormatted,
+      terminologyServerUrl
+    )
+  };
+}
+
+/**
+ * Parse and convert calculatedExpression values of type `quantity` into valid UCUM-coded `Quantity` objects.
+ *
+ * This function:
+ * - Iterates over calculatedExpressions grouped by `linkId`
+ * - Identifies expressions with `from: "item"` and valid quantity strings (e.g. `"10 'mg'"`)
+ * - Validates the UCUM unit code against a terminology server
+ * - Converts validated expressions into FHIR `Quantity` objects with `value`, `system`, `code`, and `unit`
+ * - Leaves non-quantity or invalid expressions unchanged
+ *
+ * @param diffCalculatedExpressions - Map of `linkId` → calculatedExpressions to process
+ * @param questionnaireItemMap - Map of `linkId` → QuestionnaireItem metadata
+ * @param itemPreferredTerminologyServers - Map of `linkId` → preferred terminology server URL
+ * @param defaultTerminologyServerUrl - Default terminology server URL if no item-specific server is defined
+ * @returns A promise resolving to the same structure as `diffCalculatedExpressions`, with quantity expressions converted to FHIR `Quantity` objects where possible
+ */
+export async function parseAndConvertUcumQuantities(
+  diffCalculatedExpressions: Record<string, CalculatedExpression[]>,
+  questionnaireItemMap: Record<string, Omit<QuestionnaireItem, 'item'>>,
+  itemPreferredTerminologyServers: Record<string, string>,
+  defaultTerminologyServerUrl: string
+): Promise<Record<string, CalculatedExpression[]>> {
+  /* Store Quantity calculatedExpressions with UCUM unit codes in promises to be executed in parallel */
+  const promisesMap = new Map<string, UcumQuantityPromise>();
+
+  for (const [linkId, calcExpressions] of Object.entries(diffCalculatedExpressions)) {
+    const qItem = questionnaireItemMap[linkId];
+    // Skip if qItem is not a quantity item
+    if (!qItem || qItem.type !== 'quantity') {
+      continue;
+    }
+
+    // Skip if no calculated expression
+    const calcExpression = calcExpressions.find((exp) => exp.from === 'item');
+    if (!calcExpression) {
+      continue;
+    }
+
+    // Skip if calculated expression value is not a valid quantity string
+    if (!isQuantityString(calcExpression.value)) {
+      continue;
+    }
+
+    // Validate the unit code and convert if valid
+    const ucumQuantityPromise = validateQuantityUcumCode(
+      calcExpression.value,
+      qItem,
+      itemPreferredTerminologyServers,
+      defaultTerminologyServerUrl
+    );
+    promisesMap.set(linkId, ucumQuantityPromise);
+  }
+
+  /* Execute all promises in parallel and convert to Quantity objects */
+  const promisesTuples = Array.from(promisesMap.entries());
+  try {
+    const settledPromises = await Promise.allSettled(promisesTuples.map(([, p]) => p.promise));
+    for (const [i, settledPromise] of settledPromises.entries()) {
+      // Skip rejected promises
+      if (settledPromise.status === 'rejected') {
+        console.warn(
+          `UCUM Quantity conversion network error: Details below:` + settledPromise.reason
+        );
+        continue;
+      }
+
+      // Skip null or invalid responses
+      const validateCodeResponse = settledPromise.value;
+      if (!validateCodeResponse?.parameter) {
+        continue;
+      }
+
+      // Get corresponding linkId and calculatedExpression
+      const [linkId, originalPromise] = promisesTuples[i];
+      const numericValueString = originalPromise.numericValueString;
+      const calcExpression = diffCalculatedExpressions[linkId].find((exp) => exp.from === 'item');
+      if (!calcExpression) {
+        continue;
+      }
+
+      // Extract system, code, and display from the response parameters
+      const systemParameter = validateCodeResponse.parameter.find(
+        (p) => p.name === 'system'
+      ) as SystemParameter;
+      const codeParameter = validateCodeResponse.parameter.find(
+        (p) => p.name === 'code'
+      ) as CodeParameter;
+      const displayParameter = validateCodeResponse.parameter.find(
+        (p) => p.name === 'display'
+      ) as DisplayParameter;
+
+      if (systemParameter.valueUri && codeParameter.valueCode && displayParameter.valueString) {
+        calcExpression.value = {
+          value: parseFloat(numericValueString),
+          system: systemParameter.valueUri,
+          code: codeParameter.valueCode,
+          unit: displayParameter.valueString
+        } as Quantity;
+      }
+    }
+  } catch (e) {
+    // e is not thrown as an Error type in fhirpath.js, so we can't use `if (e instanceof Error)` here
+    console.warn(
+      'UCUM Quantity conversion error: fhirpath evaluation for calculatedExpression failed. Details below:',
+      e
+    );
+  }
+
+  return diffCalculatedExpressions;
+}