@olaboot/esm-form-engine-lib 4.1.0

package/dist/components/renderer/field/fieldLogic.js

@@ -0,0 +1,238 @@
+import { codedTypes } from "../../../constants.js";
+import { hasRendering } from "../../../utils/common-utils.js";
+import { evaluateAsyncExpression, evaluateExpression } from "../../../utils/expression-runner.js";
+import { evalConditionalRequired, evaluateDisabled, evaluateHide, findFieldSection } from "../../../utils/form-helper.js";
+import { isEmpty } from "../../../validators/form-validator.js";
+import { reportError } from "../../../utils/error-utils.js";
+export function handleFieldLogic(field, context) {
+    const { methods: { getValues } } = context;
+    const values = getValues();
+    if (codedTypes.includes(field.questionOptions.rendering)) {
+        evaluateFieldAnswerDisabled(field, values, context);
+    }
+    evaluateFieldDependents(field, values, context);
+}
+function evaluateFieldAnswerDisabled(field, values, context) {
+    const { sessionMode, formFields, patient, visit } = context;
+    field.questionOptions.answers.forEach((answer)=>{
+        const disableExpression = answer.disable?.disableWhenExpression;
+        if (disableExpression && disableExpression.includes('myValue')) {
+            answer.disable.isDisabled = evaluateExpression(answer.disable?.disableWhenExpression, {
+                value: field,
+                type: 'field'
+            }, formFields, values, {
+                mode: sessionMode,
+                patient,
+                visit
+            });
+        }
+    });
+}
+function evaluateFieldDependents(field, values, context) {
+    const { sessionMode, formFields, patient, formFieldValidators, formJson, methods: { setValue }, updateFormField, setForm, visit } = context;
+    let shouldUpdateForm = false;
+    // handle fields
+    if (field.fieldDependents) {
+        field.fieldDependents.forEach((dep)=>{
+            const dependent = formFields.find((f)=>f.id == dep);
+            // evaluate calculated value
+            if (dependent.questionOptions.calculate?.calculateExpression) {
+                evaluateAsyncExpression(dependent.questionOptions.calculate.calculateExpression, {
+                    value: dependent,
+                    type: 'field'
+                }, formFields, values, {
+                    mode: sessionMode,
+                    patient,
+                    visit
+                }).then((result)=>{
+                    setValue(dependent.id, result);
+                    // validate calculated value
+                    const { errors, warnings } = validateFieldValue(dependent, result, context.formFieldValidators, {
+                        formFields,
+                        values,
+                        expressionContext: {
+                            patient,
+                            mode: sessionMode
+                        }
+                    });
+                    if (!dependent.meta.submission) {
+                        dependent.meta.submission = {};
+                    }
+                    dependent.meta.submission.errors = errors;
+                    dependent.meta.submission.warnings = warnings;
+                    if (!errors.length) {
+                        context.formFieldAdapters[dependent.type].transformFieldValue(dependent, result, context);
+                    }
+                    updateFormField(dependent);
+                }).catch((error)=>{
+                    reportError(error, 'Error evaluating calculate expression');
+                });
+            }
+            // evaluate hide
+            if (dependent.hide) {
+                const targetSection = findFieldSection(formJson, dependent);
+                const isSectionVisible = targetSection?.questions.some((question)=>!question.isHidden);
+                evaluateHide({
+                    value: dependent,
+                    type: 'field'
+                }, formFields, values, sessionMode, patient, evaluateExpression, updateFormField);
+                if (targetSection) {
+                    targetSection.questions = targetSection?.questions.map((question)=>{
+                        if (question.id === dependent.id) {
+                            return dependent;
+                        }
+                        return question;
+                    });
+                    const isDependentFieldHidden = dependent.isHidden;
+                    const sectionHasVisibleFieldAfterEvaluation = [
+                        ...targetSection.questions,
+                        dependent
+                    ].some((field)=>!field.isHidden);
+                    if (!isSectionVisible && !isDependentFieldHidden) {
+                        targetSection.isHidden = false;
+                        shouldUpdateForm = true;
+                    } else if (isSectionVisible && !sectionHasVisibleFieldAfterEvaluation) {
+                        targetSection.isHidden = true;
+                        shouldUpdateForm = true;
+                    }
+                }
+            }
+            // evaluate disabled
+            if (typeof dependent.disabled === 'object' && dependent.disabled.disableWhenExpression) {
+                dependent.isDisabled = evaluateDisabled({
+                    value: dependent,
+                    type: 'field'
+                }, formFields, values, sessionMode, patient, evaluateExpression);
+            }
+            // evaluate conditional required
+            if (typeof dependent.required === 'object' && dependent.required?.type === 'conditionalRequired') {
+                dependent.isRequired = evalConditionalRequired(dependent, formFields, values);
+            }
+            // evaluate conditional answered
+            if (dependent.validators?.some((validator)=>validator.type === 'conditionalAnswered')) {
+                const fieldValidatorConfig = dependent.validators?.find((validator)=>validator.type === 'conditionalAnswered');
+                const validationResults = formFieldValidators['conditionalAnswered'].validate(dependent, dependent.meta.submission?.newValue, {
+                    ...fieldValidatorConfig,
+                    expressionContext: {
+                        patient,
+                        mode: sessionMode
+                    },
+                    values,
+                    formFields
+                });
+                dependent.meta.submission = {
+                    ...dependent.meta.submission,
+                    errors: validationResults
+                };
+            }
+            // evaluate hide for answers
+            dependent?.questionOptions.answers?.filter((answer)=>!isEmpty(answer.hide?.hideWhenExpression)).forEach((answer)=>{
+                answer.isHidden = evaluateExpression(answer.hide?.hideWhenExpression, {
+                    value: dependent,
+                    type: 'field'
+                }, formFields, values, {
+                    mode: sessionMode,
+                    patient,
+                    visit
+                });
+            });
+            // evaluate disabled
+            dependent?.questionOptions.answers?.filter((answer)=>!isEmpty(answer.disable?.isDisabled)).forEach((answer)=>{
+                answer.disable.isDisabled = evaluateExpression(answer.disable?.disableWhenExpression, {
+                    value: dependent,
+                    type: 'field'
+                }, formFields, values, {
+                    mode: sessionMode,
+                    patient,
+                    visit
+                });
+            });
+            // evaluate readonly
+            if (!dependent.isHidden && dependent.meta.readonlyExpression) {
+                dependent.readonly = evaluateExpression(dependent.meta.readonlyExpression, {
+                    value: dependent,
+                    type: 'field'
+                }, formFields, values, {
+                    mode: sessionMode,
+                    patient,
+                    visit
+                });
+            }
+            // evaluate repeat limit
+            if (hasRendering(dependent, 'repeating') && !isEmpty(dependent.questionOptions.repeatOptions?.limitExpression)) {
+                dependent.questionOptions.repeatOptions.limit = evaluateExpression(dependent.questionOptions.repeatOptions?.limitExpression, {
+                    value: dependent,
+                    type: 'field'
+                }, formFields, values, {
+                    mode: sessionMode,
+                    patient,
+                    visit
+                });
+            }
+            updateFormField(dependent);
+        });
+    }
+    // handle sections
+    if (field.sectionDependents) {
+        field.sectionDependents.forEach((sectionId)=>{
+            for(let i = 0; i < formJson.pages.length; i++){
+                const section = formJson.pages[i].sections.find((section)=>section.label == sectionId);
+                if (section) {
+                    evaluateHide({
+                        value: section,
+                        type: 'section'
+                    }, formFields, values, sessionMode, patient, evaluateExpression, updateFormField);
+                    shouldUpdateForm = true;
+                    break;
+                }
+            }
+        });
+    }
+    // handle pages
+    if (field.pageDependents) {
+        field.pageDependents?.forEach((dep)=>{
+            const dependent = formJson.pages.find((f)=>f.label == dep);
+            evaluateHide({
+                value: dependent,
+                type: 'page'
+            }, formFields, values, sessionMode, patient, evaluateExpression, updateFormField);
+            shouldUpdateForm = true;
+        });
+    }
+    if (shouldUpdateForm) {
+        setForm(formJson);
+    }
+}
+export function validateFieldValue(field, value, validators, context) {
+    const errors = [];
+    const warnings = [];
+    if (field.meta.submission?.unspecified) {
+        return {
+            errors: [],
+            warnings: []
+        };
+    }
+    try {
+        field.validators.forEach((validatorConfig)=>{
+            const results = validators[validatorConfig.type]?.validate?.(field, value, {
+                ...validatorConfig,
+                ...context
+            });
+            if (results) {
+                results.forEach((result)=>{
+                    if (result.resultType === 'error') {
+                        errors.push(result);
+                    } else if (result.resultType === 'warning') {
+                        warnings.push(result);
+                    }
+                });
+            }
+        });
+    } catch (error) {
+        console.error(error);
+    }
+    return {
+        errors,
+        warnings
+    };
+}

package/dist/components/renderer/field/fieldLogic.test.js

@@ -0,0 +1,140 @@
+import { handleFieldLogic, validateFieldValue } from "./fieldLogic.js";
+import { evaluateExpression } from "../../../utils/expression-runner.js";
+jest.mock('../../../utils/expression-runner', ()=>({
+        evaluateExpression: jest.fn(),
+        evaluateAsyncExpression: jest.fn().mockResolvedValue({
+            result: 'mockedResult'
+        })
+    }));
+describe('handleFieldLogic', ()=>{
+    let mockContext;
+    let mockFieldCoded;
+    beforeEach(()=>{
+        mockContext = {
+            methods: {
+                getValues: jest.fn().mockReturnValue({}),
+                setValue: jest.fn()
+            },
+            formFields: [],
+            sessionMode: 'edit',
+            patient: {},
+            formFieldValidators: {},
+            formFieldAdapters: {
+                obs: {
+                    transformFieldValue: jest.fn()
+                }
+            },
+            formJson: {
+                pages: []
+            },
+            updateFormField: jest.fn(),
+            setForm: jest.fn()
+        };
+        mockFieldCoded = {
+            id: 'testField',
+            label: 'Test Field',
+            type: 'obs',
+            questionOptions: {
+                rendering: 'radio',
+                answers: [
+                    {
+                        label: 'Test Answer',
+                        concept: 'testConcept',
+                        disable: {
+                            disableWhenExpression: 'myValue > 10'
+                        }
+                    }
+                ]
+            },
+            fieldDependents: [],
+            sectionDependents: [],
+            pageDependents: [],
+            validators: []
+        };
+    });
+    it('should evaluate field answer disabled logic', ()=>{
+        evaluateExpression.mockReturnValue(true);
+        handleFieldLogic(mockFieldCoded, mockContext);
+        expect(evaluateExpression).toHaveBeenCalledWith('myValue > 10', {
+            value: mockFieldCoded,
+            type: 'field'
+        }, mockContext.formFields, mockContext.methods.getValues(), {
+            mode: mockContext.sessionMode,
+            patient: mockContext.patient
+        });
+        expect(mockFieldCoded.questionOptions.answers[0].disable.isDisabled).toBe(true);
+    });
+    it('should handle field dependents logic', ()=>{
+        mockFieldCoded.fieldDependents = new Set([
+            'dependentField'
+        ]);
+        mockContext.formFields = [
+            {
+                id: 'dependentField',
+                type: 'obs',
+                questionOptions: {
+                    calculate: {
+                        calculateExpression: '2 + 2'
+                    }
+                },
+                validators: [],
+                meta: {}
+            }
+        ];
+        handleFieldLogic(mockFieldCoded, mockContext);
+        expect(mockContext.updateFormField).toHaveBeenCalled();
+    });
+});
+describe('validateFieldValue', ()=>{
+    let mockField;
+    let mockValidators;
+    let mockContext;
+    beforeEach(()=>{
+        mockField = {
+            id: 'testField',
+            validators: [
+                {
+                    type: 'required'
+                }
+            ],
+            meta: {}
+        };
+        mockValidators = {
+            required: {
+                validate: jest.fn().mockReturnValue([
+                    {
+                        resultType: 'error',
+                        message: 'Field is required'
+                    }
+                ])
+            }
+        };
+        mockContext = {
+            formFields: [],
+            values: {},
+            expressionContext: {
+                patient: {},
+                mode: 'edit'
+            }
+        };
+    });
+    it('should validate field value and return errors and warnings', ()=>{
+        const result = validateFieldValue(mockField, '', mockValidators, mockContext);
+        expect(mockValidators.required.validate).toHaveBeenCalledWith(mockField, '', expect.objectContaining(mockContext));
+        expect(result.errors).toEqual([
+            {
+                resultType: 'error',
+                message: 'Field is required'
+            }
+        ]);
+        expect(result.warnings).toEqual([]);
+    });
+    it('should return empty errors and warnings if field submission is unspecified', ()=>{
+        mockField.meta.submission = {
+            unspecified: true
+        };
+        const result = validateFieldValue(mockField, '', mockValidators, mockContext);
+        expect(result.errors).toEqual([]);
+        expect(result.warnings).toEqual([]);
+    });
+});

package/dist/components/renderer/field/fieldRenderUtils.d.ts

@@ -0,0 +1,9 @@
+import { type SessionMode } from '../../../types';
+/**
+ * @name shouldRenderField
+ * @description Returns true if a field should be rendered.
+ * A field is hidden in 'embedded-view' mode when it is empty
+ * and either transient or `hideUnansweredQuestionsInReadonlyForms` is enabled.
+ */
+export declare function shouldRenderField(sessionMode: SessionMode, isTransient: boolean, isEmptyValue: boolean, hideUnansweredQuestionsInReadonlyForms: boolean): boolean;
+//# sourceMappingURL=fieldRenderUtils.d.ts.map

package/dist/components/renderer/field/fieldRenderUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldRenderUtils.d.ts","sourceRoot":"","sources":["../../../../src/components/renderer/field/fieldRenderUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,WAAW,EACxB,WAAW,EAAE,OAAO,EACpB,YAAY,EAAE,OAAO,EACrB,sCAAsC,EAAE,OAAO,GAC9C,OAAO,CAET"}

package/dist/components/renderer/field/fieldRenderUtils.js

@@ -0,0 +1,8 @@
+/**
+ * @name shouldRenderField
+ * @description Returns true if a field should be rendered.
+ * A field is hidden in 'embedded-view' mode when it is empty
+ * and either transient or `hideUnansweredQuestionsInReadonlyForms` is enabled.
+ */ export function shouldRenderField(sessionMode, isTransient, isEmptyValue, hideUnansweredQuestionsInReadonlyForms) {
+    return !(sessionMode === 'embedded-view' && isEmptyValue && (isTransient || hideUnansweredQuestionsInReadonlyForms));
+}

package/dist/components/renderer/field/fieldRenderUtils.test.js

@@ -0,0 +1,51 @@
+import { shouldRenderField } from "./fieldRenderUtils.js";
+describe('shouldRenderField', ()=>{
+    it('should return false for transient fields with no value in embedded-view mode', ()=>{
+        const sessionMode = 'embedded-view';
+        const isTransient = true;
+        const isEmpty = true;
+        const hideUnansweredQuestionsInReadonlyForms = false;
+        const result = shouldRenderField(sessionMode, isTransient, isEmpty, hideUnansweredQuestionsInReadonlyForms);
+        expect(result).toBe(false);
+    });
+    it('should return false for non-transient empty fields when hideUnansweredQuestionsInReadonlyForms is true in embedded-view mode', ()=>{
+        const sessionMode = 'embedded-view';
+        const isTransient = false;
+        const isEmpty = true;
+        const hideUnansweredQuestionsInReadonlyForms = true;
+        const result = shouldRenderField(sessionMode, isTransient, isEmpty, hideUnansweredQuestionsInReadonlyForms);
+        expect(result).toBe(false);
+    });
+    it('should return true for transient fields with a value in embedded-view mode', ()=>{
+        const sessionMode = 'embedded-view';
+        const isTransient = true;
+        const isEmpty = false;
+        const hideUnansweredQuestionsInReadonlyForms = true;
+        const result = shouldRenderField(sessionMode, isTransient, isEmpty, hideUnansweredQuestionsInReadonlyForms);
+        expect(result).toBe(true);
+    });
+    it('should return true for non-transient empty fields when hideUnansweredQuestionsInReadonlyForms is false in embedded-view mode', ()=>{
+        const sessionMode = 'embedded-view';
+        const isTransient = false;
+        const isEmpty = true;
+        const hideUnansweredQuestionsInReadonlyForms = false;
+        const result = shouldRenderField(sessionMode, isTransient, isEmpty, hideUnansweredQuestionsInReadonlyForms);
+        expect(result).toBe(true);
+    });
+    it('should return true for non-empty fields in embedded-view mode regardless of flags', ()=>{
+        const sessionMode = 'embedded-view';
+        const isTransient = false;
+        const isEmpty = false;
+        const hideUnansweredQuestionsInReadonlyForms = true;
+        const result = shouldRenderField(sessionMode, isTransient, isEmpty, hideUnansweredQuestionsInReadonlyForms);
+        expect(result).toBe(true);
+    });
+    it('should return true for any field in non-embedded modes', ()=>{
+        const sessionMode = 'edit';
+        const isTransient = true;
+        const isEmpty = true;
+        const hideUnansweredQuestionsInReadonlyForms = true;
+        const result = shouldRenderField(sessionMode, isTransient, isEmpty, hideUnansweredQuestionsInReadonlyForms);
+        expect(result).toBe(true);
+    });
+});

package/dist/components/renderer/field/form-field-renderer.component.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { type FormField, type FormFieldValueAdapter, type RenderType } from '../../../types';
+export interface FormFieldRendererProps {
+    fieldId: string;
+    valueAdapter: FormFieldValueAdapter;
+    repeatOptions?: {
+        targetRendering: RenderType;
+    };
+}
+export declare const FormFieldRenderer: ({ fieldId, valueAdapter, repeatOptions }: FormFieldRendererProps) => React.JSX.Element;
+export declare function ErrorFallback({ error }: {
+    error: any;
+}): React.JSX.Element;
+/**
+ * Determines whether a field can be unspecified
+ */
+export declare function isUnspecifiedSupported(question: FormField): boolean;
+export declare function isGroupField(rendering: RenderType): rendering is "group" | "repeating";
+//# sourceMappingURL=form-field-renderer.component.d.ts.map

package/dist/components/renderer/field/form-field-renderer.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-field-renderer.component.d.ts","sourceRoot":"","sources":["../../../../src/components/renderer/field/form-field-renderer.component.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAuC,MAAM,OAAO,CAAC;AAM5D,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,qBAAqB,EAC1B,KAAK,UAAU,EAGhB,MAAM,gBAAgB,CAAC;AAYxB,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,qBAAqB,CAAC;IACpC,aAAa,CAAC,EAAE;QACd,eAAe,EAAE,UAAU,CAAC;KAC7B,CAAC;CACH;AAED,eAAO,MAAM,iBAAiB,GAAI,0CAA0C,sBAAsB,sBA4NjG,CAAC;AAEF,wBAAgB,aAAa,CAAC,EAAE,KAAK,EAAE;;CAAA,qBAetC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,SAAS,WAWzD;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,UAAU,sCAEjD"}