@olaboot/esm-form-engine-lib 4.1.0

package/dist/adapters/obs-comment-adapter.d.ts

@@ -0,0 +1,4 @@
+import { type FormField, type FormFieldValueAdapter } from '../types';
+export declare const ObsCommentAdapter: FormFieldValueAdapter;
+export declare function isNewSubmissionEffective(targetField: FormField, targetFieldCurrentValue: any): boolean;
+//# sourceMappingURL=obs-comment-adapter.d.ts.map

package/dist/adapters/obs-comment-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"obs-comment-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/obs-comment-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,qBAAqB,EAAkC,MAAM,UAAU,CAAC;AAKtG,eAAO,MAAM,iBAAiB,EAAE,qBA8C/B,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,SAAS,EAAE,uBAAuB,EAAE,GAAG,WAK5F"}

package/dist/adapters/obs-comment-adapter.js

@@ -0,0 +1,52 @@
+import { hasSubmission } from "../utils/common-utils.js";
+import { isEmpty } from "../validators/form-validator.js";
+import { editObs, hasPreviousObsValueChanged } from "./obs-adapter.js";
+export const ObsCommentAdapter = {
+    transformFieldValue: function(field, value, context) {
+        const targetField = context.getFormField(field.meta.targetField);
+        const targetFieldCurrentValue = context.methods.getValues(targetField.id);
+        const targetFieldInitialObs = targetField.meta.initialValue?.omrsObject;
+        if (targetField.meta.submission?.newValue) {
+            if (isEmpty(value) && !isNewSubmissionEffective(targetField, targetFieldCurrentValue)) {
+                // clear submission
+                targetField.meta.submission.newValue = null;
+            } else {
+                targetField.meta.submission.newValue.comment = value;
+            }
+        } else if (!hasSubmission(targetField) && targetFieldInitialObs) {
+            if (isEmpty(value) && isEmpty(targetFieldInitialObs.comment)) {
+                return null;
+            }
+            // generate submission
+            const newSubmission = editObs(targetField, targetFieldCurrentValue);
+            targetField.meta.submission = {
+                newValue: {
+                    ...newSubmission,
+                    comment: value
+                }
+            };
+        }
+        return null;
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        const encounter = sourceObject ?? context.domainObjectValue;
+        if (encounter) {
+            const targetFieldId = field.id.split('_obs_comment')[0];
+            const targetField = context.formFields.find((field)=>field.id === targetFieldId);
+            return targetField?.meta.initialValue.omrsObject?.comment;
+        }
+        return null;
+    },
+    getPreviousValue: function(field, sourceObject, context) {
+        return null;
+    },
+    getDisplayValue: function(field, value) {
+        return value;
+    },
+    tearDown: function() {
+        return;
+    }
+};
+export function isNewSubmissionEffective(targetField, targetFieldCurrentValue) {
+    return hasPreviousObsValueChanged(targetField, targetFieldCurrentValue) || !isEmpty(targetField.meta.submission.newValue.obsDatetime);
+}

package/dist/adapters/orders-adapter.d.ts

@@ -0,0 +1,4 @@
+import { type FormFieldValueAdapter } from '..';
+export declare let assignedOrderIds: string[];
+export declare const OrdersAdapter: FormFieldValueAdapter;
+//# sourceMappingURL=orders-adapter.d.ts.map

package/dist/adapters/orders-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orders-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/orders-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,qBAAqB,EAAkC,MAAM,IAAI,CAAC;AAKhF,eAAO,IAAI,gBAAgB,EAAE,MAAM,EAAO,CAAC;AAI3C,eAAO,MAAM,aAAa,EAAE,qBA4C3B,CAAC"}

package/dist/adapters/orders-adapter.js

@@ -0,0 +1,64 @@
+import { clearSubmission, gracefullySetSubmission } from "../utils/common-utils.js";
+export let assignedOrderIds = [];
+const defaultOrderType = 'testorder';
+const defaultCareSetting = '6f0c9a92-6f24-11e3-af88-005056821db0';
+export const OrdersAdapter = {
+    transformFieldValue: function(field, value, context) {
+        if (context.sessionMode == 'edit' && field.meta.initialValue?.omrsObject) {
+            return editOrder(value, field, context.currentProvider.uuid);
+        }
+        const newValue = constructNewOrder(value, field, context.currentProvider.uuid);
+        gracefullySetSubmission(field, newValue, null);
+        return newValue;
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        const availableOrderables = field.questionOptions.answers?.map((answer)=>answer.concept) || [];
+        const matchedOrder = sourceObject?.orders.filter((order)=>!assignedOrderIds.includes(order.uuid) && !order.voided).find((order)=>availableOrderables.includes(order.concept.uuid));
+        if (matchedOrder) {
+            field.meta = {
+                ...field.meta || {},
+                initialValue: {
+                    omrsObject: matchedOrder,
+                    refinedValue: matchedOrder.concept.uuid
+                }
+            };
+            assignedOrderIds.push(matchedOrder.uuid);
+            return matchedOrder.concept.uuid;
+        }
+        return null;
+    },
+    getPreviousValue: function(field, sourceObject, context) {
+        return null;
+    },
+    getDisplayValue: (field, value)=>{
+        return field.questionOptions.answers?.find((option)=>option.concept == value)?.label || value;
+    },
+    tearDown: function() {
+        assignedOrderIds = [];
+    }
+};
+function constructNewOrder(value, field, orderer) {
+    if (!value) {
+        return null;
+    }
+    return {
+        action: 'NEW',
+        concept: value,
+        type: field?.questionOptions?.orderType || defaultOrderType,
+        careSetting: field?.questionOptions?.orderSettingUuid || defaultCareSetting,
+        orderer: orderer
+    };
+}
+function editOrder(newOrder, field, orderer) {
+    const previousOrder = field.meta.initialValue?.omrsObject;
+    if (newOrder === previousOrder?.concept?.uuid) {
+        clearSubmission(field);
+        return null;
+    }
+    const voided = {
+        uuid: previousOrder?.uuid,
+        voided: true
+    };
+    gracefullySetSubmission(field, constructNewOrder(newOrder, field, orderer), voided);
+    return field.meta.submission.newValue || null;
+}

package/dist/adapters/patient-identifier-adapter.d.ts

@@ -0,0 +1,3 @@
+import { type FormFieldValueAdapter } from '../types';
+export declare const PatientIdentifierAdapter: FormFieldValueAdapter;
+//# sourceMappingURL=patient-identifier-adapter.d.ts.map

package/dist/adapters/patient-identifier-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patient-identifier-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/patient-identifier-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,qBAAqB,EAAkC,MAAM,UAAU,CAAC;AAItG,eAAO,MAAM,wBAAwB,EAAE,qBAuCtC,CAAC"}

package/dist/adapters/patient-identifier-adapter.js

@@ -0,0 +1,40 @@
+import { clearSubmission } from "../utils/common-utils.js";
+import { isEmpty } from "../validators/form-validator.js";
+export const PatientIdentifierAdapter = {
+    transformFieldValue: function(field, value, context) {
+        clearSubmission(field);
+        if (field.meta.initialValue?.refinedValue === value || isEmpty(value)) {
+            return null;
+        }
+        field.meta.submission.newValue = {
+            identifier: value,
+            identifierType: field.questionOptions.identifierType,
+            uuid: field.meta.initialValue?.omrsObject?.id,
+            location: context.location
+        };
+        return field.meta.submission.newValue;
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        const latestIdentifier = context.patient?.identifier?.find((identifier)=>identifier.type?.coding[0]?.code === field.questionOptions.identifierType);
+        field.meta = {
+            ...field.meta || {},
+            initialValue: {
+                omrsObject: latestIdentifier,
+                refinedValue: latestIdentifier?.value
+            }
+        };
+        return latestIdentifier?.value;
+    },
+    getPreviousValue: function(field, sourceObject, context) {
+        return null;
+    },
+    getDisplayValue: function(field, value) {
+        if (value?.display) {
+            return value.display;
+        }
+        return value;
+    },
+    tearDown: function() {
+        return;
+    }
+};

package/dist/adapters/person-attribute-adapter.d.ts

@@ -0,0 +1,3 @@
+import { type FormFieldValueAdapter } from '../types';
+export declare const PersonAttributeAdapter: FormFieldValueAdapter;
+//# sourceMappingURL=person-attribute-adapter.d.ts.map

package/dist/adapters/person-attribute-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"person-attribute-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/person-attribute-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,qBAAqB,EAAkC,MAAM,UAAU,CAAC;AAItG,eAAO,MAAM,sBAAsB,EAAE,qBAsCpC,CAAC"}

package/dist/adapters/person-attribute-adapter.js

@@ -0,0 +1,39 @@
+import { clearSubmission } from "../utils/common-utils.js";
+import { isEmpty } from "../validators/form-validator.js";
+export const PersonAttributeAdapter = {
+    transformFieldValue: function(field, value, context) {
+        clearSubmission(field);
+        if (field.meta.initialValue?.refinedValue === value || isEmpty(value)) {
+            return null;
+        }
+        field.meta.submission.newValue = {
+            value: value,
+            attributeType: field.questionOptions.attributeType,
+            uuid: field.meta.initialValue?.omrsObject?.uuid
+        };
+        return field.meta.submission.newValue;
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        const latestAttribute = context.patient?.extension?.find((ext)=>ext.url === `http://fhir.openmrs.org/ext/person-attribute/${field.questionOptions.attributeType}`);
+        field.meta = {
+            ...field.meta,
+            initialValue: {
+                omrsObject: latestAttribute,
+                refinedValue: latestAttribute?.valueString || latestAttribute?.valueReference?.reference
+            }
+        };
+        return field.meta.initialValue.refinedValue;
+    },
+    getPreviousValue: function(field, sourceObject, context) {
+        return null;
+    },
+    getDisplayValue: function(field, value) {
+        if (value?.display) {
+            return value.display;
+        }
+        return value;
+    },
+    tearDown: function() {
+        return;
+    }
+};

package/dist/adapters/person-attribute-adapter.test.js

@@ -0,0 +1,146 @@
+import { PersonAttributeAdapter } from "./person-attribute-adapter.js";
+describe('PersonAttributeAdapter', ()=>{
+    const mockField = {
+        id: 'test-person-attribute',
+        type: 'personAttribute',
+        questionOptions: {
+            attributeType: '7ef225db-94db-4e40-9dd8-fb121d9dc370',
+            rendering: 'text'
+        },
+        meta: {}
+    };
+    const mockContext = {
+        patient: {
+            id: 'test-patient-uuid'
+        }
+    };
+    describe('transformFieldValue', ()=>{
+        it('should return null for empty value', ()=>{
+            const result = PersonAttributeAdapter.transformFieldValue(mockField, '', mockContext);
+            expect(result).toBeNull();
+        });
+        it('should return null when value equals initial value', ()=>{
+            const field = {
+                ...mockField,
+                meta: {
+                    submission: {},
+                    initialValue: {
+                        omrsObject: null,
+                        refinedValue: 'test-value'
+                    }
+                }
+            };
+            const result = PersonAttributeAdapter.transformFieldValue(field, 'test-value', mockContext);
+            expect(result).toBeNull();
+        });
+        it('should transform field value correctly for new attribute', ()=>{
+            const field = {
+                ...mockField
+            };
+            const result = PersonAttributeAdapter.transformFieldValue(field, 'new-attribute-value', mockContext);
+            expect(result).toEqual({
+                value: 'new-attribute-value',
+                attributeType: '7ef225db-94db-4e40-9dd8-fb121d9dc370',
+                uuid: undefined
+            });
+        });
+        it('should include uuid when updating existing attribute', ()=>{
+            const field = {
+                ...mockField,
+                meta: {
+                    submission: {},
+                    initialValue: {
+                        omrsObject: {
+                            uuid: 'existing-attr-uuid'
+                        },
+                        refinedValue: 'old-value'
+                    }
+                }
+            };
+            const result = PersonAttributeAdapter.transformFieldValue(field, 'updated-value', mockContext);
+            expect(result).toEqual({
+                value: 'updated-value',
+                attributeType: '7ef225db-94db-4e40-9dd8-fb121d9dc370',
+                uuid: 'existing-attr-uuid'
+            });
+        });
+    });
+    describe('getInitialValue', ()=>{
+        it('should return undefined when no person attribute exists', ()=>{
+            const mockProcessorContext = {
+                patient: {
+                    id: 'test-patient',
+                    extension: []
+                }
+            };
+            const result = PersonAttributeAdapter.getInitialValue(mockField, null, mockProcessorContext);
+            expect(result).toBeUndefined();
+        });
+        it('should return valueString when person attribute exists', ()=>{
+            const mockProcessorContext = {
+                patient: {
+                    id: 'test-patient',
+                    extension: [
+                        {
+                            url: 'http://fhir.openmrs.org/ext/person-attribute/7ef225db-94db-4e40-9dd8-fb121d9dc370',
+                            valueString: 'test-attribute-value'
+                        }
+                    ]
+                }
+            };
+            const field = {
+                ...mockField
+            };
+            const result = PersonAttributeAdapter.getInitialValue(field, null, mockProcessorContext);
+            expect(result).toBe('test-attribute-value');
+            expect(field.meta.initialValue.refinedValue).toBe('test-attribute-value');
+        });
+        it('should return valueReference when person attribute has reference', ()=>{
+            const mockProcessorContext = {
+                patient: {
+                    id: 'test-patient',
+                    extension: [
+                        {
+                            url: 'http://fhir.openmrs.org/ext/person-attribute/7ef225db-94db-4e40-9dd8-fb121d9dc370',
+                            valueReference: {
+                                reference: 'Location/test-location-uuid'
+                            }
+                        }
+                    ]
+                }
+            };
+            const field = {
+                ...mockField
+            };
+            const result = PersonAttributeAdapter.getInitialValue(field, null, mockProcessorContext);
+            expect(result).toBe('Location/test-location-uuid');
+            expect(field.meta.initialValue.refinedValue).toBe('Location/test-location-uuid');
+        });
+    });
+    describe('getPreviousValue', ()=>{
+        it('should return null', ()=>{
+            const result = PersonAttributeAdapter.getPreviousValue(mockField, null, {});
+            expect(result).toBeNull();
+        });
+    });
+    describe('getDisplayValue', ()=>{
+        it('should return display property if present', ()=>{
+            const value = {
+                display: 'Test Display',
+                value: 'test-value'
+            };
+            const result = PersonAttributeAdapter.getDisplayValue(mockField, value);
+            expect(result).toBe('Test Display');
+        });
+        it('should return value as-is if no display property', ()=>{
+            const value = 'simple-value';
+            const result = PersonAttributeAdapter.getDisplayValue(mockField, value);
+            expect(result).toBe('simple-value');
+        });
+    });
+    describe('tearDown', ()=>{
+        it('should execute without errors', ()=>{
+            expect(()=>PersonAttributeAdapter.tearDown()).not.toThrow();
+        });
+    });
+});

package/dist/adapters/program-state-adapter.d.ts

@@ -0,0 +1,3 @@
+import { type FormFieldValueAdapter } from '../types';
+export declare const ProgramStateAdapter: FormFieldValueAdapter;
+//# sourceMappingURL=program-state-adapter.d.ts.map

package/dist/adapters/program-state-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program-state-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/program-state-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkD,KAAK,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAKtG,eAAO,MAAM,mBAAmB,EAAE,qBAiDjC,CAAC"}

package/dist/adapters/program-state-adapter.js

@@ -0,0 +1,41 @@
+import dayjs from "dayjs";
+import { clearSubmission } from "../utils/common-utils.js";
+import { isEmpty } from "../validators/form-validator.js";
+export const ProgramStateAdapter = {
+    transformFieldValue: function(field, value, context) {
+        clearSubmission(field);
+        if (field.meta?.initialValue?.omrsObject?.uuid === value || isEmpty(value)) {
+            return null;
+        }
+        field.meta.submission.newValue = {
+            state: value,
+            startDate: dayjs().format()
+        };
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        const program = context.customDependencies.patientPrograms?.find((program)=>program.program.uuid === field.questionOptions.programUuid);
+        if (program?.states?.length > 0) {
+            const currentState = program.states.filter((state)=>!state.endDate).find((state)=>state.state.programWorkflow?.uuid === field.questionOptions.workflowUuid)?.state;
+            field.meta = {
+                ...field.meta || {},
+                initialValue: {
+                    omrsObject: currentState
+                }
+            };
+            return currentState?.uuid;
+        }
+        return null;
+    },
+    getPreviousValue: function(field, sourceObject, context) {
+        return null;
+    },
+    getDisplayValue: function(field, value) {
+        if (value?.display) {
+            return value.display;
+        }
+        return value;
+    },
+    tearDown: function() {
+        return;
+    }
+};