@olaboot/esm-form-engine-lib 4.1.0

package/src/utils/forms-loader.ts

@@ -0,0 +1,306 @@
+import * as semver from 'semver';
+import { type FormField } from '../types';
+
+let baseRegistry = {};
+export interface FormJsonFile {
+  version: string;
+  semanticVersion?: string;
+  json: any;
+}
+
+/**
+ * This is a form behaviour property applied on `page` or `section` or `question`
+ */
+interface BehaviourProperty {
+  name: string;
+  type: 'field' | 'section' | 'page' | 'all';
+  value: string;
+}
+
+/**
+ * Convenience function for loading form(s) associated to a given package or form version.
+ *
+ * @param packageName The package associated with the form
+ * @param formNamespace The form namespace
+ * @param version The form version
+ * @param isStrict If `true`, throws error if specified form version wasn't found
+ * @param formsRegistry Form registry. (This was added for testing purposes)
+ * @returns The form json
+ */
+export function getForm(
+  packageName: string,
+  formNamespace: string,
+  version?: string,
+  isStrict?: boolean,
+  formsRegistry?: any,
+) {
+  const forms = lookupForms(packageName, formNamespace, formsRegistry);
+  let form = null;
+  if (version) {
+    form = getFormByVersion(forms, version, isStrict);
+  }
+  if (!form) {
+    form = getLatestFormVersion(forms);
+  }
+  return loadSubforms(form.json);
+}
+
+export function loadSubforms(parentForm) {
+  parentForm.pages = parentForm.pages || [];
+  parentForm.pages.forEach((page) => {
+    if (page.isSubform && page.subform?.name && page.subform.package) {
+      try {
+        const subform = getForm(page.subform.package, page.subform.name);
+        if (!subform) {
+          console.error(`Form with name "${page.subform.package}/${page.subform.name}" was not found in registry.`);
+        }
+        page.subform.form = subform;
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  });
+  return parentForm;
+}
+
+export function getLatestFormVersion(forms: FormJsonFile[]) {
+  if (forms.length == 1) {
+    return forms[0];
+  }
+  const candidates = forms.map((f) => f.semanticVersion);
+  const latest = candidates.sort(formsVersionComparator)[candidates.length - 1];
+  return forms.find((f) => f.semanticVersion == latest);
+}
+
+export function getFormByVersion(forms: FormJsonFile[], requiredVersion: string, isStrict?: boolean) {
+  for (let form of forms) {
+    if (semver.satisfies(form.semanticVersion, requiredVersion)) {
+      return form;
+    }
+  }
+  if (isStrict) {
+    throw new Error(`Couldn't find form with version: ${requiredVersion}`);
+  } else {
+    return null;
+  }
+}
+
+export function lookupForms(packageName, formNamespace, formsRegistry) {
+  const pkg = formsRegistry ? formsRegistry[packageName] : baseRegistry[packageName];
+  if (!pkg) {
+    throw Error(`Package with name ${packageName} was not found in registry`);
+  }
+  if (!pkg[formNamespace]) {
+    throw new Error(`Form namespace '${formNamespace}' was not found in forms registry`);
+  }
+  return Object.keys(pkg[formNamespace]).map((formVersion) => {
+    return {
+      version: formVersion,
+      semanticVersion: semver.coerce(formVersion).version,
+      json: pkg[formNamespace][formVersion],
+    };
+  });
+}
+
+/**
+ * Function parses JSON form input and filters validation behaviours according to a given intent
+ *
+ * @param {string} intent The specified intent
+ * @param {object} originalJson The original JSON form schema object
+ * @param parentOverrides An array of behaviour overrides from parent form to be applied to a subform
+ * @returns {object} The form json
+ */
+export function applyFormIntent(intent, originalJson, parentOverrides?: Array<BehaviourProperty>) {
+  if (!intent) {
+    return originalJson;
+  }
+  const jsonBuffer = JSON.parse(JSON.stringify(originalJson));
+  // Set the default page based on the current intent
+  jsonBuffer.defaultPage = jsonBuffer.availableIntents?.find(
+    (candidate) => candidate.intent === (intent?.intent || intent),
+  )?.defaultPage;
+
+  // filter form-level markdown behaviour
+  if (jsonBuffer.markdown) {
+    updateMarkdownRequiredBehaviour(jsonBuffer.markdown, intent);
+  }
+
+  // Before starting traversal, ensure nodes exist, at least as empty-arrays
+  jsonBuffer.pages = jsonBuffer.pages || [];
+
+  // Traverse the property tree with items of interest for validation
+  jsonBuffer.pages.forEach((page) => {
+    if (page.isSubform && page.subform?.form) {
+      const behaviourOverrides = [];
+      const targetBehaviour = page.subform.behaviours?.find(
+        (behaviour) => behaviour.intent == intent?.intent || intent,
+      );
+      if (targetBehaviour?.readonly !== undefined || targetBehaviour?.readonly != null) {
+        behaviourOverrides.push({ name: 'readonly', type: 'field', value: targetBehaviour?.readonly });
+      }
+
+      page.subform.form = applyFormIntent(
+        targetBehaviour?.subform_intent || '*',
+        page.subform?.form,
+        behaviourOverrides,
+      );
+    }
+    const pageBehaviour = page.behaviours?.find((behaviour) => behaviour.intent === (intent?.intent || intent));
+    if (pageBehaviour) {
+      page.hide = pageBehaviour.hide ?? page.hide;
+      page.readonly = pageBehaviour.readonly ?? page.readonly;
+    } else {
+      const fallBackBehaviour = page.behaviours?.find((behaviour) => behaviour.intent === '*');
+      if (fallBackBehaviour) {
+        page.hide = fallBackBehaviour.hide ?? page.hide;
+        page.readonly = fallBackBehaviour.readonly ?? page.readonly;
+      }
+    }
+
+    // filter page-level markdown behaviour
+    if (page.markdown) {
+      updateMarkdownRequiredBehaviour(page.markdown, intent);
+    }
+    // Before starting traversal, ensure nodes exist, at least as empty-arrays
+    page.sections = page.sections || [];
+
+    page.sections.forEach((section) => {
+      const secBehaviour = section.behaviours?.find((behaviour) => behaviour.intent === intent?.intent || intent);
+      if (secBehaviour) {
+        section.hide = secBehaviour.hide ?? section.hide;
+      } else {
+        const fallBackBehaviour = section.behaviours?.find((behaviour) => behaviour.intent === '*');
+        section.hide = fallBackBehaviour?.hide ?? section.hide;
+      }
+
+      // filter section-level markdown behaviour
+      if (section.markdown) {
+        updateMarkdownRequiredBehaviour(section.markdown, intent);
+      }
+
+      // Before starting traversal, ensure nodes exist, at least as empty-arrays
+      section.questions = section.questions || [];
+
+      section.questions.forEach((question: FormField) => {
+        if (question['behaviours']) {
+          updateQuestionRequiredBehaviour(question, intent?.intent || intent);
+          parentOverrides
+            ?.filter((override) => override.type == 'all' || override.type == 'field')
+            ?.forEach((override) => {
+              question[override.name] = override.value;
+            });
+        }
+
+        if (question.questions && question.questions.length) {
+          question.questions.forEach((childQuestion) => {
+            updateQuestionRequiredBehaviour(childQuestion, intent?.intent || intent);
+
+            parentOverrides
+              ?.filter((override) => override.type == 'all' || override.type == 'field')
+              ?.forEach((override) => {
+                childQuestion[override.name] = override.value;
+              });
+          });
+        }
+      });
+    });
+  });
+  return jsonBuffer;
+}
+
+// Helpers
+
+function updateQuestionRequiredBehaviour(question, intent: string) {
+  const requiredIntentBehaviour = question.behaviours?.find((behaviour) => behaviour.intent === intent);
+
+  const defaultIntentBehaviour = question.behaviours?.find((behaviour) => behaviour.intent === '*');
+  // If both required and default intents exist, combine them and update to question
+  if (requiredIntentBehaviour || defaultIntentBehaviour) {
+    // Remove the intent name props from each object
+    delete requiredIntentBehaviour?.intent;
+    delete defaultIntentBehaviour?.intent;
+
+    // Combine required and default intents following the rules:
+    // 1. The default intent is applied to all other intents
+    // 2. Intent-specific behaviour overrides default behaviour
+    const combinedBehaviours = Object.assign(defaultIntentBehaviour || {}, requiredIntentBehaviour || {});
+    const defaultValue = combinedBehaviours.defaultValue;
+    if (defaultValue != undefined) {
+      // add the default value under the question options
+      question.questionOptions.defaultValue = defaultValue;
+      // delete it so that it's not added at the root level of the question
+      delete combinedBehaviours.defaultValue;
+    }
+    // Add the combinedBehaviours data to initial question
+    question = Object.assign(question, combinedBehaviours);
+    // Remove behaviours list
+    delete question.behaviours;
+  }
+}
+
+function updateMarkdownRequiredBehaviour(markdown, intent) {
+  const requiredIntentBehaviour = markdown.behaviours?.find((behaviour) => behaviour.intent === intent);
+  const defaultIntentBehaviour = markdown.behaviours?.find((behaviour) => behaviour.intent === '*');
+
+  if (requiredIntentBehaviour && defaultIntentBehaviour) {
+    delete requiredIntentBehaviour.intent;
+    delete defaultIntentBehaviour.intent;
+    const combinedBehaviours = Object.assign(defaultIntentBehaviour, requiredIntentBehaviour);
+
+    markdown = Object.assign(markdown, combinedBehaviours);
+    delete markdown.behaviours;
+  } else if (!requiredIntentBehaviour && defaultIntentBehaviour) {
+    delete defaultIntentBehaviour.intent;
+
+    markdown = Object.assign(markdown, defaultIntentBehaviour);
+    delete markdown.behaviours;
+  }
+}
+
+export function updateExcludeIntentBehaviour(excludedIntents: Array<string>, originalJson) {
+  originalJson.availableIntents = originalJson.availableIntents.filter(
+    (intent) => !excludedIntents.includes(intent?.intent || intent),
+  );
+  return originalJson;
+}
+
+export function addToBaseFormsRegistry(customRegistry: Record<string, any>) {
+  baseRegistry = { ...baseRegistry, ...customRegistry };
+}
+
+function isPositiveInteger(x) {
+  return /^\d+$/.test(x);
+}
+
+function formsVersionComparator(v1, v2) {
+  let v1parts = v1.split('.');
+  let v2parts = v2.split('.');
+  // First, validate both numbers are true version numbers
+  function validateParts(parts) {
+    for (let i = 0; i < parts.length; ++i) {
+      if (!isPositiveInteger(parts[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (!validateParts(v1parts) || !validateParts(v2parts)) {
+    return NaN;
+  }
+  for (let i = 0; i < v1parts.length; ++i) {
+    if (v2parts.length === i) {
+      return 1;
+    }
+    if (v1parts[i] === v2parts[i]) {
+      continue;
+    }
+    if (v1parts[i] > v2parts[i]) {
+      return 1;
+    }
+    return -1;
+  }
+  if (v1parts.length != v2parts.length) {
+    return -1;
+  }
+  return 0;
+}

package/src/utils/post-submission-action-helper.ts

@@ -0,0 +1,71 @@
+export function evaluatePostSubmissionExpression(expression: string, encounters: any[]): boolean {
+  const encounter = encounters[0];
+  const regx = /(?:\w+|'(?:\\'|[^'\n])*')/g;
+  let match;
+  const fieldIds = new Set<string>();
+  try {
+    while ((match = regx.exec(expression))) {
+      const value = match[0].replace(/\\'/g, "'"); // Replace escaped single quotes
+
+      const isBoolean = /^(true|false)$/i.test(value);
+      const isNumber = /^-?\d+$/.test(value);
+      const isFloat = /^-?\d+\.\d+$/.test(value);
+
+      if (
+        !(value.startsWith("'") && value.endsWith("'")) &&
+        typeof value === 'string' &&
+        !isBoolean &&
+        !isNumber &&
+        !isFloat
+      ) {
+        fieldIds.add(value);
+      }
+    }
+
+    let fieldToValueMap = {};
+    let replacedExpression;
+    if (fieldIds.size) {
+      fieldToValueMap = getFieldValues(fieldIds, encounter);
+    }
+
+    if (Object.keys(fieldToValueMap).length) {
+      replacedExpression = expression.replace(/(\w+)/g, (match) => {
+        return Object.prototype.hasOwnProperty.call(fieldToValueMap, match) ? fieldToValueMap[match] : match;
+      });
+    } else {
+      replacedExpression = expression;
+    }
+
+    return eval(replacedExpression);
+  } catch (error) {
+    throw new Error('Error evaluating expression');
+  }
+}
+
+function getFieldValues(fieldIds: Set<string>, encounter: any): Record<string, any> {
+  const result: Record<string, any> = {};
+  fieldIds.forEach((fieldId) => {
+    let value = encounter.obs?.find((item) => item.formFieldPath.includes(fieldId))?.value;
+    if (typeof value === 'object') {
+      value = value.uuid;
+    }
+    if (value) {
+      value = formatValue(value);
+    }
+    result[fieldId] = value;
+  });
+
+  return result;
+}
+
+//This function wraps string values in single quotes which Javascript will evaluate
+function formatValue(value: any): any {
+  if (typeof value === 'string') {
+    if (value.length >= 2 && value[0] === "'" && value[value.length - 1] === "'") {
+      return value;
+    } else {
+      return `'${value}'`;
+    }
+  }
+  return value;
+}

package/src/utils/zscore-service.ts

@@ -0,0 +1,59 @@
+import filter from 'lodash/filter';
+import bfaMale5Above from '../zscore/bfa_boys_5_above.json';
+import wflMaleBelow5 from '../zscore/wfl_boys_below5.json';
+import hfaMale5Above from '../zscore/hfa_boys_5_above.json';
+import hfaMaleBelow5 from '../zscore/hfa_boys_below5.json';
+import bfaFemale5Above from '../zscore/bfa_girls_5_above.json';
+import wflFemaleBelow5 from '../zscore/wfl_girls_below5.json';
+import hfaFemale5Above from '../zscore/hfa_girls_5_above.json';
+import hfaFemaleBelow5 from '../zscore/hfa_girls_below5.json';
+import dayjs from 'dayjs';
+
+export function getZRefByGenderAndAge(gender, birthDate, refdate) {
+  const scoreRefModel = {
+    weightForHeightRef: null,
+    heightForAgeRef: null,
+    bmiForAgeRef: null,
+  };
+  const age = getAge(birthDate, refdate, 'years');
+  const ageInMonths = getAge(birthDate, refdate, 'months');
+  const ageInDays = getAge(birthDate, refdate, 'days');
+
+  if (gender === 'F') {
+    if (age < 5) {
+      scoreRefModel.weightForHeightRef = wflFemaleBelow5;
+      scoreRefModel.heightForAgeRef = getScoreReference(hfaFemaleBelow5, 'Day', ageInDays);
+    }
+    if (age >= 5 && age < 18) {
+      scoreRefModel.bmiForAgeRef = getScoreReference(bfaFemale5Above, 'Month', ageInMonths);
+      scoreRefModel.heightForAgeRef = getScoreReference(hfaFemale5Above, 'Month', ageInMonths);
+    }
+  }
+  if (gender === 'M') {
+    if (age < 5) {
+      scoreRefModel.weightForHeightRef = wflMaleBelow5;
+      scoreRefModel.heightForAgeRef = getScoreReference(hfaMaleBelow5, 'Day', ageInDays);
+    }
+
+    if (age >= 5 && age < 18) {
+      scoreRefModel.bmiForAgeRef = getScoreReference(bfaMale5Above, 'Month', ageInMonths);
+      scoreRefModel.heightForAgeRef = getScoreReference(hfaMale5Above, 'Month', ageInMonths);
+    }
+  }
+  return scoreRefModel;
+}
+
+function getScoreReference(refData, searchKey, searchValue): any {
+  return filter(refData, (refObject) => {
+    return refObject[searchKey] === searchValue;
+  });
+}
+
+function getAge(birthdate, refDate, ageIn) {
+  if (birthdate && refDate && ageIn) {
+    const todayMoment: any = dayjs(refDate);
+    const birthDateMoment: any = dayjs(birthdate);
+    return todayMoment.diff(birthDateMoment, ageIn);
+  }
+  return null;
+}

package/src/validators/conditional-answered-validator.ts

@@ -0,0 +1,17 @@
+import { isEmpty } from '../validators/form-validator';
+import { type FormFieldValidator, type FormField } from '../types';
+
+export const conditionalAnsweredValidator: FormFieldValidator = {
+  validate: function (field: FormField, value: unknown, config: Record<string, any>) {
+    const { referenceQuestionId, referenceQuestionAnswers, values, formFields, message } = config;
+
+    const referencedField = formFields.find((field) => field.id === referenceQuestionId);
+    const referencedFieldValue = values[referencedField.id];
+
+    if (!isEmpty(value) && !referenceQuestionAnswers.includes(referencedFieldValue)) {
+      return [{ resultType: 'error', errCode: 'invalid.valueSelected', message: message }];
+    }
+
+    return [];
+  },
+};

package/src/validators/date-validator.ts

@@ -0,0 +1,19 @@
+import { type FormFieldValidator, type FormField } from '../types';
+import { isTrue } from '../utils/boolean-utils';
+import { FieldValidator } from './form-validator';
+
+export const DateValidator: FormFieldValidator = {
+  validate: (field: FormField, value: Date, config: any) => {
+    const now = new Date();
+    const errors = !value ? FieldValidator.validate(field, value) : [];
+    if (errors.length) {
+      return errors;
+    }
+    if (value && !isTrue(config?.allowFutureDates)) {
+      return value.getTime && value.getTime() > now.getTime()
+        ? [{ resultType: 'error', errCode: 'value.invalid', message: 'Future dates not allowed' }]
+        : [];
+    }
+    return [];
+  },
+};

package/src/validators/default-value-validator.ts

@@ -0,0 +1,36 @@
+import dayjs from 'dayjs';
+import { type FormFieldValidator, type FormField } from '../types';
+import { codedTypes } from '../constants';
+import { isEmpty } from './form-validator';
+
+export const DefaultValueValidator: FormFieldValidator = {
+  validate: (field: FormField, value: any) => {
+    if (!isEmpty(value) && codedTypes.includes(field.questionOptions.rendering)) {
+      const valuesArray = Array.isArray(value) ? value : [value];
+      // check whether value exists in answers
+      if (
+        !valuesArray.every((val: string) =>
+          field.questionOptions.answers?.find((answer) => answer.concept === val || answer.value === val),
+        )
+      ) {
+        return [
+          { resultType: 'error', errCode: 'invalid.defaultValue', message: 'Value not found in coded answers list' },
+        ];
+      }
+    }
+    if (!isEmpty(value) && field.questionOptions.rendering == 'date') {
+      // Check if value is a valid date value
+      if (!dayjs(value).isValid()) {
+        return [{ resultType: 'error', errCode: 'invalid.defaultValue', message: `Invalid date value: '${value}'` }];
+      }
+    }
+    if (!isEmpty(value) && field.questionOptions.rendering == 'number') {
+      if (isNaN(value)) {
+        return [
+          { resultType: 'error', errCode: 'invalid.defaultValue', message: `Invalid numerical  value: '${value}'` },
+        ];
+      }
+    }
+    return [];
+  },
+};

package/src/validators/form-validator.ts

@@ -0,0 +1,95 @@
+import { type FormFieldValidator, type FormField } from '../types';
+export const fieldRequiredErrCode = 'field.required';
+export const fieldOutOfBoundErrCode = 'field.outOfBound';
+
+export const FieldValidator: FormFieldValidator = {
+  validate: (field: FormField, value: any) => {
+    if (field.meta?.submission?.unspecified) {
+      return [];
+    }
+    if (isEmpty(value) && field.isRequired) {
+      if (typeof field.required === 'object' && field.required.type === 'conditionalRequired' && field.isRequired) {
+        return addError(fieldRequiredErrCode, field.required.message ?? 'Field is mandatory');
+      } else if (field.isRequired) {
+        return addError(fieldRequiredErrCode, 'Field is mandatory');
+      }
+    }
+    if (field.questionOptions.rendering === 'text') {
+      const minLength = field.questionOptions.minLength;
+      const maxLength = field.questionOptions.maxLength;
+
+      return textInputLengthValidator(minLength, maxLength, value?.length) ?? [];
+    }
+    if (field.questionOptions.rendering === 'number') {
+      const min = Number(field.questionOptions.min);
+      const max = Number(field.questionOptions.max);
+      const disallowDecimals = field.questionOptions.disallowDecimals || field.meta?.concept?.allowDecimal;
+      if (isEmpty(value)) return [];
+      if (disallowDecimals && !Number.isInteger(value)) {
+        return addError(fieldOutOfBoundErrCode, 'Decimal values are not allowed for this field');
+      }
+      if (!Number.isNaN(min) || !Number.isNaN(max)) {
+        return numberInputRangeValidator(min, max, value);
+      }
+    }
+    return [];
+  },
+};
+
+export function numberInputRangeValidator(min: number, max: number, inputValue: number) {
+  if (!Number.isNaN(min) && inputValue < min) {
+    return addError(fieldOutOfBoundErrCode, `Value must be greater than ${min}`);
+  }
+
+  if (!Number.isNaN(max) && inputValue > max) {
+    return addError(fieldOutOfBoundErrCode, `Value must be lower than ${max}`);
+  }
+
+  return [];
+}
+
+export function isEmpty(value: any): boolean {
+  if (value === undefined || value === null || value === '') {
+    return true;
+  }
+  if (typeof value == 'string' && !value?.trim()) {
+    return true;
+  }
+  if (Array.isArray(value) && !value.length) {
+    return true;
+  }
+  return false;
+}
+
+export function textInputLengthValidator(minLength: string, maxLength: string, inputLength: number) {
+  const minLen = Number(minLength);
+  const maxLen = Number(maxLength);
+
+  if (typeof inputLength === 'number' && !Number.isNaN(inputLength)) {
+    if (minLen && maxLen && inputLength >= minLen && inputLength <= maxLen) {
+      return [];
+    }
+
+    if (minLen && inputLength < minLen) {
+      return addError(fieldOutOfBoundErrCode, `Length should be at least ${minLen} characters`);
+    }
+
+    if (maxLen && inputLength > maxLen) {
+      return addError(fieldOutOfBoundErrCode, `Length should not exceed ${maxLen} characters`);
+    }
+
+    if (maxLen && minLen && inputLength < minLen && inputLength > maxLen) {
+      return addError(fieldOutOfBoundErrCode, `Length should be between ${minLen} and ${maxLen} characters`);
+    }
+  }
+}
+
+export function addError(errorCode: string, message: string): [{}] {
+  return [
+    {
+      resultType: 'error',
+      errCode: errorCode,
+      message: message,
+    },
+  ];
+}

package/src/validators/js-expression-validator.ts

@@ -0,0 +1,44 @@
+import { type FormFieldValidator, type FormField } from '../types';
+import { evaluateExpression, type ExpressionContext } from '../utils/expression-runner';
+
+interface ExpressionValidatorConfig {
+  failsWhenExpression?: string;
+  warnsWhenExpression?: string;
+  message: string;
+  formFields: FormField[];
+  expressionContext: ExpressionContext;
+  values: Record<string, any>;
+}
+
+export const ExpressionValidator: FormFieldValidator = {
+  validate: function (field: FormField, value: any, config: ExpressionValidatorConfig) {
+    const INVALID_VALUE_ERR_CODE = 'value.invalid';
+    const INVALID_VALUE_ERR_MESSAGE = 'Invalid value';
+    const FIELD_HAS_WARNINGS_MESSAGE = 'Field has warnings';
+    config.expressionContext.myValue = value;
+    return Object.keys(config)
+      .filter((key) => key === 'failsWhenExpression' || key === 'warnsWhenExpression')
+      .flatMap((key) => {
+        const isErrorValidator = key === 'failsWhenExpression';
+        return evaluateExpression(
+          config[key],
+          { value: field, type: 'field' },
+          config.formFields,
+          { ...config.values, [field.id]: value },
+          config.expressionContext,
+        )
+          ? [
+              {
+                resultType: isErrorValidator ? 'error' : 'warning',
+                errCode: isErrorValidator ? INVALID_VALUE_ERR_CODE : null,
+                message: config.message
+                  ? config.message
+                  : isErrorValidator
+                  ? INVALID_VALUE_ERR_MESSAGE
+                  : FIELD_HAS_WARNINGS_MESSAGE,
+              },
+            ]
+          : [];
+      });
+  },
+};

package/src/validators/schema.ts

@@ -0,0 +1,34 @@
+// import { z, type ZodTypeAny } from 'zod';
+// import { type FormFieldValidator, type FormField, type ValidationResult } from '../types';
+
+// TODOs
+// - add a reactive context to evaluate expressions
+// - figure out how to track errors vs warnings with different severity levels
+// (I will be managing validation manually for now until I figure out the above)
+// export const createValidationSchema = (formFields: FormField[], validators: Record<string, FormFieldValidator>) => {
+//   const schemaShape: Record<string, ZodTypeAny> = {};
+//   formFields.forEach((field) => {
+//     schemaShape[field.id] = zodFieldValidator(field, validators);
+//   });
+//   return z.object(schemaShape);
+// };
+
+// const zodFieldValidator = (field: FormField, validators: Record<string, FormFieldValidator>) => {
+//   return z.any().refine((value) => {
+//     const errorsAndWarnings: ValidationResult[] = [];
+//     try {
+//       field.validators.forEach((validatorConfig) => {
+//         const errorsAndWarnings = validators[validatorConfig.type]?.validate?.(field, value, validatorConfig);
+//         if (errorsAndWarnings?.length) {
+//           errorsAndWarnings.forEach((errorOrWarning) => {
+//             errorsAndWarnings.push(errorOrWarning);
+//           });
+//         }
+//       });
+//       return errorsAndWarnings.length === 0;
+//     } catch (error) {
+//       console.error(error);
+//       return false;
+//     }
+//   });
+// };