@olaboot/esm-form-engine-lib 4.1.0

package/dist/globals.d.ts

@@ -0,0 +1,3 @@
+export declare const moduleName = "@openmrs/esm-form-engine-lib";
+export declare const formEngineAppName = "@openmrs/esm-form-engine-app";
+//# sourceMappingURL=globals.d.ts.map

package/dist/globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../src/globals.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,iCAAiC,CAAC;AACzD,eAAO,MAAM,iBAAiB,iCAAiC,CAAC"}

package/dist/globals.js

@@ -0,0 +1,2 @@
+export const moduleName = '@openmrs/esm-form-engine-lib';
+export const formEngineAppName = '@openmrs/esm-form-engine-app';

package/dist/hooks/useConcepts.d.ts

@@ -0,0 +1,23 @@
+import { type Concept } from '@openmrs/esm-framework';
+type ConceptRepresentation = Pick<Concept, 'uuid' | 'display'> & {
+    conceptClass: Pick<Concept['conceptClass'], 'uuid' | 'display'>;
+    answers: Array<{
+        uuid: string;
+        display: string;
+    }>;
+    conceptMappings: Array<{
+        conceptReferenceTerm: {
+            conceptSource: {
+                name: string;
+            };
+            code: string;
+        };
+    }>;
+};
+export declare function useConcepts(references: Array<string>): {
+    concepts: Array<ConceptRepresentation> | undefined;
+    isLoading: boolean;
+    error: Error | undefined;
+};
+export {};
+//# sourceMappingURL=useConcepts.d.ts.map

package/dist/hooks/useConcepts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConcepts.d.ts","sourceRoot":"","sources":["../../src/hooks/useConcepts.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,OAAO,EAAiD,MAAM,wBAAwB,CAAC;AAKrG,KAAK,qBAAqB,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG;IAC/D,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAChE,OAAO,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IACH,eAAe,EAAE,KAAK,CAAC;QACrB,oBAAoB,EAAE;YACpB,aAAa,EAAE;gBACb,IAAI,EAAE,MAAM,CAAC;aACd,CAAC;YACF,IAAI,EAAE,MAAM,CAAC;SACd,CAAC;KACH,CAAC,CAAC;CACJ,CAAC;AAIF,wBAAgB,WAAW,CAAC,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG;IACtD,QAAQ,EAAE,KAAK,CAAC,qBAAqB,CAAC,GAAG,SAAS,CAAC;IACnD,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;CAC1B,CA4BA"}

package/dist/hooks/useConcepts.js

@@ -0,0 +1,31 @@
+import { useMemo } from "react";
+import useSWR from "swr";
+import { openmrsFetch, restBaseUrl } from "@openmrs/esm-framework";
+const conceptRepresentation = 'custom:(uuid,display,conceptClass:(uuid,display),answers:(uuid,display),conceptMappings:(conceptReferenceTerm:(conceptSource:(name),code)))';
+export function useConcepts(references) {
+    const { data, error, isLoading } = useSWR([
+        `${restBaseUrl}/conceptreferences?v=${conceptRepresentation}`,
+        references
+    ], ([url, refs])=>openmrsFetch(url, {
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: {
+                references: refs
+            },
+            method: 'POST'
+        }), {
+        revalidateIfStale: false,
+        revalidateOnFocus: false,
+        revalidateOnReconnect: false,
+        shouldRetryOnError: false
+    });
+    const concepts = useMemo(()=>data?.data ? Object.values(data.data) : undefined, [
+        data
+    ]);
+    return {
+        concepts,
+        isLoading,
+        error
+    };
+}

package/dist/hooks/useDataSourceDependentValue.d.ts

@@ -0,0 +1,4 @@
+import { type FormField } from '../types';
+declare const useDataSourceDependentValue: (field: FormField) => any;
+export default useDataSourceDependentValue;
+//# sourceMappingURL=useDataSourceDependentValue.d.ts.map

package/dist/hooks/useDataSourceDependentValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDataSourceDependentValue.d.ts","sourceRoot":"","sources":["../../src/hooks/useDataSourceDependentValue.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAG1C,QAAA,MAAM,2BAA2B,GAAI,OAAO,SAAS,QASpD,CAAC;AAEF,eAAe,2BAA2B,CAAC"}

package/dist/hooks/useDataSourceDependentValue.js

@@ -0,0 +1,14 @@
+import { useWatch } from "react-hook-form";
+import { useFormProviderContext } from "../provider/form-provider.js";
+const useDataSourceDependentValue = (field)=>{
+    const dependentField = field.questionOptions['config']?.referencedField;
+    const { methods: { control } } = useFormProviderContext();
+    const dependentValue = useWatch({
+        control,
+        name: dependentField,
+        exact: true,
+        disabled: !dependentField
+    });
+    return dependentValue;
+};
+export default useDataSourceDependentValue;

package/dist/hooks/useEncounter.d.ts

@@ -0,0 +1,7 @@
+import { type FormSchema, type OpenmrsEncounter } from '../types';
+export declare function useEncounter(formJson: FormSchema): {
+    encounter: OpenmrsEncounter;
+    error: any;
+    isLoading: boolean;
+};
+//# sourceMappingURL=useEncounter.d.ts.map

package/dist/hooks/useEncounter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEncounter.d.ts","sourceRoot":"","sources":["../../src/hooks/useEncounter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAKlE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,UAAU;;;;EAgChD"}

package/dist/hooks/useEncounter.js

@@ -0,0 +1,38 @@
+import { useEffect, useState } from "react";
+import { openmrsFetch, restBaseUrl } from "@openmrs/esm-framework";
+import { encounterRepresentation } from "../constants.js";
+import { isEmpty } from "../validators/form-validator.js";
+import isString from "lodash-es/isString";
+export function useEncounter(formJson) {
+    const [encounter, setEncounter] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(()=>{
+        const abortController = new AbortController();
+        if (!isEmpty(formJson.encounter) && isString(formJson.encounter)) {
+            openmrsFetch(`${restBaseUrl}/encounter/${formJson.encounter}?v=${encounterRepresentation}`, {
+                signal: abortController.signal
+            }).then((response)=>{
+                setEncounter(response.data);
+                setIsLoading(false);
+            }).catch((error)=>{
+                setError(error);
+            });
+        } else if (!isEmpty(formJson.encounter)) {
+            setEncounter(formJson.encounter);
+            setIsLoading(false);
+        } else {
+            setIsLoading(false);
+        }
+        return ()=>{
+            abortController.abort();
+        };
+    }, [
+        formJson.encounter
+    ]);
+    return {
+        encounter: encounter,
+        error,
+        isLoading
+    };
+}

package/dist/hooks/useEncounterRole.d.ts

@@ -0,0 +1,7 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+export declare function useEncounterRole(): {
+    encounterRole: OpenmrsResource;
+    error: Error;
+    isLoading: boolean;
+};
+//# sourceMappingURL=useEncounterRole.d.ts.map

package/dist/hooks/useEncounterRole.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEncounterRole.d.ts","sourceRoot":"","sources":["../../src/hooks/useEncounterRole.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,eAAe,EAA6B,MAAM,wBAAwB,CAAC;AAEzF,wBAAgB,gBAAgB;;;;EAW/B"}

package/dist/hooks/useEncounterRole.js

@@ -0,0 +1,18 @@
+import useSWRImmutable from "swr/immutable";
+import { openmrsFetch, restBaseUrl } from "@openmrs/esm-framework";
+export function useEncounterRole() {
+    const { data, error, isLoading } = useSWRImmutable(`${restBaseUrl}/encounterrole?v=custom:(uuid,display,name)`, openmrsFetch);
+    const clinicalEncounterRole = data?.data.results.find((encounterRole)=>encounterRole.name === 'Clinician');
+    if (clinicalEncounterRole) {
+        return {
+            encounterRole: clinicalEncounterRole,
+            error,
+            isLoading
+        };
+    }
+    return {
+        encounterRole: data?.data.results[0],
+        error,
+        isLoading
+    };
+}

package/dist/hooks/useEvaluateFormFieldExpressions.d.ts

@@ -0,0 +1,7 @@
+import { type FormProcessorContextProps } from '../types';
+export declare const useEvaluateFormFieldExpressions: (formValues: Record<string, any>, factoryContext: FormProcessorContextProps) => {
+    evaluatedFormJson: import("../types").FormSchema;
+    evaluatedFields: import("../types").FormField[];
+    evaluatedPagesVisibility: boolean;
+};
+//# sourceMappingURL=useEvaluateFormFieldExpressions.d.ts.map

package/dist/hooks/useEvaluateFormFieldExpressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEvaluateFormFieldExpressions.d.ts","sourceRoot":"","sources":["../../src/hooks/useEvaluateFormFieldExpressions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAQ1D,eAAO,MAAM,+BAA+B,GAC1C,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/B,gBAAgB,yBAAyB;;;;CAsI1C,CAAC"}

package/dist/hooks/useEvaluateFormFieldExpressions.js

@@ -0,0 +1,112 @@
+import { useEffect, useMemo, useState } from "react";
+import { evaluateExpression } from "../utils/expression-runner.js";
+import { evalConditionalRequired, evaluateConditionalAnswered, evaluateHide } from "../utils/form-helper.js";
+import { isTrue } from "../utils/boolean-utils.js";
+import { isEmpty } from "../validators/form-validator.js";
+import { updateFormSectionReferences } from "../utils/common-utils.js";
+export const useEvaluateFormFieldExpressions = (formValues, factoryContext)=>{
+    const { formFields, patient, sessionMode, visit } = factoryContext;
+    const [evaluatedFormJson, setEvaluatedFormJson] = useState(factoryContext.formJson);
+    const [evaluatedPagesVisibility, setEvaluatedPagesVisibility] = useState(false);
+    const evaluatedFields = useMemo(()=>{
+        return formFields?.map((field)=>{
+            const fieldNode = {
+                value: field,
+                type: 'field'
+            };
+            const runnerContext = {
+                patient,
+                mode: sessionMode,
+                visit
+            };
+            // evaluate hide
+            if (field.hide?.hideWhenExpression) {
+                const isHidden = evaluateExpression(field.hide.hideWhenExpression, fieldNode, formFields, formValues, runnerContext);
+                field.isHidden = isHidden;
+                if (Array.isArray(field.questions)) {
+                    field.questions.forEach((question)=>{
+                        question.isHidden = isHidden;
+                    });
+                }
+            } else {
+                field.isHidden = false;
+            }
+            // evaluate required
+            if (typeof field.required === 'object' && field.required.type === 'conditionalRequired') {
+                field.isRequired = evalConditionalRequired(field, formFields, formValues);
+            } else {
+                field.isRequired = isTrue(field.required);
+            }
+            // evaluate disabled
+            if (typeof field.disabled === 'object' && field.disabled.disableWhenExpression) {
+                field.isDisabled = evaluateExpression(field.disabled.disableWhenExpression, fieldNode, formFields, formValues, runnerContext);
+            } else {
+                field.isDisabled = isTrue(field.disabled);
+            }
+            // evaluate conditional answered
+            if (field.validators?.some((validator)=>validator.type === 'conditionalAnswered')) {
+                evaluateConditionalAnswered(field, formFields);
+            }
+            // evaluate conditional hide for answers
+            field.questionOptions.answers?.filter((answer)=>!isEmpty(answer.hide?.hideWhenExpression)).forEach((answer)=>{
+                answer.isHidden = evaluateExpression(answer.hide.hideWhenExpression, fieldNode, formFields, formValues, runnerContext);
+            });
+            // evaluate conditional disable for answers
+            field.questionOptions.answers?.filter((answer)=>!isEmpty(answer.disable?.disableWhenExpression)).forEach((answer)=>{
+                answer.disable.isDisabled = evaluateExpression(answer.disable?.disableWhenExpression, fieldNode, formFields, formValues, runnerContext);
+            });
+            // evaluate readonly
+            if (typeof field.readonly == 'string' && isNotBooleanString(field.readonly)) {
+                field.meta.readonlyExpression = field.readonly;
+                field.readonly = evaluateExpression(field.readonly, fieldNode, formFields, formValues, runnerContext);
+            }
+            // evaluate repeat limit
+            const limitExpression = field.questionOptions.repeatOptions?.limitExpression;
+            if (field.questionOptions.rendering === 'repeating' && !isEmpty(limitExpression)) {
+                field.questionOptions.repeatOptions.limit = evaluateExpression(limitExpression, fieldNode, formFields, formValues, runnerContext);
+            }
+            return field;
+        });
+    }, [
+        formValues,
+        formFields,
+        patient,
+        sessionMode
+    ]);
+    useEffect(()=>{
+        factoryContext.formJson?.pages?.forEach((page)=>{
+            if (page.hide) {
+                evaluateHide({
+                    value: page,
+                    type: 'page'
+                }, formFields, formValues, sessionMode, patient, evaluateExpression, null);
+            } else {
+                page.isHidden = false;
+            }
+            page?.sections?.forEach((section)=>{
+                if (section.hide) {
+                    evaluateHide({
+                        value: section,
+                        type: 'section'
+                    }, formFields, formValues, sessionMode, patient, evaluateExpression, null);
+                } else {
+                    section.isHidden = false;
+                }
+            });
+        });
+        setEvaluatedFormJson(updateFormSectionReferences(factoryContext.formJson));
+        setEvaluatedPagesVisibility(true);
+    }, [
+        factoryContext.formJson,
+        formFields
+    ]);
+    return {
+        evaluatedFormJson,
+        evaluatedFields,
+        evaluatedPagesVisibility
+    };
+};
+// helpers
+function isNotBooleanString(str) {
+    return str !== 'true' && str !== 'false';
+}

package/dist/hooks/useExternalFormAction.d.ts

@@ -0,0 +1,43 @@
+interface UseExternalFormActionProps {
+    patientUuid: string;
+    formUuid: string;
+    setIsSubmitting: (boolean: any) => void;
+    setIsValidating: (boolean: any) => void;
+}
+/**
+ * useExternalFormAction
+ *
+ * A custom React hook that listens for a global `CustomEvent` (`ampath-form-action`) and triggers
+ * specific actions (such as form submission or validation) by updating external state via provided handlers.
+ *
+ * This is especially useful in scenarios where the Form Engine is embedded inside another application
+ * or UI shell and form behavior (e.g. validation or submission) needs to be triggered programmatically,
+ * such as from a toolbar button, modal footer, or an iframe parent.
+ *
+ * The hook ensures that the received event matches the current `formUuid` and `patientUuid` before executing any action.
+ *
+ * ### Supported Actions
+ * - `"onSubmit"` — Triggers form submission
+ * - `"validateForm"` — Triggers form validation
+ *
+ * @param patientUuid - The UUID of the current patient, used to verify that the action is intended for this instance.
+ * @param formUuid - The UUID of the current form, used to validate the target of the action.
+ * @param setIsSubmitting - A `setState` handler that initiates form submission when set to `true`.
+ * @param setIsValidating - A `setState` handler that initiates form validation when set to `true`.
+ *
+ * @example
+ *
+ * // Elsewhere in the app, dispatching the event:
+ * window.dispatchEvent(
+ *   new CustomEvent('ampath-form-action', {
+ *     detail: {
+ *       formUuid: '289417aa-31d5-3a06-bae8-a22d870bcf1d',
+ *       patientUuid: '9ee7a509-d639-4d91-979a-cd605b4d0ad1/chart',
+ *       action: 'onSubmit',
+ *     },
+ *   })
+ * );
+ */
+export declare function useExternalFormAction({ patientUuid, formUuid, setIsSubmitting, setIsValidating, }: UseExternalFormActionProps): void;
+export {};
+//# sourceMappingURL=useExternalFormAction.d.ts.map

package/dist/hooks/useExternalFormAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExternalFormAction.d.ts","sourceRoot":"","sources":["../../src/hooks/useExternalFormAction.ts"],"names":[],"mappings":"AAUA,UAAU,0BAA0B;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,CAAC,OAAO,KAAA,KAAK,IAAI,CAAC;IACnC,eAAe,EAAE,CAAC,OAAO,KAAA,KAAK,IAAI,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,wBAAgB,qBAAqB,CAAC,EACpC,WAAW,EACX,QAAQ,EACR,eAAe,EACf,eAAe,GAChB,EAAE,0BAA0B,QAoC5B"}

package/dist/hooks/useExternalFormAction.js

@@ -0,0 +1,71 @@
+import { useEffect } from "react";
+import { reportError } from "../utils/error-utils.js";
+import { useTranslation } from "react-i18next";
+/**
+ * useExternalFormAction
+ *
+ * A custom React hook that listens for a global `CustomEvent` (`ampath-form-action`) and triggers
+ * specific actions (such as form submission or validation) by updating external state via provided handlers.
+ *
+ * This is especially useful in scenarios where the Form Engine is embedded inside another application
+ * or UI shell and form behavior (e.g. validation or submission) needs to be triggered programmatically,
+ * such as from a toolbar button, modal footer, or an iframe parent.
+ *
+ * The hook ensures that the received event matches the current `formUuid` and `patientUuid` before executing any action.
+ *
+ * ### Supported Actions
+ * - `"onSubmit"` — Triggers form submission
+ * - `"validateForm"` — Triggers form validation
+ *
+ * @param patientUuid - The UUID of the current patient, used to verify that the action is intended for this instance.
+ * @param formUuid - The UUID of the current form, used to validate the target of the action.
+ * @param setIsSubmitting - A `setState` handler that initiates form submission when set to `true`.
+ * @param setIsValidating - A `setState` handler that initiates form validation when set to `true`.
+ *
+ * @example
+ *
+ * // Elsewhere in the app, dispatching the event:
+ * window.dispatchEvent(
+ *   new CustomEvent('ampath-form-action', {
+ *     detail: {
+ *       formUuid: '289417aa-31d5-3a06-bae8-a22d870bcf1d',
+ *       patientUuid: '9ee7a509-d639-4d91-979a-cd605b4d0ad1/chart',
+ *       action: 'onSubmit',
+ *     },
+ *   })
+ * );
+ */ export function useExternalFormAction({ patientUuid, formUuid, setIsSubmitting, setIsValidating }) {
+    const { t } = useTranslation();
+    useEffect(()=>{
+        const handleSubmit = (event)=>{
+            const customEvent = event;
+            const { formUuid: targetFormUuid, patientUuid: targetPatientUuid, action } = customEvent.detail;
+            if (!action || !targetFormUuid || !targetPatientUuid) {
+                reportError(new Error('The form action event is missing required details (formUuid, patientUuid, or action).'), t('formActionFailed', 'Form action failed'));
+                return;
+            }
+            if (targetFormUuid === formUuid && targetPatientUuid === patientUuid) {
+                switch(action){
+                    case 'onSubmit':
+                        setIsSubmitting(true);
+                        break;
+                    case 'validateForm':
+                        setIsValidating(true);
+                        break;
+                    default:
+                        reportError(new Error(`Unsupported form action: "${action}"`), t('formActionFailed', 'Form action failed'));
+                        break;
+                }
+            }
+        };
+        window.addEventListener('ampath-form-action', handleSubmit);
+        return ()=>{
+            window.removeEventListener('ampath-form-action', handleSubmit);
+        };
+    }, [
+        setIsSubmitting,
+        setIsValidating,
+        formUuid,
+        patientUuid
+    ]);
+}

package/dist/hooks/useFormCollapse.d.ts

@@ -0,0 +1,6 @@
+import type { FormExpanded, SessionMode } from '../types';
+export declare function useFormCollapse(sessionMode: SessionMode): {
+    isFormExpanded: FormExpanded;
+    hideFormCollapseToggle: () => void;
+};
+//# sourceMappingURL=useFormCollapse.d.ts.map

package/dist/hooks/useFormCollapse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormCollapse.d.ts","sourceRoot":"","sources":["../../src/hooks/useFormCollapse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE1D,wBAAgB,eAAe,CAAC,WAAW,EAAE,WAAW;;;EAgCvD"}

package/dist/hooks/useFormCollapse.js

@@ -0,0 +1,35 @@
+import { useCallback, useEffect, useState } from "react";
+export function useFormCollapse(sessionMode) {
+    const [isFormExpanded, setIsFormExpanded] = useState(undefined);
+    const hideFormCollapseToggle = useCallback(()=>{
+        const HideFormCollapseToggle = new CustomEvent('openmrs:form-view-embedded', {
+            detail: {
+                value: false
+            }
+        });
+        window.dispatchEvent(HideFormCollapseToggle);
+    }, []);
+    const handleFormCollapseToggle = useCallback((event)=>{
+        setIsFormExpanded(event.detail.value);
+    }, []);
+    useEffect(()=>{
+        const FormCollapseToggleVisibleEvent = new CustomEvent('openmrs:form-view-embedded', {
+            detail: {
+                value: sessionMode != 'embedded-view'
+            }
+        });
+        window.dispatchEvent(FormCollapseToggleVisibleEvent);
+    }, [
+        sessionMode
+    ]);
+    useEffect(()=>{
+        window.addEventListener('openmrs:form-collapse-toggle', handleFormCollapseToggle);
+        return ()=>{
+            window.removeEventListener('openmrs:form-collapse-toggle', handleFormCollapseToggle);
+        };
+    }, []);
+    return {
+        isFormExpanded,
+        hideFormCollapseToggle
+    };
+}

package/dist/hooks/useFormFieldValidators.d.ts

@@ -0,0 +1,3 @@
+import { type FormField, type FormFieldValidator } from '../types';
+export declare function useFormFieldValidators(fields: FormField[]): Record<string, FormFieldValidator>;
+//# sourceMappingURL=useFormFieldValidators.d.ts.map

package/dist/hooks/useFormFieldValidators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormFieldValidators.d.ts","sourceRoot":"","sources":["../../src/hooks/useFormFieldValidators.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,sCAiBzD"}

package/dist/hooks/useFormFieldValidators.js

@@ -0,0 +1,20 @@
+import { useEffect, useState } from "react";
+import { getRegisteredValidator } from "../registry/registry.js";
+export function useFormFieldValidators(fields) {
+    const [validators, setValidators] = useState();
+    useEffect(()=>{
+        const supportedTypes = new Set();
+        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
+                }))));
+        });
+    }, [
+        fields
+    ]);
+    return validators;
+}

package/dist/hooks/useFormFieldValueAdapters.d.ts

@@ -0,0 +1,3 @@
+import { type FormField, type FormFieldValueAdapter } from '../types';
+export declare const useFormFieldValueAdapters: (fields: FormField[]) => Record<string, FormFieldValueAdapter>;
+//# sourceMappingURL=useFormFieldValueAdapters.d.ts.map

package/dist/hooks/useFormFieldValueAdapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormFieldValueAdapters.d.ts","sourceRoot":"","sources":["../../src/hooks/useFormFieldValueAdapters.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAGtE,eAAO,MAAM,yBAAyB,GAAI,QAAQ,SAAS,EAAE,0CAkB5D,CAAC"}

package/dist/hooks/useFormFieldValueAdapters.js

@@ -0,0 +1,21 @@
+import { useState, useEffect } from "react";
+import { getRegisteredFieldValueAdapter } from "../registry/registry.js";
+export const useFormFieldValueAdapters = (fields)=>{
+    const [adapters, setAdapters] = useState({});
+    useEffect(()=>{
+        const supportedTypes = new Set();
+        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));
+        });
+    }, [
+        fields
+    ]);
+    return adapters;
+};

package/dist/hooks/useFormFields.d.ts

@@ -0,0 +1,6 @@
+import { type FormField, type FormSchema } from '../types';
+export declare function useFormFields(form: FormSchema): {
+    formFields: FormField[];
+    conceptReferences: Set<string>;
+};
+//# sourceMappingURL=useFormFields.d.ts.map

package/dist/hooks/useFormFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormFields.d.ts","sourceRoot":"","sources":["../../src/hooks/useFormFields.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3D,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG;IAAE,UAAU,EAAE,SAAS,EAAE,CAAC;IAAC,iBAAiB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CA6D3G"}

package/dist/hooks/useFormFields.js

@@ -0,0 +1,62 @@
+import { useMemo } from "react";
+export function useFormFields(form) {
+    const [flattenedFields, conceptReferences] = useMemo(()=>{
+        const flattenedFieldsTemp = [];
+        const conceptReferencesTemp = new Set();
+        const processFlattenedFields = (fields)=>{
+            const flattenedFields = [];
+            const conceptReferences = new Set();
+            const processField = (field, parentGroupId)=>{
+                // Add group ID to nested fields if applicable
+                const processedField = parentGroupId ? {
+                    ...field,
+                    meta: {
+                        ...field.meta,
+                        groupId: parentGroupId
+                    }
+                } : field;
+                // Add field to flattened list
+                flattenedFields.push(processedField);
+                // 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) {
+                        conceptReferences.add(answer.concept);
+                    }
+                });
+                // 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
+            };
+        };
+        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));
+                }
+            }));
+        return [
+            flattenedFieldsTemp,
+            conceptReferencesTemp
+        ];
+    }, [
+        form
+    ]);
+    return {
+        formFields: flattenedFields,
+        conceptReferences
+    };
+}

package/dist/hooks/useFormFieldsMeta.d.ts

@@ -0,0 +1,4 @@
+import { type FormField } from '../types';
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+export declare function useFormFieldsMeta(rawFormFields: FormField[], concepts: OpenmrsResource[]): FormField[];
+//# sourceMappingURL=useFormFieldsMeta.d.ts.map

package/dist/hooks/useFormFieldsMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormFieldsMeta.d.ts","sourceRoot":"","sources":["../../src/hooks/useFormFieldsMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAI1C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,eAAe,EAAE,eAyCxF"}