@olaboot/esm-form-engine-lib 4.1.0

package/dist/processors/encounter/encounter-form-processor.test.js

@@ -0,0 +1,207 @@
+import { EncounterFormProcessor } from "./encounter-form-processor.js";
+describe('EncounterFormProcessor', ()=>{
+    describe('prepareFormSchema - validateCalculateExpressions', ()=>{
+        let processor;
+        let consoleSpy;
+        beforeEach(()=>{
+            processor = new EncounterFormProcessor(null);
+            consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+        });
+        afterEach(()=>{
+            consoleSpy.mockRestore();
+        });
+        it('should warn when a calculateExpression contains a quoted string that matches a field ID', ()=>{
+            const schema = {
+                name: 'Test Form',
+                pages: [
+                    {
+                        label: 'Page 1',
+                        sections: [
+                            {
+                                label: 'Section 1',
+                                isExpanded: 'true',
+                                questions: [
+                                    {
+                                        label: 'Last Menstrual Period',
+                                        type: 'obs',
+                                        id: 'lmp',
+                                        questionOptions: {
+                                            rendering: 'date',
+                                            concept: 'test-concept'
+                                        }
+                                    },
+                                    {
+                                        label: 'Expected Date of Delivery',
+                                        type: 'obs',
+                                        id: 'edd',
+                                        questionOptions: {
+                                            rendering: 'date',
+                                            concept: 'test-concept',
+                                            calculate: {
+                                                calculateExpression: "calcEDD('lmp')"
+                                            }
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ],
+                processor: 'EncounterFormProcessor',
+                encounterType: 'test-encounter-type',
+                referencedForms: [],
+                uuid: 'test-form-uuid'
+            };
+            processor.prepareFormSchema(schema);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("incorrectly quotes the field ID 'lmp' as a string"));
+        });
+        it('should not warn when a calculateExpression uses bare variable references', ()=>{
+            const schema = {
+                name: 'Test Form',
+                pages: [
+                    {
+                        label: 'Page 1',
+                        sections: [
+                            {
+                                label: 'Section 1',
+                                isExpanded: 'true',
+                                questions: [
+                                    {
+                                        label: 'Last Menstrual Period',
+                                        type: 'obs',
+                                        id: 'lmp',
+                                        questionOptions: {
+                                            rendering: 'date',
+                                            concept: 'test-concept'
+                                        }
+                                    },
+                                    {
+                                        label: 'Expected Date of Delivery',
+                                        type: 'obs',
+                                        id: 'edd',
+                                        questionOptions: {
+                                            rendering: 'date',
+                                            concept: 'test-concept',
+                                            calculate: {
+                                                calculateExpression: 'calcEDD(lmp)'
+                                            }
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ],
+                processor: 'EncounterFormProcessor',
+                encounterType: 'test-encounter-type',
+                referencedForms: [],
+                uuid: 'test-form-uuid'
+            };
+            processor.prepareFormSchema(schema);
+            expect(consoleSpy).not.toHaveBeenCalled();
+        });
+        it('should not warn when a quoted string does not match any field ID', ()=>{
+            const schema = {
+                name: 'Test Form',
+                pages: [
+                    {
+                        label: 'Page 1',
+                        sections: [
+                            {
+                                label: 'Section 1',
+                                isExpanded: 'true',
+                                questions: [
+                                    {
+                                        label: 'Duration',
+                                        type: 'obs',
+                                        id: 'duration',
+                                        questionOptions: {
+                                            rendering: 'number',
+                                            concept: 'test-concept',
+                                            calculate: {
+                                                calculateExpression: "calcTimeDifference(onsetDate, 'd')"
+                                            }
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ],
+                processor: 'EncounterFormProcessor',
+                encounterType: 'test-encounter-type',
+                referencedForms: [],
+                uuid: 'test-form-uuid'
+            };
+            processor.prepareFormSchema(schema);
+            // 'd' is not a field ID, so no warning should be issued
+            expect(consoleSpy).not.toHaveBeenCalled();
+        });
+        it('should warn for nested questions in obsGroups', ()=>{
+            const schema = {
+                name: 'Test Form',
+                pages: [
+                    {
+                        label: 'Page 1',
+                        sections: [
+                            {
+                                label: 'Section 1',
+                                isExpanded: 'true',
+                                questions: [
+                                    {
+                                        label: 'Height',
+                                        type: 'obs',
+                                        id: 'height',
+                                        questionOptions: {
+                                            rendering: 'number',
+                                            concept: 'test-concept'
+                                        }
+                                    },
+                                    {
+                                        label: 'Weight',
+                                        type: 'obs',
+                                        id: 'weight',
+                                        questionOptions: {
+                                            rendering: 'number',
+                                            concept: 'test-concept'
+                                        }
+                                    },
+                                    {
+                                        label: 'Vitals Group',
+                                        type: 'obsGroup',
+                                        id: 'vitalsGroup',
+                                        questionOptions: {
+                                            rendering: 'group',
+                                            concept: 'test-concept'
+                                        },
+                                        questions: [
+                                            {
+                                                label: 'BMI',
+                                                type: 'obs',
+                                                id: 'bmi',
+                                                questionOptions: {
+                                                    rendering: 'number',
+                                                    concept: 'test-concept',
+                                                    calculate: {
+                                                        calculateExpression: "calcBMI('height', 'weight')"
+                                                    }
+                                                }
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ],
+                processor: 'EncounterFormProcessor',
+                encounterType: 'test-encounter-type',
+                referencedForms: [],
+                uuid: 'test-form-uuid'
+            };
+            processor.prepareFormSchema(schema);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("incorrectly quotes the field ID 'height' as a string"));
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("incorrectly quotes the field ID 'weight' as a string"));
+        });
+    });
+});

package/dist/processors/encounter/encounter-processor-helper.d.ts

@@ -0,0 +1,19 @@
+import { type FormField, type FormProcessorContextProps, type OpenmrsEncounter, type PatientIdentifier, type PatientProgram, type PatientProgramPayload, type PersonAttribute } from '../../types';
+import { type FormContextProps } from '../../provider/form-provider';
+export declare function prepareEncounter(context: FormContextProps, encounterDate: Date, encounterRole: string, encounterProvider: string, location: string): OpenmrsEncounter;
+export declare function preparePatientIdentifiers(fields: FormField[], encounterLocation: string): PatientIdentifier[];
+export declare function savePatientIdentifiers(patient: fhir.Patient, identifiers: PatientIdentifier[]): Promise<import("@openmrs/esm-framework").FetchResponse<any>>[];
+export declare function preparePersonAttributes(fields: FormField[]): PersonAttribute[];
+export declare function savePersonAttributes(patient: fhir.Patient, attributes: PersonAttribute[]): Promise<import("@openmrs/esm-framework").FetchResponse<any>>[];
+export declare function preparePatientPrograms(fields: FormField[], patient: fhir.Patient, currentPatientPrograms: Array<PatientProgram>): Array<PatientProgramPayload>;
+export declare function savePatientPrograms(patientPrograms: PatientProgramPayload[]): Promise<import("@openmrs/esm-framework").FetchResponse<any>[]>;
+export declare function saveAttachments(fields: FormField[], encounter: OpenmrsEncounter, abortController: AbortController): any[] | Promise<import("@openmrs/esm-framework").FetchResponse<any>[]>;
+export declare function getMutableSessionProps(context: FormContextProps): {
+    encounterRole: string;
+    encounterProvider: string;
+    encounterDate: Date;
+    encounterLocation: string;
+};
+export declare function inferInitialValueFromDefaultFieldValue(field: FormField): any;
+export declare function hydrateRepeatField(field: FormField, encounter: OpenmrsEncounter, initialValues: Record<string, any>, context: FormProcessorContextProps): Promise<FormField[]>;
+//# sourceMappingURL=encounter-processor-helper.d.ts.map

package/dist/processors/encounter/encounter-processor-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encounter-processor-helper.d.ts","sourceRoot":"","sources":["../../../src/processors/encounter/encounter-processor-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,yBAAyB,EAC9B,KAAK,gBAAgB,EAErB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAKrB,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAQrE,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,gBAAgB,EACzB,aAAa,EAAE,IAAI,EACnB,aAAa,EAAE,MAAM,EACrB,iBAAiB,EAAE,MAAM,EACzB,QAAQ,EAAE,MAAM,oBA6DjB;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,iBAAiB,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAI7G;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,kEAI7F;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,eAAe,EAAE,CAI9E;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,kEAIxF;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,SAAS,EAAE,EACnB,OAAO,EAAE,IAAI,CAAC,OAAO,EACrB,sBAAsB,EAAE,KAAK,CAAC,cAAc,CAAC,GAC5C,KAAK,CAAC,qBAAqB,CAAC,CA+B9B;AAED,wBAAgB,mBAAmB,CAAC,eAAe,EAAE,qBAAqB,EAAE,kEAG3E;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,0EAcjH;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,gBAAgB;mBAa5B,MAAM;uBACE,MAAM;mBACd,IAAI;uBACI,MAAM;EAEjD;AA4FD,wBAAgB,sCAAsC,CAAC,KAAK,EAAE,SAAS,OAetE;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,gBAAgB,EAC3B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAClC,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,SAAS,EAAE,CAAC,CAwEtB"}

package/dist/processors/encounter/encounter-processor-helper.js

@@ -0,0 +1,293 @@
+import { createAttachment, savePatientIdentifier, savePersonAttribute, saveProgramEnrollment } from "../../api/index.js";
+import { hasRendering, hasSubmission } from "../../utils/common-utils.js";
+import dayjs from "dayjs";
+import { assignedObsIds, constructObs, voidObs } from "../../adapters/obs-adapter.js";
+import { ConceptTrue } from "../../constants.js";
+import { DefaultValueValidator } from "../../validators/default-value-validator.js";
+import { cloneRepeatField } from "../../components/repeat/helpers.js";
+import { assignedOrderIds } from "../../adapters/orders-adapter.js";
+import { assignedDiagnosesIds } from "../../adapters/encounter-diagnosis-adapter.js";
+export function prepareEncounter(context, encounterDate, encounterRole, encounterProvider, location) {
+    const { patient, formJson, domainObjectValue: encounter, formFields, visit, deletedFields } = context;
+    const allFormFields = [
+        ...formFields,
+        ...deletedFields
+    ];
+    const obsForSubmission = [];
+    prepareObs(obsForSubmission, allFormFields);
+    const ordersForSubmission = prepareOrders(allFormFields);
+    const diagnosesForSubmission = prepareDiagnosis(allFormFields);
+    let encounterForSubmission = {};
+    if (encounter) {
+        Object.assign(encounterForSubmission, encounter);
+        // update encounter providers
+        const hasCurrentProvider = encounterForSubmission.encounterProviders.findIndex((encProvider)=>encProvider.provider.uuid == encounterProvider) !== -1;
+        if (!hasCurrentProvider) {
+            encounterForSubmission.encounterProviders = [
+                ...encounterForSubmission.encounterProviders,
+                {
+                    provider: encounterProvider,
+                    encounterRole
+                }
+            ];
+        }
+        // TODO: Question: Should we be editing the location, form and visit here?
+        encounterForSubmission.encounterDatetime = encounterDate;
+        encounterForSubmission.location = location;
+        encounterForSubmission.form = {
+            uuid: formJson.uuid
+        };
+        if (visit) {
+            encounterForSubmission.visit = visit.uuid;
+        }
+        encounterForSubmission.obs = obsForSubmission;
+        encounterForSubmission.orders = ordersForSubmission;
+        encounterForSubmission.diagnoses = diagnosesForSubmission;
+    } else {
+        encounterForSubmission = {
+            patient: patient.id,
+            encounterDatetime: encounterDate,
+            location: location,
+            encounterType: formJson.encounterType,
+            encounterProviders: [
+                {
+                    provider: encounterProvider,
+                    encounterRole
+                }
+            ],
+            obs: obsForSubmission,
+            form: {
+                uuid: formJson.uuid
+            },
+            visit: visit?.uuid,
+            orders: ordersForSubmission,
+            diagnoses: diagnosesForSubmission
+        };
+    }
+    return encounterForSubmission;
+}
+export function preparePatientIdentifiers(fields, encounterLocation) {
+    return fields.filter((field)=>field.type === 'patientIdentifier' && hasSubmission(field)).map((field)=>field.meta.submission.newValue);
+}
+export function savePatientIdentifiers(patient, identifiers) {
+    return identifiers.map((patientIdentifier)=>{
+        return savePatientIdentifier(patientIdentifier, patient.id);
+    });
+}
+export function preparePersonAttributes(fields) {
+    return fields.filter((field)=>field.type === 'personAttribute' && hasSubmission(field)).map((field)=>field.meta.submission.newValue);
+}
+export function savePersonAttributes(patient, attributes) {
+    return attributes.map((personAttribute)=>{
+        return savePersonAttribute(personAttribute, patient.id);
+    });
+}
+export function preparePatientPrograms(fields, patient, currentPatientPrograms) {
+    const programStateFields = fields.filter((field)=>field.type === 'programState' && hasSubmission(field));
+    const programMap = new Map();
+    programStateFields.forEach((field)=>{
+        const programUuid = field.questionOptions.programUuid;
+        const newState = field.meta.submission.newValue;
+        const existingProgramEnrollment = currentPatientPrograms.find((program)=>program.program.uuid === programUuid);
+        if (existingProgramEnrollment) {
+            if (programMap.has(programUuid)) {
+                programMap.get(programUuid).states.push(newState);
+            } else {
+                programMap.set(programUuid, {
+                    uuid: existingProgramEnrollment.uuid,
+                    states: [
+                        newState
+                    ]
+                });
+            }
+        } else {
+            if (programMap.has(programUuid)) {
+                programMap.get(programUuid).states.push(newState);
+            } else {
+                programMap.set(programUuid, {
+                    patient: patient.id,
+                    program: programUuid,
+                    states: [
+                        newState
+                    ],
+                    dateEnrolled: dayjs().format()
+                });
+            }
+        }
+    });
+    return Array.from(programMap.values());
+}
+export function savePatientPrograms(patientPrograms) {
+    const ac = new AbortController();
+    return Promise.all(patientPrograms.map((programPayload)=>saveProgramEnrollment(programPayload, ac)));
+}
+export function saveAttachments(fields, encounter, abortController) {
+    const complexFields = fields?.filter((field)=>field?.questionOptions.rendering === 'file' && hasSubmission(field));
+    if (!complexFields?.length) {
+        return [];
+    }
+    const allPromises = complexFields.flatMap((field)=>{
+        const patientUuid = typeof encounter?.patient === 'string' ? encounter?.patient : encounter?.patient?.uuid;
+        const attachments = field.meta.submission.newValue ?? [];
+        return attachments.map((attachment)=>createAttachment(patientUuid, encounter.uuid, attachment));
+    });
+    return Promise.all(allPromises);
+}
+export function getMutableSessionProps(context) {
+    const { formFields, location, currentProvider, customDependencies, domainObjectValue: encounter } = context;
+    const { defaultEncounterRole } = customDependencies;
+    const encounterRole = formFields.find((field)=>field.type === 'encounterRole')?.meta.submission?.newValue || defaultEncounterRole?.uuid;
+    const encounterProvider = formFields.find((field)=>field.type === 'encounterProvider')?.meta.submission?.newValue || currentProvider.uuid;
+    const encounterDate = formFields.find((field)=>field.type === 'encounterDatetime')?.meta.submission?.newValue;
+    const encounterLocation = formFields.find((field)=>field.type === 'encounterLocation')?.meta.submission?.newValue || encounter?.location?.uuid || location.uuid;
+    return {
+        encounterRole: encounterRole,
+        encounterProvider: encounterProvider,
+        encounterDate: encounterDate,
+        encounterLocation: encounterLocation
+    };
+}
+// Helpers
+function prepareObs(obsForSubmission, fields) {
+    fields.filter((field)=>hasSubmittableObs(field)).forEach((field)=>processObsField(obsForSubmission, field));
+}
+function processObsField(obsForSubmission, field) {
+    if ((field.isHidden || field.isParentHidden) && field.meta.initialValue.omrsObject) {
+        const valuesArray = Array.isArray(field.meta.initialValue.omrsObject) ? field.meta.initialValue.omrsObject : [
+            field.meta.initialValue.omrsObject
+        ];
+        addObsToList(obsForSubmission, valuesArray.map((obs)=>voidObs(obs)));
+        return;
+    }
+    if (field.type === 'obsGroup') {
+        processObsGroup(obsForSubmission, field);
+        return;
+    }
+    // new attachments will be processed later
+    if (!hasRendering(field, 'file')) {
+        addObsToList(obsForSubmission, field.meta.submission.newValue);
+    }
+    addObsToList(obsForSubmission, field.meta.submission.voidedValue);
+}
+function processObsGroup(obsForSubmission, groupField) {
+    if (groupField.meta.submission?.voidedValue) {
+        addObsToList(obsForSubmission, groupField.meta.submission.voidedValue);
+        return;
+    }
+    const obsGroup = constructObs(groupField, null);
+    if (groupField.meta.initialValue?.omrsObject) {
+        obsGroup.uuid = groupField.meta.initialValue.omrsObject.uuid;
+    }
+    groupField.questions.forEach((nestedField)=>{
+        if (nestedField.type === 'obsGroup') {
+            const nestedObsGroup = [];
+            processObsGroup(nestedObsGroup, nestedField);
+            addObsToList(obsGroup.groupMembers, nestedObsGroup);
+        } else if (hasSubmission(nestedField)) {
+            addObsToList(obsGroup.groupMembers, nestedField.meta.submission.newValue);
+            addObsToList(obsGroup.groupMembers, nestedField.meta.submission.voidedValue);
+        }
+    });
+    if (obsGroup.groupMembers?.length || obsGroup.voided) {
+        addObsToList(obsForSubmission, obsGroup);
+    }
+}
+function prepareOrders(fields) {
+    return fields.filter((field)=>field.type === 'testOrder' && hasSubmission(field)).flatMap((field)=>[
+            field.meta.submission.newValue,
+            field.meta.submission.voidedValue
+        ]).filter((o)=>o);
+}
+function addObsToList(obsList, obs) {
+    if (!obs) {
+        return;
+    }
+    if (Array.isArray(obs)) {
+        obsList.push(...obs);
+    } else {
+        obsList.push(obs);
+    }
+}
+function hasSubmittableObs(field) {
+    const { questionOptions: { isTransient }, type } = field;
+    if (isTransient || ![
+        'obs',
+        'obsGroup'
+    ].includes(type) || field.meta.groupId) {
+        return false;
+    }
+    if ((field.isHidden || field.isParentHidden) && field.meta.initialValue?.omrsObject) {
+        return true;
+    }
+    return !field.isHidden && !field.isParentHidden && (type === 'obsGroup' || hasSubmission(field));
+}
+export function inferInitialValueFromDefaultFieldValue(field) {
+    if (field.questionOptions.rendering == 'toggle' && typeof field.questionOptions.defaultValue != 'boolean') {
+        return field.questionOptions.defaultValue == ConceptTrue;
+    }
+    // validate default value
+    const errors = DefaultValueValidator.validate(field, field.questionOptions.defaultValue);
+    if (errors.length) {
+        console.error(`Default value validation errors for field "${field.id}" with value "${field.questionOptions.defaultValue}":`, errors);
+        return null;
+    }
+    return field.questionOptions.defaultValue;
+}
+export async function hydrateRepeatField(field, encounter, initialValues, context) {
+    let counter = 1;
+    const { formFieldAdapters } = context;
+    const unMappedGroups = encounter.obs.filter((obs)=>obs.concept.uuid === field.questionOptions.concept && obs.uuid != field.meta.initialValue?.omrsObject?.uuid && !assignedObsIds.includes(obs.uuid));
+    const unMappedOrders = encounter.orders.filter((order)=>{
+        const availableOrderables = field.questionOptions.answers?.map((answer)=>answer.concept) || [];
+        return availableOrderables.includes(order.concept?.uuid) && !assignedOrderIds.includes(order.uuid);
+    });
+    if (field.type === 'testOrder') {
+        return Promise.all(unMappedOrders.filter((order)=>!order.voided).map(async (order)=>{
+            const clone = cloneRepeatField(field, order, counter++);
+            initialValues[clone.id] = await formFieldAdapters[field.type].getInitialValue(clone, {
+                orders: [
+                    order
+                ]
+            }, context);
+            return clone;
+        }));
+    }
+    const unMappedDiagnoses = encounter.diagnoses.filter((diagnosis)=>{
+        return !diagnosis.voided && !assignedDiagnosesIds.includes(diagnosis?.diagnosis?.coded.uuid) && diagnosis.formFieldPath.startsWith(`rfe-forms-${field.id}_`);
+    });
+    if (field.type === 'diagnosis') {
+        return Promise.all(unMappedDiagnoses.map(async (diagnosis)=>{
+            const idSuffix = parseInt(diagnosis.formFieldPath.split('_')[1]);
+            const clone = cloneRepeatField(field, diagnosis, idSuffix);
+            initialValues[clone.id] = await formFieldAdapters[field.type].getInitialValue(clone, {
+                diagnoses: [
+                    diagnosis
+                ]
+            }, context);
+            if (!assignedDiagnosesIds.includes(diagnosis.diagnosis.coded.uuid)) {
+                assignedDiagnosesIds.push(diagnosis.diagnosis.coded.uuid);
+            }
+            return clone;
+        }));
+    }
+    // handle obs groups
+    return Promise.all(unMappedGroups.map(async (group)=>{
+        const clone = cloneRepeatField(field, group, counter++);
+        await Promise.all(clone.questions.map(async (childField)=>{
+            initialValues[childField.id] = await formFieldAdapters[field.type].getInitialValue(childField, {
+                obs: [
+                    group
+                ]
+            }, context);
+        }));
+        assignedObsIds.push(group.uuid);
+        return [
+            clone,
+            ...clone.questions
+        ];
+    })).then((results)=>results.flat());
+}
+function prepareDiagnosis(fields) {
+    const diagnoses = fields.filter((field)=>field.type === 'diagnosis' && hasSubmission(field)).map((field)=>field.meta.submission.newValue || field.meta.submission.voidedValue).filter((o)=>o);
+    return diagnoses;
+}

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

@@ -0,0 +1,25 @@
+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;
+export type GetCustomHooksResponse = {
+    useCustomHooks: (context: Partial<FormProcessorContextProps>) => {
+        data: any;
+        isLoading: boolean;
+        error: any;
+        updateContext: (setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>) => void;
+    };
+};
+export declare abstract class FormProcessor {
+    formJson: FormSchema;
+    domainObjectValue: OpenmrsResource;
+    constructor(formJson: FormSchema);
+    getDomainObject(): OpenmrsResource;
+    loadDependencies(context: Partial<FormProcessorContextProps>, setContext: React.Dispatch<React.SetStateAction<FormProcessorContextProps>>): 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>>;
+    abstract getCustomHooks(): GetCustomHooksResponse;
+    abstract prepareFormSchema(schema: FormSchema): FormSchema;
+}
+//# sourceMappingURL=form-processor.d.ts.map

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

@@ -0,0 +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"}

package/dist/processors/form-processor.js

@@ -0,0 +1,26 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+export class FormProcessor {
+    getDomainObject() {
+        return this.domainObjectValue;
+    }
+    async loadDependencies(context, setContext) {
+        return Promise.resolve({});
+    }
+    constructor(formJson){
+        _define_property(this, "formJson", void 0);
+        _define_property(this, "domainObjectValue", void 0);
+        this.formJson = formJson;
+    }
+}

package/dist/provider/form-factory-helper.d.ts

@@ -0,0 +1,8 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from './form-provider';
+import { type PostSubmissionActionMeta } from '../hooks/usePostSubmissionActions';
+import { type TFunction } from 'i18next';
+import { type SessionMode } from '../types';
+export declare function validateForm(context: FormContextProps): boolean;
+export declare function processPostSubmissionActions(postSubmissionHandlers: PostSubmissionActionMeta[], submissionResults: OpenmrsResource[], patient: fhir.Patient, sessionMode: SessionMode, t: TFunction): Promise<void[]>;
+//# sourceMappingURL=form-factory-helper.d.ts.map

package/dist/provider/form-factory-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-factory-helper.d.ts","sourceRoot":"","sources":["../../src/provider/form-factory-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAgB,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGxD,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,wBAAgB,YAAY,CAAC,OAAO,EAAE,gBAAgB,WAwCrD;AAED,wBAAsB,4BAA4B,CAChD,sBAAsB,EAAE,wBAAwB,EAAE,EAClD,iBAAiB,EAAE,eAAe,EAAE,EACpC,OAAO,EAAE,IAAI,CAAC,OAAO,EACrB,WAAW,EAAE,WAAW,EACxB,CAAC,EAAE,SAAS,mBAkDb"}