@olaboot/esm-form-engine-lib 4.1.0

package/dist/zscore-tests/bmi-age.test.js

@@ -0,0 +1,84 @@
+import React from "react";
+import userEvent from "@testing-library/user-event";
+import { act, render, screen } from "@testing-library/react";
+import { openmrsFetch, usePatient, useSession } from "@openmrs/esm-framework";
+import { mockSessionDataResponse, mockVisit } from "__mocks__";
+import { mockPatientAge8 } from "__mocks__/patient.mock";
+import { demoHtsForm, bmiForAgeScoreTestSchema, demoHtsOpenmrsForm } from "__mocks__/forms";
+import FormEngine from "../form-engine.component.js";
+const patientUUID = 'e13a8696-dc58-4b8c-ae40-2a1e7dd843e7';
+const visit = mockVisit;
+const mockOpenmrsFetch = jest.mocked(openmrsFetch);
+const mockUsePatient = jest.mocked(usePatient);
+const mockUseSession = jest.mocked(useSession);
+jest.mock('../../src/api', ()=>{
+    const originalModule = jest.requireActual('../../src/api');
+    return {
+        ...originalModule,
+        getPreviousEncounter: jest.fn().mockImplementation(()=>Promise.resolve(null)),
+        getConcept: jest.fn().mockImplementation(()=>Promise.resolve(null)),
+        getLatestObs: jest.fn().mockImplementation(()=>Promise.resolve({
+                valueNumeric: 60
+            })),
+        saveEncounter: jest.fn()
+    };
+});
+describe.skip('bmiForAge z-score', ()=>{
+    beforeEach(()=>{
+        mockUseSession.mockReturnValue(mockSessionDataResponse.data);
+        mockUsePatient.mockReturnValue({
+            isLoading: false,
+            patient: mockPatientAge8,
+            patientUuid: mockPatientAge8.id,
+            error: null
+        });
+        mockOpenmrsFetch.mockResolvedValue({
+            data: {
+                results: [
+                    {
+                        ...demoHtsOpenmrsForm
+                    }
+                ]
+            }
+        });
+        mockOpenmrsFetch.mockResolvedValue({
+            data: {
+                results: [
+                    {
+                        ...demoHtsForm
+                    }
+                ]
+            }
+        });
+    });
+    it('should compute bmiForAge z-score from the provided height and weight values', async ()=>{
+        const user = userEvent.setup();
+        await act(async ()=>renderForm(null, bmiForAgeScoreTestSchema));
+        const bmiForAge = screen.getByRole('spinbutton', {
+            name: /bmi for age zscore result/i
+        });
+        const height = screen.getByRole('spinbutton', {
+            name: /height/i
+        });
+        const weight = screen.getByRole('spinbutton', {
+            name: /weight/i
+        });
+        await user.type(height, '100');
+        await user.type(weight, '45');
+        await user.tab();
+        expect(height).toHaveValue(100);
+        expect(weight).toHaveValue(45);
+        expect(bmiForAge).toHaveValue(4);
+    });
+    function renderForm(formUUID, formJson, intent) {
+        return act(()=>{
+            render(/*#__PURE__*/ React.createElement(FormEngine, {
+                formJson: formJson,
+                formUUID: formUUID,
+                patientUUID: patientUUID,
+                formSessionIntent: intent,
+                visit: visit
+            }));
+        });
+    }
+});

package/dist/zscore-tests/height-age.test.js

@@ -0,0 +1,88 @@
+import React from "react";
+import userEvent from "@testing-library/user-event";
+import { render, screen, act } from "@testing-library/react";
+import { openmrsFetch, usePatient, useSession } from "@openmrs/esm-framework";
+import { mockSessionDataResponse, mockVisit } from "__mocks__";
+import { mockPatientAge8 } from "__mocks__/patient.mock";
+import { demoHtsForm, demoHtsOpenmrsForm, heightForAgeZscoreTestSchema } from "__mocks__/forms";
+import FormEngine from "../form-engine.component.js";
+const patientUUID = 'e13a8696-dc58-4b8c-ae40-2a1e7dd843e7';
+const visit = mockVisit;
+const mockOpenmrsFetch = jest.mocked(openmrsFetch);
+const mockUsePatient = jest.mocked(usePatient);
+const mockUseSession = jest.mocked(useSession);
+jest.mock('../../src/api', ()=>{
+    const originalModule = jest.requireActual('../../src/api');
+    return {
+        ...originalModule,
+        getPreviousEncounter: jest.fn().mockImplementation(()=>Promise.resolve(null)),
+        getConcept: jest.fn().mockImplementation(()=>Promise.resolve(null)),
+        getLatestObs: jest.fn().mockImplementation(()=>Promise.resolve({
+                valueNumeric: 60
+            })),
+        saveEncounter: jest.fn()
+    };
+});
+describe.skip('heightForAge z-score', ()=>{
+    let globalSpy;
+    beforeEach(()=>{
+        const mockedDate = new Date(2024, 4, 10);
+        globalSpy = jest.spyOn(global, 'Date').mockImplementation(()=>mockedDate);
+        mockUseSession.mockReturnValue(mockSessionDataResponse.data);
+        mockUsePatient.mockReturnValue({
+            isLoading: false,
+            patient: mockPatientAge8,
+            patientUuid: mockPatientAge8.id,
+            error: null
+        });
+        mockOpenmrsFetch.mockResolvedValue({
+            data: {
+                results: [
+                    {
+                        ...demoHtsOpenmrsForm
+                    }
+                ]
+            }
+        });
+        mockOpenmrsFetch.mockResolvedValue({
+            data: {
+                results: [
+                    {
+                        ...demoHtsForm
+                    }
+                ]
+            }
+        });
+    });
+    afterEach(()=>{
+        globalSpy.mockRestore();
+    });
+    it('should compute heightForAge z-score from the provided height and weight values', async ()=>{
+        const user = userEvent.setup();
+        await act(async ()=>renderForm(null, heightForAgeZscoreTestSchema));
+        const heightForAgeZscore = screen.getByRole('spinbutton', {
+            name: /height for age zscore result/i
+        });
+        const height = screen.getByRole('spinbutton', {
+            name: /^height \*$/i
+        });
+        const weight = screen.getByRole('spinbutton', {
+            name: /weight/i
+        });
+        await user.type(height, '150');
+        await user.type(weight, '45');
+        await user.tab();
+        expect(height).toHaveValue(150);
+        expect(weight).toHaveValue(45);
+        expect(heightForAgeZscore).toHaveValue(4);
+    });
+    function renderForm(formUUID, formJson, intent) {
+        render(/*#__PURE__*/ React.createElement(FormEngine, {
+            formJson: formJson,
+            formUUID: formUUID,
+            patientUUID: patientUUID,
+            formSessionIntent: intent,
+            visit: visit
+        }));
+    }
+});

package/dist/zscore-tests/weight-height.test.js

@@ -0,0 +1,82 @@
+import React from "react";
+import userEvent from "@testing-library/user-event";
+import { act, render, screen } from "@testing-library/react";
+import { openmrsFetch, usePatient, useSession } from "@openmrs/esm-framework";
+import { mockSessionDataResponse, mockVisit } from "__mocks__";
+import { mockPatientAge4 } from "__mocks__/patient.mock";
+import { demoHtsForm, demoHtsOpenmrsForm, weightForHeightZscoreTestSchema } from "__mocks__/forms";
+import FormEngine from "../form-engine.component.js";
+const patientUUID = '8673ee4f-e2ab-4077-ba55-4980f408773e';
+const visit = mockVisit;
+const mockOpenmrsFetch = jest.mocked(openmrsFetch);
+const mockUsePatient = jest.mocked(usePatient);
+const mockUseSession = jest.mocked(useSession);
+jest.mock('../../src/api', ()=>{
+    const originalModule = jest.requireActual('../../src/api');
+    return {
+        ...originalModule,
+        getPreviousEncounter: jest.fn().mockImplementation(()=>Promise.resolve(null)),
+        getConcept: jest.fn().mockImplementation(()=>Promise.resolve(null)),
+        getLatestObs: jest.fn().mockImplementation(()=>Promise.resolve({
+                valueNumeric: 60
+            })),
+        saveEncounter: jest.fn()
+    };
+});
+describe.skip('weightForHeight z-score', ()=>{
+    beforeEach(()=>{
+        mockUseSession.mockReturnValue(mockSessionDataResponse.data);
+        mockUsePatient.mockReturnValue({
+            isLoading: false,
+            patient: mockPatientAge4,
+            patientUuid: mockPatientAge4.id,
+            error: null
+        });
+        mockOpenmrsFetch.mockResolvedValue({
+            data: {
+                results: [
+                    {
+                        ...demoHtsOpenmrsForm
+                    }
+                ]
+            }
+        });
+        mockOpenmrsFetch.mockResolvedValue({
+            data: {
+                results: [
+                    {
+                        ...demoHtsForm
+                    }
+                ]
+            }
+        });
+    });
+    it('should compute weightForHeight z-score from the provided height and weight values', async ()=>{
+        const user = userEvent.setup();
+        await act(async ()=>renderForm(null, weightForHeightZscoreTestSchema));
+        const weightForHeightZscore = screen.getByRole('textbox', {
+            name: /weight for height zscore result/i
+        });
+        const height = screen.getByRole('spinbutton', {
+            name: /height/i
+        });
+        const weight = screen.getByRole('spinbutton', {
+            name: /weight/i
+        });
+        await user.type(height, '110');
+        await user.type(weight, '45');
+        await user.tab();
+        expect(weight).toHaveValue(45);
+        expect(height).toHaveValue(110);
+        expect(weightForHeightZscore).toHaveValue('4');
+    });
+    function renderForm(formUUID, formJson, intent) {
+        render(/*#__PURE__*/ React.createElement(FormEngine, {
+            formJson: formJson,
+            formUUID: formUUID,
+            patientUUID: patientUUID,
+            formSessionIntent: intent,
+            visit: visit
+        }));
+    }
+});

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "@olaboot/esm-form-engine-lib",
+  "version": "4.1.0",
+  "description": "React Form Engine for O3",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "src/index.ts",
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.*",
+    "!src/setup-tests.ts",
+    "!src/utils/test-utils.ts",
+    "!src/zscore-tests"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/openmrs/openmrs-esm-form-engine-lib#readme",
+  "scripts": {
+    "lint": "eslint src --ext .ts,.tsx --fix",
+    "verify": "turbo run lint typescript test --concurrency=5",
+    "test": "TZ=UTC jest --config ./jest.config.js --passWithNoTests --color",
+    "test:watch": "TZ=UTC jest --config ./jest.config.js --watch --color",
+    "typescript": "tsc",
+    "build": "rimraf dist && concurrently \"swc --copy-files --ignore '**/*.test.*' --ignore '**/setup-tests.*' --ignore '**/test-utils.*' src -d dist\" \"tsc --project tsconfig.build.json\"",
+    "coverage": "yarn test --coverage",
+    "prepare": "husky install",
+    "extract-translations": "i18next 'src/**/*.component.tsx' 'src/**/*.ts' --config './tools/i18next-parser.config.js'"
+  },
+  "browserslist": [
+    "extends browserslist-config-openmrs"
+  ],
+  "keywords": [
+    "openmrs"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "@carbon/react": "^1.83.0",
+    "classnames": "^2.5.1",
+    "lodash-es": "^4.17.21",
+    "react-error-boundary": "^4.0.13",
+    "react-hook-form": "^7.52.0",
+    "react-markdown": "^9.0.1",
+    "react-waypoint": "^10.3.0",
+    "react-webcam": "^7.2.0"
+  },
+  "peerDependencies": {
+    "@openmrs/esm-framework": "9.x",
+    "dayjs": "1.x",
+    "i18next": "25.x",
+    "react": "18.x",
+    "react-i18next": "16.x",
+    "swr": "2.x"
+  },
+  "devDependencies": {
+    "@openmrs/esm-framework": "next",
+    "@openmrs/esm-styleguide": "next",
+    "@swc/cli": "^0.1.65",
+    "@swc/core": "^1.5.7",
+    "@swc/jest": "^0.2.36",
+    "@testing-library/dom": "^9.3.4",
+    "@testing-library/jest-dom": "^6.4.5",
+    "@testing-library/react": "^14.3.1",
+    "@testing-library/user-event": "^14.5.2",
+    "@types/jest": "^29.5.12",
+    "@types/lodash": "^4.17.4",
+    "@types/lodash-es": "^4.17.12",
+    "@types/react": "^18.3.2",
+    "@typescript-eslint/eslint-plugin": "^7.9.0",
+    "@typescript-eslint/parser": "^7.9.0",
+    "concurrently": "^6.5.1",
+    "dayjs": "^1.11.11",
+    "eslint": "^8.57.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jsx-a11y": "^6.8.0",
+    "eslint-plugin-react-hooks": "^4.6.2",
+    "husky": "^8.0.3",
+    "i18next": "^25.0.0",
+    "i18next-parser": "^9.3.0",
+    "identity-obj-proxy": "^3.0.0",
+    "jest": "^29.7.0",
+    "jest-cli": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "jest-when": "^3.6.0",
+    "lint-staged": "^15.2.2",
+    "openmrs": "next",
+    "prettier": "^2.8.8",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-i18next": "^16.0.0",
+    "resize-observer-polyfill": "^1.5.1",
+    "rimraf": "^5.0.0",
+    "sass": "^1.77.2",
+    "swr": "^2.2.5",
+    "turbo": "^2.5.2",
+    "typescript": "^5.0.0"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": "eslint --cache --fix --max-warnings 0",
+    "*.{css,scss,ts,tsx}": "prettier --write --list-different"
+  },
+  "packageManager": "yarn@4.10.3"
+}

package/src/adapters/control-adapter.ts

@@ -0,0 +1,29 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from '../provider/form-provider';
+import { type FormField, type FormProcessorContextProps, type FormFieldValueAdapter } from '../types';
+
+export const ControlAdapter: FormFieldValueAdapter = {
+  getDisplayValue: (field: FormField, value: any) => {
+    return value;
+  },
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    return null;
+  },
+  getInitialValue: function (
+    field: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): Promise<any> {
+    return null;
+  },
+  getPreviousValue: function (
+    field: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): Promise<any> {
+    return null;
+  },
+  tearDown: function (): void {
+    return;
+  },
+};

package/src/adapters/encounter-datetime-adapter.ts

@@ -0,0 +1,38 @@
+import { formatDate, type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from '../provider/form-provider';
+import {
+  type FormField,
+  type FormProcessorContextProps,
+  type FormFieldValueAdapter,
+  type ValueAndDisplay,
+} from '../types';
+import { gracefullySetSubmission } from '../utils/common-utils';
+
+export const EncounterDatetimeAdapter: FormFieldValueAdapter = {
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    gracefullySetSubmission(field, value, null);
+  },
+  getInitialValue: function (field: FormField, sourceObject: OpenmrsResource, context: FormProcessorContextProps) {
+    return sourceObject?.encounterDatetime ? new Date(sourceObject.encounterDatetime) : context.sessionDate;
+  },
+  getPreviousValue: function (
+    field: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): ValueAndDisplay {
+    if (sourceObject?.encounterDatetime) {
+      const date = new Date(sourceObject.encounterDatetime);
+      return {
+        value: date,
+        display: this.getDisplayValue(field, date),
+      };
+    }
+    return null;
+  },
+  getDisplayValue: function (field: FormField, value: Date) {
+    return formatDate(value);
+  },
+  tearDown: function (): void {
+    return;
+  },
+};

package/src/adapters/encounter-diagnosis-adapter.ts

@@ -0,0 +1,121 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import {
+  type OpenmrsObs,
+  type FormFieldValueAdapter,
+  type FormProcessorContextProps,
+  type OpenmrsEncounter,
+  type FormField,
+} from '../types';
+import { type FormContextProps } from '../provider/form-provider';
+import { gracefullySetSubmission } from '../utils/common-utils';
+import { isEmpty } from '../validators/form-validator';
+import { isTrue } from '../utils/boolean-utils';
+
+export let assignedDiagnosesIds: string[] = [];
+
+export const EncounterDiagnosisAdapter: FormFieldValueAdapter = {
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    if (field.meta.initialValue?.omrsObject && isEmpty(value)) {
+      return gracefullySetSubmission(field, undefined, voidDiagnosis(field.meta.initialValue.omrsObject as OpenmrsObs));
+    }
+    if (!isEmpty(value)) {
+      const previousDiagnosis = field.meta.initialValue?.omrsObject as OpenmrsResource;
+      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: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): Promise<any> {
+    const encounter = sourceObject ?? (context.domainObjectValue as OpenmrsEncounter);
+    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: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): Promise<any> {
+    return null;
+  },
+  getDisplayValue: (field: FormField, value: any) => {
+    return field.questionOptions.answers?.find((option) => option.concept == value)?.label || value;
+  },
+  tearDown: function (): void {
+    assignedDiagnosesIds = [];
+  },
+};
+
+const constructNewDiagnosis = (value: string, field: FormField, patientUuid: string) => {
+  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, // rank 1 denotes a diagnosis is primary, else secondary
+    formFieldPath: `rfe-forms-${field.id}`,
+    formFieldNamespace: 'rfe-forms',
+  };
+};
+
+function editDiagnosis(
+  newEncounterDiagnosis: string,
+  field: FormField,
+  previousDiagnosis: OpenmrsResource,
+  patientUuid: string,
+) {
+  return {
+    patient: patientUuid,
+    condition: null,
+    diagnosis: {
+      coded: newEncounterDiagnosis,
+    },
+    certainty: isTrue(field.questionOptions?.diagnosis?.isConfirmed) ? 'CONFIRMED' : 'PROVISIONAL',
+    rank: field.questionOptions.diagnosis?.rank ?? 1, // rank 1 denotes a diagnosis is primary, else secondary
+    formFieldPath: `rfe-forms-${field.id}`,
+    formFieldNamespace: 'rfe-forms',
+    uuid: previousDiagnosis.uuid,
+  };
+}
+
+export function hasPreviousDiagnosisValueChanged(previousDiagnosis: OpenmrsResource, newValue: string) {
+  if (isEmpty(previousDiagnosis)) {
+    return false;
+  }
+  return previousDiagnosis.value !== newValue;
+}
+
+export function voidDiagnosis(diagnosis: OpenmrsResource) {
+  return { uuid: diagnosis.uuid, voided: true };
+}

package/src/adapters/encounter-location-adapter.ts

@@ -0,0 +1,39 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from '../provider/form-provider';
+import {
+  type ValueAndDisplay,
+  type FormField,
+  type FormFieldValueAdapter,
+  type FormProcessorContextProps,
+} from '../types';
+import { gracefullySetSubmission } from '../utils/common-utils';
+
+export const EncounterLocationAdapter: FormFieldValueAdapter = {
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    gracefullySetSubmission(field, value, null);
+  },
+  getInitialValue: function (field: FormField, sourceObject: OpenmrsResource, context: FormProcessorContextProps): any {
+    if (sourceObject && sourceObject['location']?.uuid) {
+      return sourceObject['location'].uuid;
+    }
+
+    return context.location.uuid;
+  },
+  getPreviousValue: function (
+    field: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): ValueAndDisplay {
+    const encounter = sourceObject ?? context.previousDomainObjectValue;
+    return {
+      value: encounter?.location?.uuid,
+      display: encounter?.location?.name,
+    };
+  },
+  getDisplayValue: function (field: FormField, value: string) {
+    return value;
+  },
+  tearDown: function (): void {
+    return;
+  },
+};

package/src/adapters/encounter-provider-adapter.ts

@@ -0,0 +1,48 @@
+import { type OpenmrsResource } from '@openmrs/esm-framework';
+import { type FormContextProps } from '../provider/form-provider';
+import {
+  type ValueAndDisplay,
+  type FormField,
+  type FormFieldValueAdapter,
+  type FormProcessorContextProps,
+} from '../types';
+import { gracefullySetSubmission } from '../utils/common-utils';
+
+export const EncounterProviderAdapter: FormFieldValueAdapter = {
+  transformFieldValue: function (field: FormField, value: any, context: FormContextProps) {
+    gracefullySetSubmission(field, value, null);
+  },
+  getInitialValue: function (field: FormField, sourceObject: OpenmrsResource, context: FormProcessorContextProps) {
+    const encounter = sourceObject ?? context.previousDomainObjectValue;
+    return getLatestProvider(encounter)?.uuid;
+  },
+  getPreviousValue: function (
+    field: FormField,
+    sourceObject: OpenmrsResource,
+    context: FormProcessorContextProps,
+  ): ValueAndDisplay {
+    const encounter = sourceObject ?? context.previousDomainObjectValue;
+    const provider = getLatestProvider(encounter);
+    return {
+      value: provider?.uuid,
+      display: provider?.name,
+    };
+  },
+  getDisplayValue: function (field: FormField, value: any) {
+    if (value?.display) {
+      return value.display;
+    }
+    return value;
+  },
+  tearDown: function (): void {
+    return;
+  },
+};
+
+function getLatestProvider(encounter: OpenmrsResource) {
+  if (encounter && encounter['encounterProviders']?.length) {
+    const lastProviderIndex = encounter['encounterProviders'].length - 1;
+    return encounter['encounterProviders'][lastProviderIndex].provider;
+  }
+  return null;
+}