@olaboot/esm-form-engine-lib 4.1.0

package/src/components/processor-factory/form-processor-factory.component.tsx

@@ -0,0 +1,128 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import useProcessorDependencies from '../../hooks/useProcessorDependencies';
+import useInitialValues from '../../hooks/useInitialValues';
+import { FormRenderer } from '../renderer/form/form-renderer.component';
+import { type FormProcessorContextProps, type FormSchema } from '../../types';
+import { CustomHooksRenderer } from '../renderer/custom-hooks-renderer.component';
+import { useFormFields } from '../../hooks/useFormFields';
+import { useConcepts } from '../../hooks/useConcepts';
+import { useFormFieldValidators } from '../../hooks/useFormFieldValidators';
+import { useFormFieldsMeta } from '../../hooks/useFormFieldsMeta';
+import { useFormFactory } from '../../provider/form-factory-provider';
+import { useFormFieldValueAdapters } from '../../hooks/useFormFieldValueAdapters';
+import { EncounterFormProcessor } from '../../processors/encounter/encounter-form-processor';
+import { reportError } from '../../utils/error-utils';
+import { useTranslation } from 'react-i18next';
+import Loader from '../loaders/loader.component';
+import { registerFormFieldAdaptersForCleanUp } from '../../lifecycle';
+
+interface FormProcessorFactoryProps {
+  formJson: FormSchema;
+  isSubForm?: boolean;
+  setIsLoadingFormDependencies: (isLoading: boolean) => void;
+}
+
+const FormProcessorFactory = ({
+  formJson,
+  isSubForm = false,
+  setIsLoadingFormDependencies,
+}: FormProcessorFactoryProps) => {
+  const { patient, sessionMode, formProcessors, layoutType, location, provider, sessionDate, visit } = useFormFactory();
+
+  const processor = useMemo(() => {
+    const ProcessorClass = formProcessors[formJson.processor];
+    let processorInstance;
+    if (ProcessorClass) {
+      processorInstance = new ProcessorClass(formJson);
+    } else {
+      console.error(`Form processor ${formJson.processor} not found, defaulting to EncounterFormProcessor`);
+      processorInstance = new EncounterFormProcessor(formJson);
+    }
+    processorInstance.prepareFormSchema(formJson);
+    return processorInstance;
+  }, [formProcessors, formJson.processor]);
+
+  const [processorContext, setProcessorContext] = useState<FormProcessorContextProps>({
+    patient,
+    formJson,
+    sessionMode,
+    layoutType,
+    location,
+    currentProvider: provider,
+    processor,
+    sessionDate,
+    visit,
+    formFields: [],
+    formFieldAdapters: {},
+    formFieldValidators: {},
+  });
+  const { t } = useTranslation();
+  const { formFields: rawFormFields, conceptReferences } = useFormFields(formJson);
+  const { concepts: formFieldsConcepts, isLoading: isLoadingConcepts } = useConcepts(Array.from(conceptReferences));
+  const formFieldsWithMeta = useFormFieldsMeta(rawFormFields, formFieldsConcepts);
+  const formFieldAdapters = useFormFieldValueAdapters(rawFormFields);
+  const formFieldValidators = useFormFieldValidators(rawFormFields);
+  const { isLoading: isLoadingCustomDeps } = useProcessorDependencies(processor, processorContext, setProcessorContext);
+  const useCustomHooks = processor.getCustomHooks().useCustomHooks;
+  const [isLoadingCustomHooks, setIsLoadingCustomHooks] = useState(!!useCustomHooks);
+  const [isLoadingProcessorDependencies, setIsLoadingProcessorDependencies] = useState(true);
+  const {
+    isLoadingInitialValues,
+    initialValues,
+    error: initialValuesError,
+  } = useInitialValues(processor, isLoadingCustomDeps || isLoadingCustomHooks || isLoadingConcepts, processorContext);
+
+  useEffect(() => {
+    const isLoading = isLoadingCustomDeps || isLoadingCustomHooks || isLoadingConcepts || isLoadingInitialValues;
+    setIsLoadingFormDependencies(isLoading);
+    setIsLoadingProcessorDependencies(isLoading);
+  }, [isLoadingCustomDeps, isLoadingCustomHooks, isLoadingConcepts, isLoadingInitialValues]);
+
+  useEffect(() => {
+    setProcessorContext((prev) => ({
+      ...prev,
+      ...(formFieldAdapters && { formFieldAdapters }),
+      ...(formFieldValidators && { formFieldValidators }),
+      ...(formFieldsWithMeta?.length
+        ? { formFields: formFieldsWithMeta }
+        : rawFormFields?.length
+        ? { formFields: rawFormFields }
+        : {}),
+    }));
+  }, [formFieldAdapters, formFieldValidators, rawFormFields, formFieldsWithMeta]);
+
+  useEffect(() => {
+    reportError(initialValuesError, t('errorLoadingInitialValues', 'Error loading initial values'));
+  }, [initialValuesError]);
+
+  useEffect(() => {
+    if (formFieldAdapters) {
+      registerFormFieldAdaptersForCleanUp(formFieldAdapters);
+    }
+  }, [formFieldAdapters]);
+
+  return (
+    <>
+      {useCustomHooks && (
+        <CustomHooksRenderer
+          context={processorContext}
+          setContext={setProcessorContext}
+          useCustomHooks={useCustomHooks}
+          setIsLoadingCustomHooks={setIsLoadingCustomHooks}
+        />
+      )}
+      {isLoadingProcessorDependencies && !isSubForm ? (
+        <Loader />
+      ) : (
+        <FormRenderer
+          processorContext={processorContext}
+          initialValues={initialValues}
+          isSubForm={isSubForm}
+          setIsLoadingFormDependencies={setIsLoadingFormDependencies}
+        />
+      )}
+    </>
+  );
+};
+
+export default FormProcessorFactory;

package/src/components/renderer/custom-hooks-renderer.component.tsx

@@ -0,0 +1,30 @@
+import { useEffect } from 'react';
+import { type FormProcessorContextProps } from '../../types';
+
+export const CustomHooksRenderer = ({
+  context,
+  setContext,
+  useCustomHooks,
+  setIsLoadingCustomHooks,
+}: {
+  context: FormProcessorContextProps;
+  setContext: (context: FormProcessorContextProps) => void;
+  useCustomHooks: (context: Partial<FormProcessorContextProps>) => {
+    data: any;
+    isLoading: boolean;
+    error: any;
+    updateContext: (setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>) => void;
+  };
+  setIsLoadingCustomHooks: (isLoading: boolean) => void;
+}) => {
+  const { isLoading = false, error = null, data, updateContext } = useCustomHooks(context);
+
+  useEffect(() => {
+    if (!isLoading && updateContext) {
+      updateContext(setContext);
+      setIsLoadingCustomHooks(false);
+    }
+  }, [isLoading]);
+
+  return null;
+};

package/src/components/renderer/field/fieldLogic.ts

@@ -0,0 +1,314 @@
+import { codedTypes } from '../../../constants';
+import { type FormContextProps } from '../../../provider/form-provider';
+import { type FormFieldValidator, type SessionMode, type ValidationResult, type FormField } from '../../../types';
+import { hasRendering } from '../../../utils/common-utils';
+import { evaluateAsyncExpression, evaluateExpression } from '../../../utils/expression-runner';
+import { evalConditionalRequired, evaluateDisabled, evaluateHide, findFieldSection } from '../../../utils/form-helper';
+import { isEmpty } from '../../../validators/form-validator';
+import { reportError } from '../../../utils/error-utils';
+
+export function handleFieldLogic(field: FormField, context: FormContextProps) {
+  const {
+    methods: { getValues },
+  } = context;
+  const values = getValues();
+  if (codedTypes.includes(field.questionOptions.rendering)) {
+    evaluateFieldAnswerDisabled(field, values, context);
+  }
+  evaluateFieldDependents(field, values, context);
+}
+
+function evaluateFieldAnswerDisabled(field: FormField, values: Record<string, any>, context: FormContextProps) {
+  const { sessionMode, formFields, patient, visit } = context;
+  field.questionOptions.answers.forEach((answer) => {
+    const disableExpression = answer.disable?.disableWhenExpression;
+    if (disableExpression && disableExpression.includes('myValue')) {
+      answer.disable.isDisabled = evaluateExpression(
+        answer.disable?.disableWhenExpression,
+        { value: field, type: 'field' },
+        formFields,
+        values,
+        {
+          mode: sessionMode,
+          patient,
+          visit,
+        },
+      );
+    }
+  });
+}
+
+function evaluateFieldDependents(field: FormField, values: any, context: FormContextProps) {
+  const {
+    sessionMode,
+    formFields,
+    patient,
+    formFieldValidators,
+    formJson,
+    methods: { setValue },
+    updateFormField,
+    setForm,
+    visit,
+  } = context;
+
+  let shouldUpdateForm = false;
+  // handle fields
+  if (field.fieldDependents) {
+    field.fieldDependents.forEach((dep) => {
+      const dependent = formFields.find((f) => f.id == dep);
+      // evaluate calculated value
+      if (dependent.questionOptions.calculate?.calculateExpression) {
+        evaluateAsyncExpression(
+          dependent.questionOptions.calculate.calculateExpression,
+          { value: dependent, type: 'field' },
+          formFields,
+          values,
+          {
+            mode: sessionMode,
+            patient,
+            visit,
+          },
+        )
+          .then((result) => {
+            setValue(dependent.id, result);
+            // validate calculated value
+            const { errors, warnings } = validateFieldValue(dependent, result, context.formFieldValidators, {
+              formFields,
+              values,
+              expressionContext: { patient, mode: sessionMode },
+            });
+            if (!dependent.meta.submission) {
+              dependent.meta.submission = {};
+            }
+            dependent.meta.submission.errors = errors;
+            dependent.meta.submission.warnings = warnings;
+            if (!errors.length) {
+              context.formFieldAdapters[dependent.type].transformFieldValue(dependent, result, context);
+            }
+            updateFormField(dependent);
+          })
+          .catch((error) => {
+            reportError(error, 'Error evaluating calculate expression');
+          });
+      }
+      // evaluate hide
+      if (dependent.hide) {
+        const targetSection = findFieldSection(formJson, dependent);
+        const isSectionVisible = targetSection?.questions.some((question) => !question.isHidden);
+
+        evaluateHide(
+          { value: dependent, type: 'field' },
+          formFields,
+          values,
+          sessionMode,
+          patient,
+          evaluateExpression,
+          updateFormField,
+        );
+
+        if (targetSection) {
+          targetSection.questions = targetSection?.questions.map((question) => {
+            if (question.id === dependent.id) {
+              return dependent;
+            }
+            return question;
+          });
+          const isDependentFieldHidden = dependent.isHidden;
+          const sectionHasVisibleFieldAfterEvaluation = [...targetSection.questions, dependent].some(
+            (field) => !field.isHidden,
+          );
+
+          if (!isSectionVisible && !isDependentFieldHidden) {
+            targetSection.isHidden = false;
+            shouldUpdateForm = true;
+          } else if (isSectionVisible && !sectionHasVisibleFieldAfterEvaluation) {
+            targetSection.isHidden = true;
+            shouldUpdateForm = true;
+          }
+        }
+      }
+      // evaluate disabled
+      if (typeof dependent.disabled === 'object' && dependent.disabled.disableWhenExpression) {
+        dependent.isDisabled = evaluateDisabled(
+          { value: dependent, type: 'field' },
+          formFields,
+          values,
+          sessionMode,
+          patient,
+          evaluateExpression,
+        );
+      }
+      // evaluate conditional required
+      if (typeof dependent.required === 'object' && dependent.required?.type === 'conditionalRequired') {
+        dependent.isRequired = evalConditionalRequired(dependent, formFields, values);
+      }
+      // evaluate conditional answered
+      if (dependent.validators?.some((validator) => validator.type === 'conditionalAnswered')) {
+        const fieldValidatorConfig = dependent.validators?.find(
+          (validator) => validator.type === 'conditionalAnswered',
+        );
+
+        const validationResults = formFieldValidators['conditionalAnswered'].validate(
+          dependent,
+          dependent.meta.submission?.newValue,
+          {
+            ...fieldValidatorConfig,
+            expressionContext: { patient, mode: sessionMode },
+            values,
+            formFields,
+          },
+        );
+        dependent.meta.submission = { ...dependent.meta.submission, errors: validationResults };
+      }
+      // evaluate hide for answers
+      dependent?.questionOptions.answers
+        ?.filter((answer) => !isEmpty(answer.hide?.hideWhenExpression))
+        .forEach((answer) => {
+          answer.isHidden = evaluateExpression(
+            answer.hide?.hideWhenExpression,
+            { value: dependent, type: 'field' },
+            formFields,
+            values,
+            {
+              mode: sessionMode,
+              patient,
+              visit,
+            },
+          );
+        });
+      // evaluate disabled
+      dependent?.questionOptions.answers
+        ?.filter((answer) => !isEmpty(answer.disable?.isDisabled))
+        .forEach((answer) => {
+          answer.disable.isDisabled = evaluateExpression(
+            answer.disable?.disableWhenExpression,
+            { value: dependent, type: 'field' },
+            formFields,
+            values,
+            {
+              mode: sessionMode,
+              patient,
+              visit,
+            },
+          );
+        });
+      // evaluate readonly
+      if (!dependent.isHidden && dependent.meta.readonlyExpression) {
+        dependent.readonly = evaluateExpression(
+          dependent.meta.readonlyExpression,
+          { value: dependent, type: 'field' },
+          formFields,
+          values,
+          {
+            mode: sessionMode,
+            patient,
+            visit,
+          },
+        );
+      }
+      // evaluate repeat limit
+      if (hasRendering(dependent, 'repeating') && !isEmpty(dependent.questionOptions.repeatOptions?.limitExpression)) {
+        dependent.questionOptions.repeatOptions.limit = evaluateExpression(
+          dependent.questionOptions.repeatOptions?.limitExpression,
+          { value: dependent, type: 'field' },
+          formFields,
+          values,
+          {
+            mode: sessionMode,
+            patient,
+            visit,
+          },
+        );
+      }
+      updateFormField(dependent);
+    });
+  }
+
+  // handle sections
+  if (field.sectionDependents) {
+    field.sectionDependents.forEach((sectionId) => {
+      for (let i = 0; i < formJson.pages.length; i++) {
+        const section = formJson.pages[i].sections.find((section) => section.label == sectionId);
+        if (section) {
+          evaluateHide(
+            { value: section, type: 'section' },
+            formFields,
+            values,
+            sessionMode,
+            patient,
+            evaluateExpression,
+            updateFormField,
+          );
+          shouldUpdateForm = true;
+          break;
+        }
+      }
+    });
+  }
+
+  // handle pages
+  if (field.pageDependents) {
+    field.pageDependents?.forEach((dep) => {
+      const dependent = formJson.pages.find((f) => f.label == dep);
+      evaluateHide(
+        { value: dependent, type: 'page' },
+        formFields,
+        values,
+        sessionMode,
+        patient,
+        evaluateExpression,
+        updateFormField,
+      );
+      shouldUpdateForm = true;
+    });
+  }
+
+  if (shouldUpdateForm) {
+    setForm(formJson);
+  }
+}
+
+export interface ValidatorConfig {
+  formFields: FormField[];
+  values: Record<string, any>;
+  expressionContext: {
+    patient: fhir.Patient;
+    mode: SessionMode;
+  };
+}
+
+export function validateFieldValue(
+  field: FormField,
+  value: any,
+  validators: Record<string, FormFieldValidator>,
+  context: ValidatorConfig,
+): { errors: ValidationResult[]; warnings: ValidationResult[] } {
+  const errors: ValidationResult[] = [];
+  const warnings: ValidationResult[] = [];
+
+  if (field.meta.submission?.unspecified) {
+    return { errors: [], warnings: [] };
+  }
+
+  try {
+    field.validators.forEach((validatorConfig) => {
+      const results = validators[validatorConfig.type]?.validate?.(field, value, {
+        ...validatorConfig,
+        ...context,
+      });
+      if (results) {
+        results.forEach((result) => {
+          if (result.resultType === 'error') {
+            errors.push(result);
+          } else if (result.resultType === 'warning') {
+            warnings.push(result);
+          }
+        });
+      }
+    });
+  } catch (error) {
+    console.error(error);
+  }
+
+  return { errors, warnings };
+}

package/src/components/renderer/field/fieldRenderUtils.ts

@@ -0,0 +1,16 @@
+import { type SessionMode } from '../../../types';
+
+/**
+ * @name shouldRenderField
+ * @description Returns true if a field should be rendered.
+ * A field is hidden in 'embedded-view' mode when it is empty
+ * and either transient or `hideUnansweredQuestionsInReadonlyForms` is enabled.
+ */
+export function shouldRenderField(
+  sessionMode: SessionMode,
+  isTransient: boolean,
+  isEmptyValue: boolean,
+  hideUnansweredQuestionsInReadonlyForms: boolean,
+): boolean {
+  return !(sessionMode === 'embedded-view' && isEmptyValue && (isTransient || hideUnansweredQuestionsInReadonlyForms));
+}