@aehrc/smart-forms-renderer 0.5.0 → 0.6.1

package/src/utils/qItem.ts

@@ -18,7 +18,7 @@
 import type { Extension, Questionnaire, QuestionnaireItem } from 'fhir/r4';
 import { hasHiddenExtension } from './itemControl';
 import { getChoiceControlType } from './choice';
-import { QItemChoiceControl, QItemOpenChoiceControl } from '../interfaces/choice.enum';
+import { ChoiceItemControl, OpenChoiceItemControl } from '../interfaces/choice.enum';
 import { getOpenChoiceControlType } from './openChoice';
 import type { EnableWhenExpression, EnableWhenItems } from '../interfaces/enableWhen.interface';
 
@@ -82,8 +82,8 @@ export function isHiddenByEnableWhens(params: isHiddenByEnableWhensParams): bool
  */
 export function isRepeatItemAndNotCheckbox(qItem: QuestionnaireItem): boolean {
   const isCheckbox =
-    getChoiceControlType(qItem) === QItemChoiceControl.Checkbox ||
-    getOpenChoiceControlType(qItem) === QItemOpenChoiceControl.Checkbox;
+    getChoiceControlType(qItem) === ChoiceItemControl.Checkbox ||
+    getOpenChoiceControlType(qItem) === OpenChoiceItemControl.Checkbox;
 
   return !!qItem['repeats'] && !isCheckbox;
 }

package/src/utils/removeHidden.ts

@@ -15,13 +15,13 @@
  * limitations under the License.
  */
 
-import {
+import type {
   Questionnaire,
   QuestionnaireItem,
   QuestionnaireResponse,
   QuestionnaireResponseItem
 } from 'fhir/r4';
-import {
+import type {
   EnableWhenExpression,
   EnableWhenItems
 } from 'smart-forms-app/src/types/enableWhen.interface';

package/src/utils/valueSet.ts

@@ -64,6 +64,17 @@ export function getValueSetPromise(url: string, terminologyServer?: string): Pro
   });
 }
 
+async function addTimeoutToPromise(promise: Promise<any>, timeoutMs: number) {
+  const timeoutPromise = new Promise((_, reject) => {
+    setTimeout(() => {
+      reject(new Error(`Promise timed out after ${timeoutMs} milliseconds`));
+    }, timeoutMs);
+  });
+
+  // Use Promise.race to wait for either the original promise or the timeout promise
+  return Promise.race([promise, timeoutPromise]);
+}
+
 export async function resolvePromises(
   valueSetPromises: Record<string, ValueSetPromise>
 ): Promise<Record<string, ValueSetPromise>> {
@@ -71,7 +82,11 @@ export async function resolvePromises(
 
   const valueSetPromiseKeys = Object.keys(valueSetPromises);
   const valueSetPromiseValues = Object.values(valueSetPromises);
-  const promises = valueSetPromiseValues.map((valueSetPromise) => valueSetPromise.promise);
+
+  const timeoutMs = 5000;
+  const promises = valueSetPromiseValues.map((valueSetPromise) =>
+    addTimeoutToPromise(valueSetPromise.promise, timeoutMs)
+  );
 
   const settledPromises = await Promise.allSettled(promises);
 

package/tsconfig.json

@@ -14,8 +14,9 @@
     "allowJs": true,
     "outDir": "lib",
     "declaration": true,
-    "checkJs": true
+    "checkJs": true,
+    "resolveJsonModule": true
   },
   "include": ["src"],
-  "exclude": ["src/**/*.test.ts", "src/stories/**/*", "src/setup-jest.*"]
+  "exclude": ["src/**/*.test.ts", "src/stories/**/*", "src/setup-jest.*", "lib"]
 }

package/src/api/populate.ts

@@ -1,70 +0,0 @@
-/*
- * 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 { InputParameters, OutputParameters } from 'sdc-populate';
-import { isOutputParameters, populate } from 'sdc-populate';
-import type { RequestConfig } from '../utils/populateCallback';
-import { fetchResourceCallback } from '../utils/populateCallback';
-import type Client from 'fhirclient/lib/Client';
-import type { OperationOutcome } from 'fhir/r4';
-
-const IS_IN_APP_POPULATE = true;
-
-export const HEADERS = {
-  'Content-Type': 'application/json;charset=utf-8',
-  Accept: 'application/json;charset=utf-8'
-};
-
-export async function requestPopulate(
-  fhirClient: Client,
-  inputParameters: InputParameters
-): Promise<OutputParameters | OperationOutcome> {
-  const requestConfig: RequestConfig = {
-    clientEndpoint: fhirClient.state.serverUrl,
-    authToken: fhirClient.state.tokenResponse!.access_token!
-  };
-
-  if (IS_IN_APP_POPULATE) {
-    return await populate(inputParameters, fetchResourceCallback, requestConfig);
-  }
-
-  const outputParameters = await fhirClient.request({
-    url: 'Questionnaire/$populate',
-    method: 'POST',
-    body: JSON.stringify(inputParameters),
-    headers: {
-      ...HEADERS,
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${requestConfig.authToken}`
-    }
-  });
-
-  if (isOutputParameters(outputParameters)) {
-    return outputParameters;
-  }
-
-  return {
-    resourceType: 'OperationOutcome',
-    issue: [
-      {
-        severity: 'error',
-        code: 'invalid',
-        details: { text: 'Output parameters does not match the specification.' }
-      }
-    ]
-  };
-}

package/src/stores/useConfigStore.ts

@@ -1,36 +0,0 @@
-import { create } from 'zustand';
-import type { Encounter, Patient, Practitioner, Questionnaire } from 'fhir/r4';
-import type Client from 'fhirclient/lib/Client';
-
-export interface ConfigState {
-  smartClient: Client | null;
-  patient: Patient | null;
-  user: Practitioner | null;
-  encounter: Encounter | null;
-  launchQuestionnaire: Questionnaire | null;
-  debugMode: boolean;
-  setSmartClient: (client: Client) => void;
-  setPatient: (patient: Patient) => void;
-  setUser: (user: Practitioner) => void;
-  setEncounter: (encounter: Encounter) => void;
-  setLaunchQuestionnaire: (launchQuestionnaire: Questionnaire | null) => void;
-  activateDebugMode: () => void;
-}
-
-const useConfigStore = create<ConfigState>()((set) => ({
-  smartClient: null,
-  patient: null,
-  user: null,
-  encounter: null,
-  launchQuestionnaire: null,
-  debugMode: false,
-  setSmartClient: (client: Client) => set(() => ({ smartClient: client })),
-  setPatient: (patient: Patient) => set(() => ({ patient: patient })),
-  setUser: (user: Practitioner) => set(() => ({ user: user })),
-  setEncounter: (encounter: Encounter) => set(() => ({ encounter: encounter })),
-  setLaunchQuestionnaire: (launchQuestionnaire: Questionnaire | null) =>
-    set(() => ({ launchQuestionnaire: launchQuestionnaire })),
-  activateDebugMode: () => set(() => ({ debugMode: true }))
-}));
-
-export default useConfigStore;

package/src/utils/populate.ts

@@ -1,117 +0,0 @@
-/*
- * 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 {
-  Encounter,
-  Patient,
-  Practitioner,
-  Questionnaire,
-  QuestionnaireResponse
-} from 'fhir/r4';
-import {
-  getLaunchContexts,
-  getQuestionnaireLevelXFhirQueryVariables,
-  getSourceQueries
-} from './populateContexts';
-import type { IssuesParameter, ResponseParameter } from 'sdc-populate';
-import { isInputParameters } from 'sdc-populate';
-import type Client from 'fhirclient/lib/Client';
-import { createPopulateInputParameters } from './populateInputParams';
-import { requestPopulate } from '../api/populate';
-
-export interface PopulateFormParams {
-  populated: QuestionnaireResponse;
-  hasWarnings: boolean;
-}
-/**
- * Pre-populate questionnaire from CMS patient data to form a populated questionnaireResponse
- *
- * @author Sean Fong
- */
-export async function populateQuestionnaire(
-  questionnaire: Questionnaire,
-  fhirClient: Client,
-  patient: Patient,
-  user: Practitioner,
-  encounter: Encounter | null,
-  populateForm: {
-    (params: PopulateFormParams): void;
-  },
-  exitSpinner: { (): void }
-) {
-  // Get launch contexts, source queries and questionnaire-level variables
-  const launchContexts = getLaunchContexts(questionnaire);
-  const sourceQueries = getSourceQueries(questionnaire);
-  const questionnaireLevelVariables = getQuestionnaireLevelXFhirQueryVariables(questionnaire);
-
-  if (
-    launchContexts.length === 0 &&
-    sourceQueries.length === 0 &&
-    questionnaireLevelVariables.length === 0
-  ) {
-    exitSpinner();
-    return;
-  }
-
-  // Define population input parameters from launch contexts, source queries and questionnaire-level variables
-  const inputParameters = createPopulateInputParameters(
-    questionnaire,
-    patient,
-    user,
-    encounter,
-    launchContexts,
-    sourceQueries,
-    questionnaireLevelVariables
-  );
-
-  if (!inputParameters) {
-    exitSpinner();
-    return;
-  }
-
-  if (!isInputParameters(inputParameters)) {
-    exitSpinner();
-    return;
-  }
-
-  // Perform population if parameters satisfies input parameters
-  const outputParameters = await requestPopulate(fhirClient, inputParameters);
-
-  if (outputParameters.resourceType === 'OperationOutcome') {
-    exitSpinner();
-    return;
-  }
-
-  const responseParameter = outputParameters.parameter.find(
-    (param) => param.name === 'response'
-  ) as ResponseParameter;
-  const issuesParameter = outputParameters.parameter.find((param) => param.name === 'issues') as
-    | IssuesParameter
-    | undefined;
-
-  if (issuesParameter) {
-    for (const issue of issuesParameter.resource.issue) {
-      if (issue.details?.text) {
-        console.warn(issue.details.text);
-      }
-    }
-    populateForm({ populated: responseParameter.resource, hasWarnings: true });
-    return;
-  }
-
-  populateForm({ populated: responseParameter.resource, hasWarnings: false });
-}

package/src/utils/populateCallback.ts

@@ -1,53 +0,0 @@
-/*
- * 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 { FetchResourceCallback } from 'sdc-populate';
-import axios from 'axios';
-
-const ABSOLUTE_URL_REGEX = /^(https?|ftp):\/\/[^\s/$.?#].[^\s]*$/;
-
-export interface RequestConfig {
-  clientEndpoint: string;
-  authToken: string;
-}
-
-export const fetchResourceCallback: FetchResourceCallback = (
-  query: string,
-  requestConfig: RequestConfig
-) => {
-  let { clientEndpoint } = requestConfig;
-  const { authToken } = requestConfig;
-
-  const headers = {
-    Accept: 'application/json;charset=utf-8',
-    Authorization: `Bearer ${authToken}`
-  };
-
-  if (!clientEndpoint.endsWith('/')) {
-    clientEndpoint += '/';
-  }
-
-  if (ABSOLUTE_URL_REGEX.test(query)) {
-    return axios.get(query, {
-      headers: headers
-    });
-  } else {
-    return axios.get(clientEndpoint + query, {
-      headers: headers
-    });
-  }
-};