@openmrs/esm-form-engine-lib 4.2.2-pre.2546 → 4.2.2-pre.2550

package/dist/src/processors/form-processor.d.ts

@@ -2,12 +2,27 @@ import { type OpenmrsResource } from '@openmrs/esm-framework';
 import { type FormContextProps } from '../provider/form-provider';
 import { type ValueAndDisplay, type FormField, type FormSchema, type FormProcessorContextProps } from '../types';
 export type FormProcessorConstructor = new (...args: ConstructorParameters<typeof FormProcessor>) => FormProcessor;
+/**
+ * The setters a processor uses to feed its results back into the processor context. These are the
+ * only three properties it can change; the rest of {@link FormProcessorContextProps} is derived by
+ * the FormProcessorFactory. They supersede the `setContext` passed alongside them, which is shaped
+ * like a `setState` over the whole context but silently discards everything else.
+ */
+export interface FormProcessorContextSetters {
+    setDomainObjectValue: (value: OpenmrsResource) => void;
+    setPreviousDomainObjectValue: (value: OpenmrsResource) => void;
+    setCustomDependencies: (dependencies: Record<string, any> | ((previous: Record<string, any>) => Record<string, any>)) => void;
+}
 export type GetCustomHooksResponse = {
     useCustomHooks: (context: Partial<FormProcessorContextProps>) => {
         data: any;
         isLoading: boolean;
         error: any;
-        updateContext: (setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>) => void;
+        /**
+         * Called once the hook has finished loading, to merge its results into the processor context.
+         * `setContext` is deprecated; use `setters`.
+         */
+        updateContext: (setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>, setters: FormProcessorContextSetters) => void;
     };
 };
 export declare abstract class FormProcessor {
@@ -15,7 +30,11 @@ export declare abstract class FormProcessor {
     domainObjectValue: OpenmrsResource;
     constructor(formJson: FormSchema);
     getDomainObject(): OpenmrsResource;
-    loadDependencies(context: Partial<FormProcessorContextProps>, setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>): Promise<Record<string, any>>;
+    /**
+     * Loads whatever the processor needs before the form can render, merging the results into the
+     * processor context. `setContext` is deprecated; use `setters`.
+     */
+    loadDependencies(context: Partial<FormProcessorContextProps>, setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>, setters: FormProcessorContextSetters): Promise<Record<string, any>>;
     abstract getHistoricalValue(field: FormField, context: FormContextProps): Promise<ValueAndDisplay>;
     abstract processSubmission(context: FormContextProps, abortController: AbortController): Promise<OpenmrsResource>;
     abstract getInitialValues(context: FormProcessorContextProps): Promise<Record<string, any>>;

package/dist/src/processors/form-processor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"form-processor.d.ts","sourceRoot":"","sources":["../../../src/processors/form-processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,KAAK,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAEjH,MAAM,MAAM,wBAAwB,GAAG,KAAK,GAAG,IAAI,EAAE,qBAAqB,CAAC,OAAO,aAAa,CAAC,KAAK,aAAa,CAAC;AAEnH,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,yBAAyB,CAAC,KAAK;QAC/D,IAAI,EAAE,GAAG,CAAC;QACV,SAAS,EAAE,OAAO,CAAC;QACnB,KAAK,EAAE,GAAG,CAAC;QACX,aAAa,EAAE,CAAC,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,yBAAyB,CAAC,CAAC,KAAK,IAAI,CAAC;KACtG,CAAC;CACH,CAAC;AAEF,8BAAsB,aAAa;IACjC,QAAQ,EAAE,UAAU,CAAC;IACrB,iBAAiB,EAAE,eAAe,CAAC;gBAEvB,QAAQ,EAAE,UAAU;IAIhC,eAAe;IAIT,gBAAgB,CACpB,OAAO,EAAE,OAAO,CAAC,yBAAyB,CAAC,EAC3C,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,yBAAyB,CAAC,CAAC,GAC1E,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAI/B,QAAQ,CAAC,kBAAkB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAClG,QAAQ,CAAC,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IACjH,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3F,QAAQ,CAAC,cAAc,IAAI,sBAAsB;IACjD,QAAQ,CAAC,iBAAiB,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU;CAC3D"}
+{"version":3,"file":"form-processor.d.ts","sourceRoot":"","sources":["../../../src/processors/form-processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,KAAK,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAEjH,MAAM,MAAM,wBAAwB,GAAG,KAAK,GAAG,IAAI,EAAE,qBAAqB,CAAC,OAAO,aAAa,CAAC,KAAK,aAAa,CAAC;AAEnH;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B;IAC1C,oBAAoB,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IACvD,4BAA4B,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAC/D,qBAAqB,EAAE,CACrB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,KACzF,IAAI,CAAC;CACX;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,yBAAyB,CAAC,KAAK;QAC/D,IAAI,EAAE,GAAG,CAAC;QACV,SAAS,EAAE,OAAO,CAAC;QACnB,KAAK,EAAE,GAAG,CAAC;QACX;;;WAGG;QACH,aAAa,EAAE,CACb,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,yBAAyB,CAAC,CAAC,EAC3E,OAAO,EAAE,2BAA2B,KACjC,IAAI,CAAC;KACX,CAAC;CACH,CAAC;AAEF,8BAAsB,aAAa;IACjC,QAAQ,EAAE,UAAU,CAAC;IACrB,iBAAiB,EAAE,eAAe,CAAC;gBAEvB,QAAQ,EAAE,UAAU;IAIhC,eAAe;IAIf;;;OAGG;IACG,gBAAgB,CACpB,OAAO,EAAE,OAAO,CAAC,yBAAyB,CAAC,EAC3C,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,yBAAyB,CAAC,CAAC,EAC3E,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAI/B,QAAQ,CAAC,kBAAkB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAClG,QAAQ,CAAC,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IACjH,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3F,QAAQ,CAAC,cAAc,IAAI,sBAAsB;IACjD,QAAQ,CAAC,iBAAiB,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU;CAC3D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-form-engine-lib",
-  "version": "4.2.2-pre.2546",
+  "version": "4.2.2-pre.2550",
   "description": "React Form Engine for O3",
   "main": "dist/index.js",
   "module": "dist/index.js",

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

@@ -1,4 +1,5 @@
-import React, { useEffect, useMemo, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { type OpenmrsResource } from '@openmrs/esm-framework';
 import useProcessorDependencies from '../../hooks/useProcessorDependencies';
 import useInitialValues from '../../hooks/useInitialValues';
 import { FormRenderer } from '../renderer/form/form-renderer.component';
@@ -11,6 +12,7 @@ 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 { type FormProcessorContextSetters } from '../../processors/form-processor';
 import { reportError } from '../../utils/error-utils';
 import { useTranslation } from 'react-i18next';
 import Loader from '../loaders/loader.component';
@@ -22,12 +24,48 @@ interface FormProcessorFactoryProps {
   setIsLoadingFormDependencies: (isLoading: boolean) => void;
 }
 
+// Mutable parts of the context that can be updated by processors/hooks
+interface MutableContextState {
+  domainObjectValue?: OpenmrsResource;
+  previousDomainObjectValue?: OpenmrsResource;
+  customDependencies?: Record<string, any>;
+}
+
+/** Context properties this component derives; a processor that sets one of these is ignored. */
+const factoryOwnedContextKeys = [
+  'patient',
+  'formJson',
+  'visit',
+  'sessionMode',
+  'sessionDate',
+  'location',
+  'currentProvider',
+  'layoutType',
+  'processor',
+  'formFields',
+  'formFieldAdapters',
+  'formFieldValidators',
+] as const satisfies ReadonlyArray<keyof FormProcessorContextProps>;
+
+function warnAboutIgnoredContextKeys(previous: FormProcessorContextProps, next: FormProcessorContextProps) {
+  const ignored = factoryOwnedContextKeys.filter((key) => key in next && next[key] !== previous[key]);
+  if (ignored.length) {
+    console.warn(
+      `A form processor tried to set the context propert${ignored.length === 1 ? 'y' : 'ies'} ` +
+        `${ignored.join(', ')}, which the form engine derives itself. ${
+          ignored.length === 1 ? 'It was' : 'They were'
+        } ignored. Use the setters passed alongside setContext to update the domain object or custom dependencies.`,
+    );
+  }
+}
+
 const FormProcessorFactory = ({
   formJson,
   isSubForm = false,
   setIsLoadingFormDependencies,
 }: FormProcessorFactoryProps) => {
   const { patient, sessionMode, formProcessors, layoutType, location, provider, sessionDate, visit } = useFormFactory();
+  const { t } = useTranslation();
 
   const processor = useMemo(() => {
     const ProcessorClass = formProcessors[formJson.processor];
@@ -42,58 +80,135 @@ const FormProcessorFactory = ({
     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();
+  // Derive form fields and related data
   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 formFields = useMemo(
+    () => (formFieldsWithMeta?.length ? formFieldsWithMeta : rawFormFields ?? []),
+    [formFieldsWithMeta, rawFormFields],
+  );
+
+  // We divide the context into the "mutable" parts, which can be changed by custom hooks
+  // and the "static" parts
+  const [mutableContext, setMutableContext] = useState<MutableContextState>({});
+
+  // Create the "static" part of the context
+  const baseContext = useMemo<Omit<FormProcessorContextProps, keyof MutableContextState>>(
+    () => ({
+      patient,
+      formJson,
+      sessionMode,
+      layoutType,
+      location,
+      currentProvider: provider,
+      processor,
+      sessionDate,
+      visit,
+      formFields,
+      formFieldAdapters: formFieldAdapters ?? {},
+      formFieldValidators: formFieldValidators ?? {},
+    }),
+    [
+      patient,
+      formJson,
+      sessionMode,
+      layoutType,
+      location,
+      provider,
+      processor,
+      sessionDate,
+      visit,
+      formFields,
+      formFieldAdapters,
+      formFieldValidators,
+    ],
+  );
+
+  // re-create the full processor context
+  const processorContext = useMemo<FormProcessorContextProps>(
+    () => ({
+      ...baseContext,
+      ...mutableContext,
+    }),
+    [baseContext, mutableContext],
+  );
+
+  // callback to update the mutable part of the context
+  const setProcessorContext = useCallback(
+    (updater: FormProcessorContextProps | ((prev: FormProcessorContextProps) => FormProcessorContextProps)) => {
+      setMutableContext((prevMutable) => {
+        // Build the "previous" full context to pass to the updater
+        const prevFull: FormProcessorContextProps = {
+          ...baseContext,
+          ...prevMutable,
+        };
+
+        const newFull = typeof updater === 'function' ? updater(prevFull) : updater;
+
+        // Only the updater form sees prevFull; a bare object may be a stale context, whose
+        // differences aren't attempted writes.
+        if (typeof updater === 'function') {
+          warnAboutIgnoredContextKeys(prevFull, newFull);
+        }
+
+        // Extract only the mutable parts from the result
+        return {
+          domainObjectValue: newFull.domainObjectValue,
+          previousDomainObjectValue: newFull.previousDomainObjectValue,
+          customDependencies: newFull.customDependencies,
+        };
+      });
+    },
+    [baseContext],
+  );
+
+  const processorSetters = useMemo<FormProcessorContextSetters>(
+    () => ({
+      setDomainObjectValue: (value) => setMutableContext((prev) => ({ ...prev, domainObjectValue: value })),
+      setPreviousDomainObjectValue: (value) =>
+        setMutableContext((prev) => ({ ...prev, previousDomainObjectValue: value })),
+      setCustomDependencies: (dependencies) =>
+        setMutableContext((prev) => ({
+          ...prev,
+          customDependencies:
+            typeof dependencies === 'function' ? dependencies(prev.customDependencies ?? {}) : dependencies,
+        })),
+    }),
+    [],
+  );
+
+  const { isLoading: isLoadingCustomDeps } = useProcessorDependencies(
+    processor,
+    processorContext,
+    setProcessorContext,
+    processorSetters,
+  );
   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]);
+  // Derive loading state with useMemo to avoid effect-based state updates
+  const isLoadingProcessorDependencies = useMemo(
+    () => isLoadingCustomDeps || isLoadingCustomHooks || isLoadingConcepts || isLoadingInitialValues,
+    [isLoadingCustomDeps, isLoadingCustomHooks, isLoadingConcepts, isLoadingInitialValues],
+  );
 
+  // Notify parent of loading state changes
   useEffect(() => {
-    setProcessorContext((prev) => ({
-      ...prev,
-      ...(formFieldAdapters && { formFieldAdapters }),
-      ...(formFieldValidators && { formFieldValidators }),
-      ...(formFieldsWithMeta?.length
-        ? { formFields: formFieldsWithMeta }
-        : rawFormFields?.length
-        ? { formFields: rawFormFields }
-        : {}),
-    }));
-  }, [formFieldAdapters, formFieldValidators, rawFormFields, formFieldsWithMeta]);
+    setIsLoadingFormDependencies(isLoadingProcessorDependencies);
+  }, [isLoadingProcessorDependencies, setIsLoadingFormDependencies]);
 
   useEffect(() => {
     reportError(initialValuesError, t('errorLoadingInitialValues', 'Error loading initial values'));
-  }, [initialValuesError]);
+  }, [initialValuesError, t]);
 
   useEffect(() => {
     if (formFieldAdapters) {
@@ -107,6 +222,7 @@ const FormProcessorFactory = ({
         <CustomHooksRenderer
           context={processorContext}
           setContext={setProcessorContext}
+          setters={processorSetters}
           useCustomHooks={useCustomHooks}
           setIsLoadingCustomHooks={setIsLoadingCustomHooks}
         />

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

@@ -1,27 +1,25 @@
 import { useEffect } from 'react';
 import { type FormProcessorContextProps } from '../../types';
+import { type FormProcessorContextSetters, type GetCustomHooksResponse } from '../../processors/form-processor';
 
 export const CustomHooksRenderer = ({
   context,
   setContext,
+  setters,
   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;
-  };
+  setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>;
+  setters: FormProcessorContextSetters;
+  useCustomHooks: GetCustomHooksResponse['useCustomHooks'];
   setIsLoadingCustomHooks: (isLoading: boolean) => void;
 }) => {
   const { isLoading = false, error = null, data, updateContext } = useCustomHooks(context);
 
   useEffect(() => {
     if (!isLoading && updateContext) {
-      updateContext(setContext);
+      updateContext(setContext, setters);
       setIsLoadingCustomHooks(false);
     }
   }, [isLoading]);

package/src/hooks/useFormFieldValidators.ts

@@ -1,22 +1,32 @@
-import { useEffect, useState } from 'react';
+import { useMemo } from 'react';
+import useSWRImmutable from 'swr/immutable';
 import { getRegisteredValidator } from '../registry/registry';
 import { type FormField, type FormFieldValidator } from '../types';
 
-export function useFormFieldValidators(fields: FormField[]) {
-  const [validators, setValidators] = useState<Record<string, FormFieldValidator>>();
+const EMPTY_VALIDATORS: Record<string, FormFieldValidator> = {};
 
-  useEffect(() => {
-    const supportedTypes = new Set<string>();
+export function useFormFieldValidators(fields: FormField[]) {
+  const validatorTypesKey = useMemo(() => {
+    const uniqueTypes = new Set<string>();
     fields.forEach((field) => {
-      field.validators?.forEach((validator) => supportedTypes.add(validator.type));
-    });
-    const supportedTypesArray = Array.from(supportedTypes);
-    Promise.all(supportedTypesArray.map((type) => getRegisteredValidator(type))).then((validators) => {
-      setValidators(
-        Object.assign({}, ...validators.map((validator, index) => ({ [supportedTypesArray[index]]: validator }))),
-      );
+      field.validators?.forEach((validator) => uniqueTypes.add(validator.type));
     });
+    return Array.from(uniqueTypes).sort().join(',');
   }, [fields]);
 
-  return validators;
+  const { data: validators } = useSWRImmutable(
+    validatorTypesKey ? ['formFieldValidators', validatorTypesKey] : null,
+    async ([, key]) => {
+      const types = key.split(',');
+      const loadedValidators = await Promise.all(types.map((type) => getRegisteredValidator(type)));
+      const validatorsByType: Record<string, FormFieldValidator> = {};
+      types.forEach((type, index) => {
+        validatorsByType[type] = loadedValidators[index];
+      });
+      return validatorsByType;
+    },
+    { keepPreviousData: true },
+  );
+
+  return validators ?? EMPTY_VALIDATORS;
 }

package/src/hooks/useFormFieldValueAdapters.ts

@@ -1,23 +1,30 @@
-import { useState, useEffect } from 'react';
+import { useMemo } from 'react';
+import useSWRImmutable from 'swr/immutable';
 import { type FormField, type FormFieldValueAdapter } from '../types';
 import { getRegisteredFieldValueAdapter } from '../registry/registry';
 
-export const useFormFieldValueAdapters = (fields: FormField[]) => {
-  const [adapters, setAdapters] = useState<Record<string, FormFieldValueAdapter>>({});
+const EMPTY_ADAPTERS: Record<string, FormFieldValueAdapter> = {};
 
-  useEffect(() => {
-    const supportedTypes = new Set<string>();
-    fields.forEach((field) => {
-      supportedTypes.add(field.type);
-    });
-    const supportedTypesArray = Array.from(supportedTypes);
-    Promise.all(supportedTypesArray.map((type) => getRegisteredFieldValueAdapter(type))).then((adapters) => {
-      const adaptersByType = supportedTypesArray.map((type, index) => ({
-        [type]: adapters[index],
-      }));
-      setAdapters(Object.assign({}, ...adaptersByType));
-    });
+export const useFormFieldValueAdapters = (fields: FormField[]) => {
+  const typesKey = useMemo(() => {
+    const uniqueTypes = new Set<string>();
+    fields.forEach((field) => uniqueTypes.add(field.type));
+    return Array.from(uniqueTypes).sort().join(',');
   }, [fields]);
 
-  return adapters;
+  const { data: adapters } = useSWRImmutable(
+    typesKey ? ['formFieldValueAdapters', typesKey] : null,
+    async ([, key]) => {
+      const types = key.split(',');
+      const loadedAdapters = await Promise.all(types.map((type) => getRegisteredFieldValueAdapter(type)));
+      const adaptersByType: Record<string, FormFieldValueAdapter> = {};
+      types.forEach((type, index) => {
+        adaptersByType[type] = loadedAdapters[index];
+      });
+      return adaptersByType;
+    },
+    { keepPreviousData: true },
+  );
+
+  return adapters ?? EMPTY_ADAPTERS;
 };

package/src/hooks/useFormFields.ts

@@ -2,64 +2,51 @@ import { useMemo } from 'react';
 import { type FormField, type FormSchema } from '../types';
 
 export function useFormFields(form: FormSchema): { formFields: FormField[]; conceptReferences: Set<string> } {
-  const [flattenedFields, conceptReferences] = useMemo(() => {
+  const [flattenedFields, conceptReferencesKey] = useMemo(() => {
     const flattenedFieldsTemp: FormField[] = [];
     const conceptReferencesTemp = new Set<string>();
 
-    const processFlattenedFields = (
-      fields: FormField[],
-    ): {
-      flattenedFields: FormField[];
-      conceptReferences: Set<string>;
-    } => {
-      const flattenedFields: FormField[] = [];
-      const conceptReferences = new Set<string>();
+    const processField = (field: FormField, parentGroupId?: string) => {
+      // Add group ID to nested fields if applicable
+      const processedField = parentGroupId ? { ...field, meta: { ...field.meta, groupId: parentGroupId } } : field;
 
-      const processField = (field: FormField, parentGroupId?: string) => {
-        // Add group ID to nested fields if applicable
-        const processedField = parentGroupId ? { ...field, meta: { ...field.meta, groupId: parentGroupId } } : field;
+      // Add field to flattened list
+      flattenedFieldsTemp.push(processedField);
 
-        // Add field to flattened list
-        flattenedFields.push(processedField);
+      // Collect concept references
+      if (processedField.questionOptions?.concept) {
+        conceptReferencesTemp.add(processedField.questionOptions.concept);
+      }
 
-        // Collect concept references
-        if (processedField.questionOptions?.concept) {
-          conceptReferences.add(processedField.questionOptions.concept);
+      // Collect concept references from answers
+      processedField.questionOptions?.answers?.forEach((answer) => {
+        if (answer.concept) {
+          conceptReferencesTemp.add(answer.concept);
         }
+      });
 
-        // Collect concept references from answers
-        processedField.questionOptions?.answers?.forEach((answer) => {
-          if (answer.concept) {
-            conceptReferences.add(answer.concept);
-          }
+      // Recursively process nested questions for obsGroup
+      if (processedField.type === 'obsGroup' && processedField.questions) {
+        processedField.questions.forEach((nestedField) => {
+          processField(nestedField, processedField.id);
         });
-
-        // Recursively process nested questions for obsGroup
-        if (processedField.type === 'obsGroup' && processedField.questions) {
-          processedField.questions.forEach((nestedField) => {
-            processField(nestedField, processedField.id);
-          });
-        }
-      };
-
-      // Process all input fields
-      fields.forEach((field) => processField(field));
-
-      return { flattenedFields, conceptReferences };
+      }
     };
 
+    // Process all input fields
     form.pages?.forEach((page) =>
       page.sections?.forEach((section) => {
-        if (section.questions) {
-          const { flattenedFields, conceptReferences } = processFlattenedFields(section.questions);
-          flattenedFieldsTemp.push(...flattenedFields);
-          conceptReferences.forEach((conceptReference) => conceptReferencesTemp.add(conceptReference));
-        }
+        section.questions?.forEach((field) => processField(field));
       }),
     );
 
-    return [flattenedFieldsTemp, conceptReferencesTemp];
+    // Serialised so the set below is rebuilt only when the references change. JSON rather than a
+    // delimiter because mapping codes may contain any character, commas included.
+    const sortedRefs = Array.from(conceptReferencesTemp).sort();
+    return [flattenedFieldsTemp, JSON.stringify(sortedRefs)];
   }, [form]);
 
+  const conceptReferences = useMemo(() => new Set<string>(JSON.parse(conceptReferencesKey)), [conceptReferencesKey]);
+
   return { formFields: flattenedFields, conceptReferences };
 }

package/src/hooks/useInitialValues.ts

@@ -1,4 +1,4 @@
-import { useEffect, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { type FormProcessorContextProps } from '../types';
 import { type FormProcessor } from '../processors/form-processor';
 
@@ -11,16 +11,25 @@ const useInitialValues = (
   const [initialValues, setInitialValues] = useState({});
   const [error, setError] = useState(null);
 
+  const contextRef = useRef(context);
+  contextRef.current = context;
+
+  const hasStartedLoading = useRef(false);
+  const hasFormFields = context.formFields?.length > 0;
+  const hasFormFieldAdapters = Object.keys(context.formFieldAdapters ?? {}).length > 0;
+
   useEffect(() => {
     if (
       formProcessor &&
       !isLoadingContextDependencies &&
-      context.formFields?.length &&
-      Object.keys(context.formFieldAdapters).length &&
-      !Object.keys(initialValues).length
+      hasFormFields &&
+      hasFormFieldAdapters &&
+      !hasStartedLoading.current
     ) {
+      hasStartedLoading.current = true;
+      const currentContext = contextRef.current;
       formProcessor
-        .getInitialValues(context)
+        .getInitialValues(currentContext)
         .then((values) => {
           setInitialValues(values);
           setIsLoadingInitialValues(false);
@@ -31,7 +40,7 @@ const useInitialValues = (
           setIsLoadingInitialValues(false);
         });
     }
-  }, [formProcessor, isLoadingContextDependencies, context, initialValues]);
+  }, [formProcessor, isLoadingContextDependencies, hasFormFields, hasFormFieldAdapters]);
 
   return { isLoadingInitialValues, initialValues, error };
 };

package/src/hooks/useProcessorDependencies.ts

@@ -1,12 +1,13 @@
 import { useEffect, useState } from 'react';
 import { type FormProcessorContextProps } from '../types';
-import { type FormProcessor } from '../processors/form-processor';
+import { type FormProcessor, type FormProcessorContextSetters } from '../processors/form-processor';
 import { reportError } from '../utils/error-utils';
 
 const useProcessorDependencies = (
   formProcessor: FormProcessor,
   context: Partial<FormProcessorContextProps>,
-  setContext: (context: FormProcessorContextProps) => void,
+  setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>,
+  setters: FormProcessorContextSetters,
 ) => {
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState('');
@@ -17,7 +18,7 @@ const useProcessorDependencies = (
 
     if (loadDependencies) {
       setIsLoading(true);
-      loadDependencies(context, setContext)
+      loadDependencies(context, setContext, setters)
         .then(() => {
           if (!ignore) {
             setIsLoading(false);

package/src/processors/encounter/encounter-form-processor.ts

@@ -24,7 +24,7 @@ import {
 import { evaluateAsyncExpression, type FormNode } from '../../utils/expression-runner';
 import { extractErrorMessagesFromResponse } from '../../utils/error-utils';
 import { extractObsValueAndDisplay } from '../../utils/form-helper';
-import { FormProcessor } from '../form-processor';
+import { FormProcessor, type FormProcessorContextSetters } from '../form-processor';
 import { getPreviousEncounter, saveEncounter } from '../../api';
 import { hasRendering } from '../../utils/common-utils';
 import { isEmpty } from '../../validators/form-validator';
@@ -50,19 +50,14 @@ function useCustomHooks(context: Partial<FormProcessorContextProps>) {
     data: { encounter, patientPrograms, encounterRole },
     isLoading,
     error: null,
-    updateContext: (setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>) => {
-      setContext((context) => {
-        context.processor.domainObjectValue = encounter as OpenmrsResource;
-        return {
-          ...context,
-          domainObjectValue: encounter as OpenmrsResource,
-          customDependencies: {
-            ...context.customDependencies,
-            patientPrograms: patientPrograms,
-            defaultEncounterRole: encounterRole,
-          },
-        };
-      });
+    updateContext: (_setContext, { setDomainObjectValue, setCustomDependencies }) => {
+      context.processor.domainObjectValue = encounter as OpenmrsResource;
+      setDomainObjectValue(encounter as OpenmrsResource);
+      setCustomDependencies((previous) => ({
+        ...previous,
+        patientPrograms: patientPrograms,
+        defaultEncounterRole: encounterRole,
+      }));
     },
   };
 }
@@ -344,16 +339,12 @@ export class EncounterFormProcessor extends FormProcessor {
 
   async loadDependencies(
     context: FormContextProps,
-    setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>,
+    _setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>,
+    { setPreviousDomainObjectValue }: FormProcessorContextSetters,
   ) {
     const { patient, formJson } = context;
     const encounter = await getPreviousEncounter(patient?.id, formJson.encounterType);
-    setContext((context) => {
-      return {
-        ...context,
-        previousDomainObjectValue: encounter,
-      };
-    });
+    setPreviousDomainObjectValue(encounter);
     return context;
   }