@aehrc/smart-forms-renderer 0.3.0 → 0.5.0

package/src/hooks/useIntegerCalculatedExpression.ts

@@ -0,0 +1,72 @@
+/*
+ * 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 { useEffect, useState } from 'react';
+import { createEmptyQrItemWithUnit } from '../utils/qrItem';
+import type { QuestionnaireItem, QuestionnaireResponseItem } from 'fhir/r4';
+import useQuestionnaireStore from '../stores/useQuestionnaireStore';
+
+interface UseIntegerCalculatedExpression {
+  calcExpUpdated: boolean;
+}
+
+interface useIntegerCalculatedExpressionProps {
+  qItem: QuestionnaireItem;
+  inputValue: number;
+  displayUnit: string;
+  setInputValue: (value: number) => void;
+  onQrItemChange: (qrItem: QuestionnaireResponseItem) => void;
+}
+
+function useIntegerCalculatedExpression(
+  props: useIntegerCalculatedExpressionProps
+): UseIntegerCalculatedExpression {
+  const { qItem, inputValue, displayUnit, setInputValue, onQrItemChange } = props;
+
+  const calculatedExpressions = useQuestionnaireStore((state) => state.calculatedExpressions);
+
+  const [calcExpUpdated, setCalcExpUpdated] = useState(false);
+
+  useEffect(
+    () => {
+      const calcExpression = calculatedExpressions[qItem.linkId];
+
+      // only update if calculated value is different from current value
+      if (calcExpression?.value !== inputValue && typeof calcExpression?.value === 'number') {
+        // update ui to show calculated value changes
+        setCalcExpUpdated(true);
+        setTimeout(() => {
+          setCalcExpUpdated(false);
+        }, 500);
+
+        // update questionnaireResponse
+        setInputValue(calcExpression.value);
+        onQrItemChange({
+          ...createEmptyQrItemWithUnit(qItem, displayUnit),
+          answer: [{ valueInteger: calcExpression.value }]
+        });
+      }
+    },
+    // Only trigger this effect if calculatedExpression of item changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [calculatedExpressions]
+  );
+
+  return { calcExpUpdated: calcExpUpdated };
+}
+
+export default useIntegerCalculatedExpression;

package/src/hooks/useQueryClient.ts

@@ -0,0 +1,31 @@
+/*
+ * 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 { QueryClient } from '@tanstack/react-query';
+
+function useQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        refetchOnWindowFocus: false,
+        keepPreviousData: true
+      }
+    }
+  });
+}
+
+export default useQueryClient;

package/src/hooks/useRenderingExtensions.ts

@@ -0,0 +1,52 @@
+/*
+ * 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 {
+  getEntryFormat,
+  getMaxLength,
+  getReadOnly,
+  getRegexValidation,
+  getTextDisplayInstructions,
+  getTextDisplayPrompt,
+  getTextDisplayUnit
+} from '../utils/itemControl';
+import type { QuestionnaireItem } from 'fhir/r4';
+import type { RegexValidation } from '../interfaces/regex.interface';
+
+interface RenderingExtensions {
+  displayUnit: string;
+  displayPrompt: string;
+  displayInstructions: string;
+  readOnly: boolean;
+  entryFormat: string;
+  regexValidation: RegexValidation | null;
+  maxLength: number | null;
+}
+
+function useRenderingExtensions(qItem: QuestionnaireItem): RenderingExtensions {
+  return {
+    displayUnit: getTextDisplayUnit(qItem),
+    displayPrompt: getTextDisplayPrompt(qItem),
+    displayInstructions: getTextDisplayInstructions(qItem),
+    readOnly: getReadOnly(qItem),
+    entryFormat: getEntryFormat(qItem),
+    regexValidation: getRegexValidation(qItem),
+    maxLength: getMaxLength(qItem)
+  };
+}
+
+export default useRenderingExtensions;

package/src/hooks/useResponsive.ts

@@ -0,0 +1,51 @@
+/*
+ * 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 { useTheme } from '@mui/material/styles';
+import useMediaQuery from '@mui/material/useMediaQuery';
+
+function useResponsive(
+  query: 'up' | 'down' | 'between' | 'only',
+  start: 'xs' | 'sm' | 'md' | 'lg' | 'xl',
+  end: 'xs' | 'sm' | 'md' | 'lg' | 'xl' = 'xl'
+) {
+  const theme = useTheme();
+
+  const mediaUp = useMediaQuery(theme.breakpoints.up(start));
+
+  const mediaDown = useMediaQuery(theme.breakpoints.down(start));
+
+  const mediaBetween = useMediaQuery(theme.breakpoints.between(start, end));
+
+  const mediaOnly = useMediaQuery(theme.breakpoints.only(start));
+
+  if (query === 'up') {
+    return mediaUp;
+  }
+
+  if (query === 'down') {
+    return mediaDown;
+  }
+
+  if (query === 'between') {
+    return mediaBetween;
+  }
+
+  return mediaOnly;
+}
+
+export default useResponsive;

package/src/hooks/useStringCalculatedExpression.ts

@@ -0,0 +1,71 @@
+/*
+ * 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 { useEffect, useState } from 'react';
+import { createEmptyQrItem } from '../utils/qrItem';
+import type { QuestionnaireItem, QuestionnaireResponseItem } from 'fhir/r4';
+import useQuestionnaireStore from '../stores/useQuestionnaireStore';
+
+interface UseStringCalculatedExpression {
+  calcExpUpdated: boolean;
+}
+
+interface useStringCalculatedExpressionProps {
+  qItem: QuestionnaireItem;
+  inputValue: string;
+  setInputValue: (value: string) => void;
+  onQrItemChange: (qrItem: QuestionnaireResponseItem) => void;
+}
+
+function useStringCalculatedExpression(
+  props: useStringCalculatedExpressionProps
+): UseStringCalculatedExpression {
+  const { qItem, inputValue, setInputValue, onQrItemChange } = props;
+
+  const calculatedExpressions = useQuestionnaireStore((state) => state.calculatedExpressions);
+
+  const [calcExpUpdated, setCalcExpUpdated] = useState(false);
+
+  useEffect(
+    () => {
+      const calcExpression = calculatedExpressions[qItem.linkId];
+
+      // only update if calculated value is different from current value
+      if (calcExpression?.value !== inputValue && typeof calcExpression?.value === 'string') {
+        // update ui to show calculated value changes
+        setCalcExpUpdated(true);
+        setTimeout(() => {
+          setCalcExpUpdated(false);
+        }, 500);
+
+        // update questionnaireResponse
+        setInputValue(calcExpression.value);
+        onQrItemChange({
+          ...createEmptyQrItem(qItem),
+          answer: [{ valueString: calcExpression.value }]
+        });
+      }
+    },
+    // Only trigger this effect if calculatedExpression of item changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [calculatedExpressions]
+  );
+
+  return { calcExpUpdated: calcExpUpdated };
+}
+
+export default useStringCalculatedExpression;

package/src/hooks/useTerminologyServerQuery.ts

@@ -0,0 +1,98 @@
+/*
+ * 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 { useQuery } from '@tanstack/react-query';
+import type { Coding, ValueSet } from 'fhir/r4';
+import { getValueSetCodings, getValueSetPromise } from '../utils/valueSet';
+
+import type { AlertColor } from '@mui/material';
+import useQuestionnaireStore from '../stores/useQuestionnaireStore';
+
+function useTerminologyServerQuery(
+  answerValueSetUrl: string | undefined,
+  maxList: number,
+  input: string,
+  searchTerm: string,
+  terminologyServerUrl?: string
+): { options: Coding[]; loading: boolean; feedback?: { message: string; color: AlertColor } } {
+  const processedValueSetUrls = useQuestionnaireStore((state) => state.processedValueSetUrls);
+
+  let fullUrl = '';
+
+  let options: Coding[] = [];
+  let loading = false;
+  let feedback: { message: string; color: AlertColor } | undefined;
+
+  if (input.length === 0) {
+    feedback = undefined;
+  }
+
+  if (searchTerm.length < 2 && searchTerm.length > 0) {
+    feedback = { message: 'Enter at least 2 characters to search for results.', color: 'info' };
+  }
+
+  // Restructure url to include filter and count parameters
+  if (answerValueSetUrl) {
+    if (answerValueSetUrl.startsWith('#')) {
+      answerValueSetUrl = answerValueSetUrl.slice(1);
+    }
+
+    // attempt to get url from contained value sets when loading questionnaire
+    if (processedValueSetUrls[answerValueSetUrl]) {
+      answerValueSetUrl = processedValueSetUrls[answerValueSetUrl];
+    }
+
+    const urlWithTrailingAmpersand =
+      answerValueSetUrl + (answerValueSetUrl[answerValueSetUrl.length - 1] !== '&' ? '&' : '');
+    fullUrl = urlWithTrailingAmpersand + 'filter=' + searchTerm + '&count=' + maxList;
+  }
+
+  // Perform query
+  const { isInitialLoading, error, data } = useQuery<ValueSet>(
+    ['expandValueSet', fullUrl],
+    () => getValueSetPromise(fullUrl, terminologyServerUrl),
+    {
+      enabled: searchTerm.length >= 2 && answerValueSetUrl !== undefined
+    }
+  );
+
+  if (isInitialLoading) {
+    loading = true;
+  }
+
+  if (error) {
+    console.warn('Ontoserver query failed. Details below: \n' + error);
+    feedback = {
+      message: 'An error occurred. Try again later or try searching for a different term.',
+      color: 'error'
+    };
+  }
+
+  if (data) {
+    if (data.expansion?.total !== 0) {
+      options = getValueSetCodings(data);
+    } else {
+      feedback = {
+        message: "We couldn't seem to find anything. Try searching for a different term.",
+        color: 'warning'
+      };
+    }
+  }
+
+  return { options, loading, feedback };
+}
+export default useTerminologyServerQuery;

package/src/hooks/useValidationError.ts

@@ -0,0 +1,48 @@
+/*
+ * 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 { RegexValidation } from '../interfaces/regex.interface';
+
+function useValidationError(
+  input: string,
+  regexValidation: RegexValidation | null,
+  maxLength: number | null
+): string {
+  let feedback = '';
+
+  if (input) {
+    // Test regex
+    if (regexValidation) {
+      if (!regexValidation.expression.test(input)) {
+        feedback =
+          regexValidation.feedback ??
+          `Input should match the specified regex ${regexValidation.expression}`;
+      }
+    }
+
+    // Test max character limit
+    if (maxLength) {
+      if (input.length > maxLength) {
+        feedback = 'Input exceeds maximum character limit.';
+      }
+    }
+  }
+
+  return feedback;
+}
+
+export default useValidationError;

package/src/hooks/useValueSetCodings.ts

@@ -0,0 +1,150 @@
+/*
+ * 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 { useEffect, useMemo, useState } from 'react';
+import type { Coding, FhirResource, QuestionnaireItem, ValueSet } from 'fhir/r4';
+import {
+  getResourceFromLaunchContext,
+  getTerminologyServerUrl,
+  getValueSetCodings,
+  getValueSetPromise
+} from '../utils/valueSet';
+import { getAnswerExpression } from '../utils/itemControl';
+import fhirpath from 'fhirpath';
+import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
+import useConfigStore from '../stores/useConfigStore';
+import useQuestionnaireStore from '../stores/useQuestionnaireStore';
+
+function useValueSetCodings(qItem: QuestionnaireItem) {
+  const patient = useConfigStore((state) => state.patient);
+  const user = useConfigStore((state) => state.user);
+  const encounter = useConfigStore((state) => state.encounter);
+
+  const launchContexts = useQuestionnaireStore((state) => state.launchContexts);
+  const processedValueSetCodings = useQuestionnaireStore((state) => state.processedValueSetCodings);
+  const cachedValueSetCodings = useQuestionnaireStore((state) => state.cachedValueSetCodings);
+  const addCodingToCache = useQuestionnaireStore((state) => state.addCodingToCache);
+  const { xFhirQueryVariables } = useQuestionnaireStore((state) => state.variables);
+
+  const valueSetUrl = qItem.answerValueSet;
+  let initialCodings = useMemo(() => {
+    // set options from cached answer options if present
+    if (valueSetUrl) {
+      let cleanValueSetUrl = valueSetUrl;
+      if (valueSetUrl.startsWith('#')) {
+        cleanValueSetUrl = valueSetUrl.slice(1);
+      }
+
+      // attempt to get codings from value sets preprocessed when loading questionnaire
+      if (processedValueSetCodings[cleanValueSetUrl]) {
+        return processedValueSetCodings[cleanValueSetUrl];
+      }
+
+      // attempt to get codings from cached queried value sets
+      if (cachedValueSetCodings[cleanValueSetUrl]) {
+        return cachedValueSetCodings[cleanValueSetUrl];
+      }
+    }
+
+    return [];
+  }, [cachedValueSetCodings, processedValueSetCodings, valueSetUrl]);
+
+  const answerExpression = getAnswerExpression(qItem)?.expression;
+  initialCodings = useMemo(() => {
+    if (initialCodings.length === 0 && answerExpression) {
+      const variable = answerExpression.substring(
+        answerExpression.indexOf('%') + 1,
+        answerExpression.indexOf('.')
+      );
+      const contextMap: Record<string, FhirResource> = {};
+
+      // get answer expression resource from launch contexts
+      if (launchContexts[variable]) {
+        const resourceType = launchContexts[variable].extension[1].valueCode;
+        const resource = getResourceFromLaunchContext(resourceType, patient, user, encounter);
+        if (resource) {
+          contextMap[variable] = resource;
+        }
+      } else if (xFhirQueryVariables[variable]) {
+        const resource = xFhirQueryVariables[variable].result;
+        if (resource) {
+          contextMap[variable] = resource;
+        }
+      }
+
+      if (contextMap[variable]) {
+        try {
+          const evaluated: any[] = fhirpath.evaluate(
+            {},
+            answerExpression,
+            contextMap,
+            fhirpath_r4_model
+          );
+
+          if (evaluated[0].system || evaluated[0].code) {
+            // determine if the evaluated array is a coding array
+            return evaluated;
+          } else if (evaluated[0].coding) {
+            // determine and return if the evaluated array is a codeable concept
+            return evaluated[0].coding;
+          }
+        } catch (e) {
+          console.warn(e.message);
+        }
+      }
+    }
+
+    return initialCodings;
+  }, [
+    answerExpression,
+    encounter,
+    initialCodings,
+    launchContexts,
+    patient,
+    user,
+    xFhirQueryVariables
+  ]);
+
+  const [codings, setCodings] = useState<Coding[]>(initialCodings);
+  const [serverError, setServerError] = useState<Error | null>(null);
+
+  // get options from answerValueSet on render
+  useEffect(() => {
+    const valueSetUrl = qItem.answerValueSet;
+    if (!valueSetUrl || codings.length > 0) return;
+
+    const terminologyServer = getTerminologyServerUrl(qItem);
+    const promise = getValueSetPromise(valueSetUrl, terminologyServer);
+    if (promise) {
+      promise
+        .then((valueSet: ValueSet) => {
+          const codings = getValueSetCodings(valueSet);
+          if (codings.length > 0) {
+            addCodingToCache(valueSetUrl, codings);
+            setCodings(codings);
+          }
+        })
+        .catch((error: Error) => {
+          setServerError(error);
+        });
+    }
+  }, [qItem]);
+
+  return { codings, serverError };
+}
+
+export default useValueSetCodings;