@openmrs/esm-form-engine-lib 4.0.1-pre.2260 → 4.0.1-pre.2265

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

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

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

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

package/dist/adapters/control-adapter.js

@@ -0,0 +1,17 @@
+export const ControlAdapter = {
+    getDisplayValue: (field, value)=>{
+        return value;
+    },
+    transformFieldValue: function(field, value, context) {
+        return null;
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        return null;
+    },
+    getPreviousValue: function(field, sourceObject, context) {
+        return null;
+    },
+    tearDown: function() {
+        return;
+    }
+};

package/dist/adapters/encounter-datetime-adapter.d.ts

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

package/dist/adapters/encounter-datetime-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encounter-datetime-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/encounter-datetime-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,qBAAqB,EAE3B,MAAM,UAAU,CAAC;AAGlB,eAAO,MAAM,wBAAwB,EAAE,qBA2BtC,CAAC"}

package/dist/adapters/encounter-datetime-adapter.js

@@ -0,0 +1,26 @@
+import { formatDate } from "@openmrs/esm-framework";
+import { gracefullySetSubmission } from "../utils/common-utils.js";
+export const EncounterDatetimeAdapter = {
+    transformFieldValue: function(field, value, context) {
+        gracefullySetSubmission(field, value, null);
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        return sourceObject?.encounterDatetime ? new Date(sourceObject.encounterDatetime) : context.sessionDate;
+    },
+    getPreviousValue: function(field, sourceObject, context) {
+        if (sourceObject?.encounterDatetime) {
+            const date = new Date(sourceObject.encounterDatetime);
+            return {
+                value: date,
+                display: this.getDisplayValue(field, date)
+            };
+        }
+        return null;
+    },
+    getDisplayValue: function(field, value) {
+        return formatDate(value);
+    },
+    tearDown: function() {
+        return;
+    }
+};

package/dist/adapters/encounter-diagnosis-adapter.d.ts

@@ -0,0 +1,10 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormFieldValueAdapter } from '../types';
+export declare let assignedDiagnosesIds: string[];
+export declare const EncounterDiagnosisAdapter: FormFieldValueAdapter;
+export declare function hasPreviousDiagnosisValueChanged(previousDiagnosis: OpenmrsResource, newValue: string): boolean;
+export declare function voidDiagnosis(diagnosis: OpenmrsResource): {
+    uuid: string;
+    voided: boolean;
+};
+//# sourceMappingURL=encounter-diagnosis-adapter.d.ts.map

package/dist/adapters/encounter-diagnosis-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encounter-diagnosis-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/encounter-diagnosis-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAEL,KAAK,qBAAqB,EAI3B,MAAM,UAAU,CAAC;AAMlB,eAAO,IAAI,oBAAoB,EAAE,MAAM,EAAO,CAAC;AAE/C,eAAO,MAAM,yBAAyB,EAAE,qBAyDvC,CAAC;AAuCF,wBAAgB,gCAAgC,CAAC,iBAAiB,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,WAKpG;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,eAAe;;;EAEvD"}

package/dist/adapters/encounter-diagnosis-adapter.js

@@ -0,0 +1,89 @@
+import { gracefullySetSubmission } from "../utils/common-utils.js";
+import { isEmpty } from "../validators/form-validator.js";
+import { isTrue } from "../utils/boolean-utils.js";
+export let assignedDiagnosesIds = [];
+export const EncounterDiagnosisAdapter = {
+    transformFieldValue: function(field, value, context) {
+        if (field.meta.initialValue?.omrsObject && isEmpty(value)) {
+            return gracefullySetSubmission(field, undefined, voidDiagnosis(field.meta.initialValue.omrsObject));
+        }
+        if (!isEmpty(value)) {
+            const previousDiagnosis = field.meta.initialValue?.omrsObject;
+            if (hasPreviousDiagnosisValueChanged(previousDiagnosis, value)) {
+                return gracefullySetSubmission(field, editDiagnosis(value, field, previousDiagnosis, context.patient.id), undefined);
+            }
+        }
+        const newValue = constructNewDiagnosis(value, field, context.patient.id);
+        gracefullySetSubmission(field, newValue, null);
+        return newValue;
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        const encounter = sourceObject ?? context.domainObjectValue;
+        const matchedDiagnosis = encounter.diagnoses.find((diagnosis)=>diagnosis.formFieldPath === `rfe-forms-${field.id}`);
+        if (matchedDiagnosis) {
+            field.meta = {
+                ...field.meta || {},
+                initialValue: {
+                    omrsObject: matchedDiagnosis,
+                    refinedValue: matchedDiagnosis.diagnosis?.coded.uuid
+                }
+            };
+            if (!assignedDiagnosesIds.includes(matchedDiagnosis.diagnosis?.coded?.uuid)) {
+                assignedDiagnosesIds.push(matchedDiagnosis.diagnosis?.coded?.uuid);
+            }
+            return matchedDiagnosis.diagnosis?.coded.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() {
+        assignedDiagnosesIds = [];
+    }
+};
+const constructNewDiagnosis = (value, field, patientUuid)=>{
+    if (!value) {
+        return null;
+    }
+    return {
+        patient: patientUuid,
+        condition: null,
+        diagnosis: {
+            coded: value
+        },
+        certainty: isTrue(field.questionOptions?.diagnosis?.isConfirmed) ? 'CONFIRMED' : 'PROVISIONAL',
+        rank: field.questionOptions.diagnosis?.rank ?? 1,
+        formFieldPath: `rfe-forms-${field.id}`,
+        formFieldNamespace: 'rfe-forms'
+    };
+};
+function editDiagnosis(newEncounterDiagnosis, field, previousDiagnosis, patientUuid) {
+    return {
+        patient: patientUuid,
+        condition: null,
+        diagnosis: {
+            coded: newEncounterDiagnosis
+        },
+        certainty: isTrue(field.questionOptions?.diagnosis?.isConfirmed) ? 'CONFIRMED' : 'PROVISIONAL',
+        rank: field.questionOptions.diagnosis?.rank ?? 1,
+        formFieldPath: `rfe-forms-${field.id}`,
+        formFieldNamespace: 'rfe-forms',
+        uuid: previousDiagnosis.uuid
+    };
+}
+export function hasPreviousDiagnosisValueChanged(previousDiagnosis, newValue) {
+    if (isEmpty(previousDiagnosis)) {
+        return false;
+    }
+    return previousDiagnosis.value !== newValue;
+}
+export function voidDiagnosis(diagnosis) {
+    return {
+        uuid: diagnosis.uuid,
+        voided: true
+    };
+}

package/dist/adapters/encounter-location-adapter.d.ts

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

package/dist/adapters/encounter-location-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encounter-location-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/encounter-location-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,qBAAqB,EAE3B,MAAM,UAAU,CAAC;AAGlB,eAAO,MAAM,wBAAwB,EAAE,qBA4BtC,CAAC"}

package/dist/adapters/encounter-location-adapter.js

@@ -0,0 +1,25 @@
+import { gracefullySetSubmission } from "../utils/common-utils.js";
+export const EncounterLocationAdapter = {
+    transformFieldValue: function(field, value, context) {
+        gracefullySetSubmission(field, value, null);
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        if (sourceObject && sourceObject['location']?.uuid) {
+            return sourceObject['location'].uuid;
+        }
+        return context.location.uuid;
+    },
+    getPreviousValue: function(field, sourceObject, context) {
+        const encounter = sourceObject ?? context.previousDomainObjectValue;
+        return {
+            value: encounter?.location?.uuid,
+            display: encounter?.location?.name
+        };
+    },
+    getDisplayValue: function(field, value) {
+        return value;
+    },
+    tearDown: function() {
+        return;
+    }
+};

package/dist/adapters/encounter-provider-adapter.d.ts

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

package/dist/adapters/encounter-provider-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encounter-provider-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/encounter-provider-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,qBAAqB,EAE3B,MAAM,UAAU,CAAC;AAGlB,eAAO,MAAM,wBAAwB,EAAE,qBA6BtC,CAAC"}

package/dist/adapters/encounter-provider-adapter.js

@@ -0,0 +1,34 @@
+import { gracefullySetSubmission } from "../utils/common-utils.js";
+export const EncounterProviderAdapter = {
+    transformFieldValue: function(field, value, context) {
+        gracefullySetSubmission(field, value, null);
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        const encounter = sourceObject ?? context.previousDomainObjectValue;
+        return getLatestProvider(encounter)?.uuid;
+    },
+    getPreviousValue: function(field, sourceObject, context) {
+        const encounter = sourceObject ?? context.previousDomainObjectValue;
+        const provider = getLatestProvider(encounter);
+        return {
+            value: provider?.uuid,
+            display: provider?.name
+        };
+    },
+    getDisplayValue: function(field, value) {
+        if (value?.display) {
+            return value.display;
+        }
+        return value;
+    },
+    tearDown: function() {
+        return;
+    }
+};
+function getLatestProvider(encounter) {
+    if (encounter && encounter['encounterProviders']?.length) {
+        const lastProviderIndex = encounter['encounterProviders'].length - 1;
+        return encounter['encounterProviders'][lastProviderIndex].provider;
+    }
+    return null;
+}

package/dist/adapters/encounter-role-adapter.d.ts

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

package/dist/adapters/encounter-role-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encounter-role-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/encounter-role-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,qBAAqB,EAE3B,MAAM,UAAU,CAAC;AAGlB,eAAO,MAAM,oBAAoB,EAAE,qBAmClC,CAAC"}

package/dist/adapters/encounter-role-adapter.js

@@ -0,0 +1,40 @@
+import { gracefullySetSubmission } from "../utils/common-utils.js";
+export const EncounterRoleAdapter = {
+    transformFieldValue: function(field, value, context) {
+        gracefullySetSubmission(field, value, null);
+    },
+    getInitialValue: function(field, sourceObject, context) {
+        const encounter = sourceObject ?? context.domainObjectValue;
+        if (encounter) {
+            return getLatestEncounterRole(encounter)?.uuid;
+        }
+        return context.customDependencies.defaultEncounterRole.uuid;
+    },
+    getPreviousValue: function(field, sourceObject, context) {
+        const encounter = sourceObject ?? context.previousDomainObjectValue;
+        if (encounter) {
+            const role = getLatestEncounterRole(encounter);
+            return {
+                value: role?.uuid,
+                display: role?.name
+            };
+        }
+        return null;
+    },
+    getDisplayValue: function(field, value) {
+        if (value?.display) {
+            return value.display;
+        }
+        return value;
+    },
+    tearDown: function() {
+        return;
+    }
+};
+function getLatestEncounterRole(encounter) {
+    if (encounter && encounter['encounterProviders']?.length) {
+        const lastProviderIndex = encounter['encounterProviders'].length - 1;
+        return encounter['encounterProviders'][lastProviderIndex].encounterRole;
+    }
+    return null;
+}

package/dist/adapters/inline-date-adapter.d.ts

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

package/dist/adapters/inline-date-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inline-date-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/inline-date-adapter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkB,KAAK,qBAAqB,EAAkC,MAAM,UAAU,CAAC;AAItG,eAAO,MAAM,iBAAiB,EAAE,qBAkD/B,CAAC"}

package/dist/adapters/inline-date-adapter.js

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

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

@@ -0,0 +1,24 @@
+import { type OpenmrsObs, type FormField, type FormFieldValueAdapter } from '../types';
+export declare let assignedObsIds: string[];
+export declare const ObsAdapter: FormFieldValueAdapter;
+export declare function constructObs(field: FormField, value: any): Partial<OpenmrsObs>;
+export declare function voidObs(obs: OpenmrsObs): {
+    uuid: string;
+    voided: boolean;
+};
+export declare function editObs(field: FormField, newValue: any): {
+    uuid: string;
+    value: any;
+    formFieldNamespace: string;
+    formFieldPath: string;
+};
+export declare function hasPreviousObsValueChanged(field: FormField, newValue: any): boolean;
+/**
+ * Retrieves a list of observations from a given `obsList` that correspond to the specified field.
+ *
+ * Notes:
+ * If the query by field-path returns an empty list, the function falls back to querying
+ * by concept and uses `claimedObsIds` to exclude already assigned observations.
+ */
+export declare function findObsByFormField(obsList: Array<OpenmrsObs>, claimedObsIds: string[], field: FormField): OpenmrsObs[];
+//# sourceMappingURL=obs-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"obs-adapter.d.ts","sourceRoot":"","sources":["../../src/adapters/obs-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,SAAS,EAGd,KAAK,qBAAqB,EAC3B,MAAM,UAAU,CAAC;AAclB,eAAO,IAAI,cAAc,EAAE,MAAM,EAAO,CAAC;AAEzC,eAAO,MAAM,UAAU,EAAE,qBAyExB,CAAC;AAkDF,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC,CAgB9E;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,UAAU;;;EAEtC;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG;;;;;EAWtD;AAkBD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,WAkBzE;AA+CD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,KAAK,CAAC,UAAU,CAAC,EAC1B,aAAa,EAAE,MAAM,EAAE,EACvB,KAAK,EAAE,SAAS,GACf,UAAU,EAAE,CAmBd"}

package/dist/adapters/obs-adapter.js

@@ -0,0 +1,259 @@
+import dayjs from "dayjs";
+import { ConceptTrue, codedTypes } from "../constants.js";
+import { hasRendering, gracefullySetSubmission, clearSubmission, flattenObsList, parseToLocalDateTime, formatDateAsDisplayString } from "../utils/common-utils.js";
+import { isEmpty } from "../validators/form-validator.js";
+import { attachmentUrl, getAttachmentByUuid } from "@openmrs/esm-framework";
+// Temporarily holds observations that have already been bound with matching fields
+export let assignedObsIds = [];
+export const ObsAdapter = {
+    async getInitialValue (field, sourceObject, context) {
+        const encounter = sourceObject ?? context.domainObjectValue;
+        const matchingObs = findObsByFormField(flattenObsList(encounter.obs), assignedObsIds, field);
+        if (hasRendering(field, 'file') && matchingObs?.length) {
+            return resolveAttachmentsFromObs(field, matchingObs);
+        }
+        return extractFieldValue(field, matchingObs, true);
+    },
+    async getPreviousValue (field, sourceObject, context) {
+        const encounter = sourceObject ?? context.previousDomainObjectValue;
+        if (encounter) {
+            const value = extractFieldValue(field, findObsByFormField(flattenObsList(encounter.obs), assignedObsIds, field), true);
+            if (!isEmpty(value)) {
+                return {
+                    value,
+                    display: this.getDisplayValue(field, value)
+                };
+            }
+        }
+        return null;
+    },
+    getDisplayValue: (field, value)=>{
+        const rendering = field.questionOptions.rendering;
+        if (isEmpty(value)) {
+            return value;
+        }
+        if (value instanceof Date) {
+            return formatDateAsDisplayString(field, value);
+        }
+        if (rendering === 'checkbox') {
+            return value.map((selected)=>field.questionOptions.answers?.find((option)=>option.concept == selected)?.label);
+        }
+        if (rendering === 'toggle') {
+            return value ? field.questionOptions.toggleOptions.labelTrue : field.questionOptions.toggleOptions.labelFalse;
+        }
+        if (codedTypes.includes(rendering)) {
+            return field.questionOptions.answers?.find((option)=>option.concept == value)?.label;
+        }
+        return value;
+    },
+    transformFieldValue: (field, value, context)=>{
+        // clear previous submission
+        clearSubmission(field);
+        if (!field.meta.initialValue?.omrsObject && isEmpty(value)) {
+            return null;
+        }
+        if (hasRendering(field, 'checkbox')) {
+            return handleMultiSelect(field, Array.isArray(value) ? value : [
+                value
+            ]);
+        }
+        if (hasRendering(field, 'file')) {
+            return handleAttachments(field, value);
+        }
+        if (!isEmpty(value) && hasPreviousObsValueChanged(field, value)) {
+            return gracefullySetSubmission(field, editObs(field, value), undefined);
+        }
+        if (field.meta.initialValue?.omrsObject && isEmpty(value)) {
+            return gracefullySetSubmission(field, undefined, voidObs(field.meta.initialValue.omrsObject));
+        }
+        if (!isEmpty(value)) {
+            return gracefullySetSubmission(field, constructObs(field, value), undefined);
+        }
+        return null;
+    },
+    tearDown: function() {
+        assignedObsIds = [];
+    }
+};
+// Helpers
+/**
+ * Extracts field's primitive value from obs
+ */ function extractFieldValue(field, obsList = [], makeFieldDirty = false) {
+    const rendering = field.questionOptions.rendering;
+    if (!field.meta) {
+        field.meta = {
+            initialValue: {
+                omrsObject: null,
+                refinedValue: null
+            }
+        };
+    }
+    if (obsList.length) {
+        if (rendering == 'checkbox') {
+            assignedObsIds.push(...obsList.map((obs)=>obs.uuid));
+            field.meta.initialValue.omrsObject = makeFieldDirty ? obsList : null;
+            return obsList.map((o)=>o.value.uuid);
+        }
+        const obs = obsList[0];
+        if (makeFieldDirty) {
+            field.meta.initialValue.omrsObject = {
+                ...obs
+            };
+        }
+        assignedObsIds.push(obs.uuid);
+        if (typeof obs.value === 'string' || typeof obs.value === 'number') {
+            if (rendering.startsWith('date')) {
+                const dateObject = parseToLocalDateTime(obs.value);
+                if (makeFieldDirty) {
+                    const obsObject = field.meta.initialValue.omrsObject;
+                    obsObject.value = dayjs(dateObject).format('YYYY-MM-DD HH:mm');
+                }
+                return dateObject;
+            }
+            return obs.value;
+        }
+        if (rendering == 'toggle') {
+            return obs.value.uuid === ConceptTrue;
+        }
+        if (rendering == 'fixed-value') {
+            return field['fixedValue'];
+        }
+        return obs.value?.uuid;
+    }
+    return '';
+}
+export function constructObs(field, value) {
+    if (isEmpty(value) && field.type !== 'obsGroup') {
+        return null;
+    }
+    const draftObs = field.type === 'obsGroup' ? {
+        groupMembers: []
+    } : {
+        value: field.questionOptions.rendering.startsWith('date') ? formatDateByPickerType(field, value) : value
+    };
+    return {
+        ...draftObs,
+        concept: field.questionOptions.concept,
+        formFieldNamespace: 'rfe-forms',
+        formFieldPath: `rfe-forms-${field.id}`
+    };
+}
+export function voidObs(obs) {
+    return {
+        uuid: obs.uuid,
+        voided: true
+    };
+}
+export function editObs(field, newValue) {
+    const oldObs = field.meta.initialValue?.omrsObject;
+    const formattedValue = field.questionOptions.rendering.startsWith('date') ? formatDateByPickerType(field, newValue) : newValue;
+    return {
+        uuid: oldObs.uuid,
+        value: formattedValue,
+        formFieldNamespace: 'rfe-forms',
+        formFieldPath: `rfe-forms-${field.id}`
+    };
+}
+function formatDateByPickerType(field, value) {
+    if (field.datePickerFormat) {
+        switch(field.datePickerFormat){
+            case 'calendar':
+                return dayjs(value).format('YYYY-MM-DD');
+            case 'timer':
+                return dayjs(value).format('HH:mm');
+            case 'both':
+                return dayjs(value).format('YYYY-MM-DD HH:mm');
+            default:
+                return dayjs(value).format('YYYY-MM-DD');
+        }
+    }
+    return value;
+}
+export function hasPreviousObsValueChanged(field, newValue) {
+    const previousObs = field.meta.initialValue?.omrsObject;
+    if (isEmpty(previousObs)) {
+        return false;
+    }
+    if (codedTypes.includes(field.questionOptions.rendering)) {
+        return previousObs.value.uuid !== newValue;
+    }
+    if (hasRendering(field, 'date')) {
+        return dayjs(newValue).diff(dayjs(previousObs.value), 'D') !== 0;
+    }
+    if (hasRendering(field, 'datetime') || field.datePickerFormat === 'both') {
+        return dayjs(newValue).diff(dayjs(previousObs.value), 'minute') !== 0;
+    }
+    if (hasRendering(field, 'toggle')) {
+        return previousObs.value.uuid === ConceptTrue !== newValue;
+    }
+    return previousObs.value !== newValue;
+}
+function handleMultiSelect(field, values = []) {
+    // three possible scenarios
+    // 1. we have a previous value and an empty current value
+    // 2. a mix of both (previous and current)
+    // 3. we only have a current value
+    const obsArray = field.meta.initialValue?.omrsObject;
+    if (obsArray?.length && isEmpty(values)) {
+        // we assume the user cleared the existing value(s)
+        // so we void all previous values
+        return gracefullySetSubmission(field, null, obsArray.map((previousValue)=>voidObs(previousValue)));
+    }
+    if (obsArray?.length && !isEmpty(values)) {
+        const toBeVoided = obsArray.filter((obs)=>!values.includes(obs.value.uuid));
+        const toBeCreated = values.filter((v)=>!obsArray.some((obs)=>obs.value.uuid === v));
+        return gracefullySetSubmission(field, toBeCreated.map((value)=>constructObs(field, value)), toBeVoided.map((obs)=>voidObs(obs)));
+    }
+    return gracefullySetSubmission(field, values.map((value)=>constructObs(field, value)), undefined);
+}
+function handleAttachments(field, attachments = []) {
+    const voided = attachments.filter((attachment)=>attachment.uuid && attachment.voided).map((voided)=>({
+            uuid: voided.uuid,
+            voided: true
+        }));
+    const newAttachments = field.meta.submission.newValue = attachments.filter((attachment)=>!attachment.uuid).map((newAttachment)=>({
+            formFieldNamespace: 'rfe-forms',
+            formFieldPath: `rfe-forms-${field.id}`,
+            ...newAttachment
+        }));
+    return gracefullySetSubmission(field, newAttachments, voided);
+}
+/**
+ * Retrieves a list of observations from a given `obsList` that correspond to the specified field.
+ *
+ * Notes:
+ * If the query by field-path returns an empty list, the function falls back to querying
+ * by concept and uses `claimedObsIds` to exclude already assigned observations.
+ */ export function findObsByFormField(obsList, claimedObsIds, field) {
+    const obs = obsList.filter((candidate)=>{
+        // we ignore the concept for attachments because they're managed from the backend
+        if (hasRendering(field, 'file') && candidate.formFieldPath == `rfe-forms-${field.id}`) {
+            return true;
+        }
+        return candidate.formFieldPath == `rfe-forms-${field.id}` && candidate.concept.uuid == field.questionOptions.concept;
+    });
+    // We shall fall back to mapping by the associated concept
+    // That being said, we shall find all matching obs and pick the one that wasn't previously claimed.
+    if (!obs?.length) {
+        const obsByConcept = obsList.filter((obs)=>obs.concept.uuid == field.questionOptions.concept);
+        return claimedObsIds?.length ? obsByConcept.filter((obs)=>!claimedObsIds.includes(obs.uuid)) : obsByConcept;
+    }
+    return obs;
+}
+async function resolveAttachmentsFromObs(field, obs) {
+    const abortController = new AbortController();
+    const attachments = await Promise.all(obs.map((obs)=>getAttachmentByUuid(obs.uuid, abortController).then((response)=>response.data).catch((error)=>{
+            console.error(`Failed to fetch attachment ${obs.uuid}:`, error);
+            return null;
+        })));
+    field.meta.initialValue = {
+        omrsObject: obs
+    };
+    return attachments.filter(Boolean).map((attachment)=>({
+            uuid: attachment.uuid,
+            base64Content: `${window.openmrsBase}${attachmentUrl}/${attachment.uuid}/bytes`,
+            fileName: attachment.filename,
+            fileDescription: attachment.comment,
+            fileType: attachment.bytesContentFamily?.toLowerCase()
+        }));
+}

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"}