@wavemaker-ai/react-runtime 1.0.0-next.27766

package/components/data/form/base-form/index.js

@@ -0,0 +1,691 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { jsx } from "react/jsx-runtime";
+import { useMemo, useState, useRef, useEffect, useCallback } from "react";
+import clsx from "clsx";
+import { useForm } from "react-hook-form";
+import get from "lodash-es/get";
+import debounce from "lodash-es/debounce";
+import { defaultProps } from "./props";
+import {
+  FormProvider,
+  useFormRef as useFormContextRef,
+  ParentFormDataContext
+} from "../form-context";
+import { cleanRowData } from "../../table/utils";
+import { getItemsPerRowClass } from "../../list/utils/list-helpers";
+import {
+  getFieldLayoutConfig,
+  isElementInViewport,
+  scrollToElement,
+  transformRangeFilterData,
+  getWidgetFormFields,
+  registerChildFieldInWidget
+} from "./utils";
+import {
+  useFormDataSync,
+  useParentFormRelationship,
+  useFormValidation,
+  useFormOperations,
+  useFormSubmission,
+  FormType,
+  isChildFormType,
+  usesPrefixedFields
+} from "./hooks";
+import { useWidgetProxy } from "../../../../context/WidgetProvider";
+import {
+  useAppNotificationAction,
+  useNotifyApp
+} from "../../../../context/AppContext";
+const DEFAULT_CLASS = "panel app-panel app-form";
+const BaseForm = (WrappedComponent) => {
+  const ControlledForm = (FormProps) => {
+    var _a;
+    const props = __spreadValues(__spreadValues({}, defaultProps), FormProps);
+    const formProxy = useWidgetProxy(props.name);
+    const notificationAction = useAppNotificationAction();
+    const notifyApp = useNotifyApp();
+    const {
+      name: formName,
+      expanded: initialExpanded,
+      isInsideWizard,
+      formdata,
+      listener,
+      className,
+      collapsible,
+      captionwidth,
+      captionposition,
+      itemsperrow,
+      messagelayout,
+      errormessage,
+      standalone = false
+    } = props;
+    const parentFormRef = useFormContextRef();
+    const formReff = useRef(null);
+    const formRef = useRef(null);
+    const messageRef = useRef(null);
+    const formIdRef = useRef(Math.random().toString(36).substring(2, 15));
+    const formfieldsRef = useRef({});
+    const formDataref = useRef(null);
+    const lastEmittedValuesSerialized = useRef("");
+    const lastUpdateOriginRef = useRef("external");
+    const [expanded, setExpanded] = useState(initialExpanded);
+    const [childFormData, setChildFormData] = useState();
+    const [formfields, setFormfields] = useState({});
+    const [headerActions, setHeaderActions] = useState({});
+    const [showmessage, setShowMessage] = useState(false);
+    const [statusMessage, setStatusMessage] = useState({
+      caption: "",
+      type: ""
+    });
+    const {
+      control,
+      handleSubmit,
+      formState: { errors, isValid, submitCount },
+      reset,
+      watch,
+      trigger,
+      getValues,
+      clearErrors,
+      setValue
+    } = useForm({
+      defaultValues: formdata,
+      mode: "onTouched",
+      reValidateMode: "onBlur"
+    });
+    const {
+      formType,
+      formArrayIndex,
+      effectiveChildDatasetNode,
+      fullDataPath,
+      rootParentForm,
+      parentFormData,
+      parentFormDataContext
+    } = useParentFormRelationship({
+      name: formName || "",
+      parentForm: props.parentForm,
+      isParentList: props.isParentList,
+      parentListName: props.parentListName,
+      childdatasetnode: props.childdatasetnode,
+      formArrayIndex: props.formArrayIndex
+    });
+    const isChildForm = isChildFormType(formType);
+    const hasPrefixedFields = usesPrefixedFields(formType);
+    const {
+      currentFormData,
+      syncFormData,
+      resetFormData,
+      clearFormData,
+      markCurrentData,
+      isUpdating
+    } = useFormDataSync({
+      reset,
+      formType,
+      formName
+    });
+    const { captionCls, widgetCls } = useMemo(
+      () => getFieldLayoutConfig(captionwidth, captionposition, "os"),
+      [captionwidth, captionposition]
+    );
+    const itemsPerRow = useMemo(() => {
+      if (itemsperrow == null || String(itemsperrow).trim() === "") {
+        return void 0;
+      }
+      return getItemsPerRowClass(String(itemsperrow));
+    }, [itemsperrow]);
+    const listenerWidgetFormdata = (_a = formProxy == null ? void 0 : formProxy.formdata) != null ? _a : void 0;
+    const widgetFormData = useMemo(() => {
+      if (!formName) return formdata;
+      const proxyFormdata = formProxy == null ? void 0 : formProxy.formdata;
+      return proxyFormdata && Object.keys(proxyFormdata).length > 0 ? proxyFormdata : formdata;
+    }, [formName, formdata, listenerWidgetFormdata]);
+    const formClassName = useMemo(() => {
+      return isInsideWizard ? clsx(className) : clsx(DEFAULT_CLASS, className);
+    }, [isInsideWizard, className]);
+    const onDataSourceChangeFiredRef = useRef(false);
+    const registerHeaderAction = useCallback((actionName, action) => {
+      if (!action || !actionName) return;
+      setHeaderActions((prev) => {
+        if (!prev[actionName]) {
+          return __spreadProps(__spreadValues({}, prev), { [actionName]: action });
+        }
+        return prev;
+      });
+    }, []);
+    const onChangeHandler = useCallback((fieldName, value) => {
+      if (!fieldName || value === void 0) return;
+      setFormfields((prev) => __spreadProps(__spreadValues({}, prev), {
+        [fieldName]: __spreadProps(__spreadValues({}, prev[fieldName]), { value, datavalue: value })
+      }));
+    }, []);
+    const checkAppServiceErrorMsg = useCallback((type) => {
+      var _a2;
+      if (notificationAction && type === "error") {
+        return (_a2 = notificationAction == null ? void 0 : notificationAction.getMessage) == null ? void 0 : _a2.call(notificationAction);
+      }
+      return void 0;
+    }, []);
+    const clearMessage = useCallback(() => {
+      setStatusMessage({ caption: "", type: "" });
+      setShowMessage(false);
+    }, []);
+    const toggleMessage = useCallback(
+      (state, msg, type) => {
+        var _a2;
+        let template = msg;
+        if (state && msg) {
+          if (type === "error" && errormessage && errormessage.length > 0) {
+            template = errormessage;
+          }
+          if (messagelayout === "Inline") {
+            template = checkAppServiceErrorMsg(type) || template;
+            setStatusMessage({ caption: template || "", type });
+            setShowMessage(true);
+            if ((_a2 = messageRef.current) == null ? void 0 : _a2.showMessage) {
+              messageRef.current.showMessage(template, type);
+            }
+            const formEl = formRef.current;
+            if (formEl && !isElementInViewport(formEl)) {
+              scrollToElement(formEl);
+            }
+          } else {
+            notifyApp == null ? void 0 : notifyApp(template || "", type || "", true);
+          }
+        } else {
+          setStatusMessage({ caption: "", type: "" });
+          setShowMessage(false);
+        }
+        if (formRef.current) {
+          scrollToElement(formRef.current);
+        }
+      },
+      [messagelayout, errormessage, checkAppServiceErrorMsg]
+    );
+    const handleChildDataChange = useCallback(
+      (fullDataPath2, formData) => {
+        if (!fullDataPath2 || !formData) return;
+        const currentValues = getValues();
+        const pathParts = fullDataPath2.replace(/\[(\d+)\]/g, ".$1").split(".");
+        let existingData = currentValues;
+        for (const part of pathParts) {
+          if (existingData && typeof existingData === "object") {
+            existingData = existingData[part];
+          } else {
+            existingData = void 0;
+            break;
+          }
+        }
+        let mergedData;
+        if (existingData && typeof existingData === "object" && !Array.isArray(existingData)) {
+          const filteredExisting = {};
+          Object.keys(existingData).forEach((key) => {
+            const value = existingData[key];
+            if (!Array.isArray(value) || key in formData) {
+              filteredExisting[key] = value;
+            }
+          });
+          mergedData = __spreadValues(__spreadValues({}, filteredExisting), formData);
+        } else {
+          mergedData = formData;
+        }
+        setValue(fullDataPath2, mergedData, { shouldValidate: false, shouldDirty: true });
+        const currentData = getValues();
+        markCurrentData(currentData);
+        lastUpdateOriginRef.current = "child";
+        formProxy.formdata = currentData;
+      },
+      [setValue, getValues, markCurrentData, formName]
+    );
+    const handleRegisterChildField = useCallback(
+      (data) => {
+        const { childFormName, widget, formKey, fieldName } = data;
+        if (childFormName && widget && formKey && fieldName) {
+          registerChildFieldInWidget(listener, formName, { widget, formKey, fieldName });
+        }
+      },
+      [formName]
+    );
+    const notifyDataOutput = useCallback(
+      (data) => {
+        var _a2;
+        const cleanedData = cleanRowData(data);
+        if (formName) {
+          (_a2 = listener == null ? void 0 : listener.onChange) == null ? void 0 : _a2.call(listener, formName, { dataoutput: cleanedData });
+        }
+      },
+      [formName]
+    );
+    const updateFormData = useCallback((data) => {
+      if (typeof data === "function") {
+        formDataref.current = data(formDataref.current || {});
+      } else {
+        formDataref.current = __spreadValues(__spreadValues({}, formDataref.current || {}), data);
+      }
+    }, []);
+    const { validationMessagesRef, validateFieldsOnSubmit } = useFormValidation({
+      formRef,
+      formfields,
+      formReff,
+      control,
+      trigger,
+      errors,
+      formName: formName || "",
+      listener
+    });
+    const { submit, deleteEntry } = useFormSubmission({
+      formName: formName || "",
+      formfields,
+      formDataref,
+      getValues,
+      formType,
+      validateFieldsOnSubmit,
+      resetFormData,
+      toggleMessage,
+      setShowViewMode: (val) => setShowViewMode(val),
+      listener,
+      datasource: props.datasource,
+      formSubmit: props.formSubmit,
+      widgettype: props.widgettype,
+      onBeforeSubmit: props.onBeforeSubmit,
+      onSubmit: props.onSubmit,
+      onResult: props.onResult,
+      onSuccess: props.onSuccess,
+      formSuccess: props.formSuccess,
+      onError: props.onError,
+      insertmessage: props.insertmessage,
+      updatemessage: props.updatemessage,
+      deletemessage: props.deletemessage,
+      postmessage: props.postmessage,
+      errormessage,
+      messagelayout,
+      standalone: standalone || false
+    });
+    const livefilterFn = props.Livefilter || (() => {
+    });
+    const filter = useMemo(
+      () => handleSubmit((data, e) => {
+        e == null ? void 0 : e.preventDefault();
+        e == null ? void 0 : e.stopPropagation();
+        const transformedData = transformRangeFilterData(data);
+        return livefilterFn(transformedData, false, formfieldsRef.current);
+      }),
+      [handleSubmit, livefilterFn]
+    );
+    const debouncedFilter = useCallback(() => {
+      const debouncedFn = debounce(filter, 250);
+      debouncedFn();
+    }, [filter]);
+    const {
+      formreset: formresetFn,
+      create,
+      edit,
+      setFormData,
+      saveAndNew,
+      saveAndView,
+      showViewMode,
+      setShowViewMode
+    } = useFormOperations({
+      formName: formName || "",
+      formfields: (formProxy == null ? void 0 : formProxy.formfields) || {},
+      formRef,
+      formReff,
+      formType,
+      fullDataPath,
+      parentFormDataContext,
+      clearFormData,
+      resetFormData,
+      trigger,
+      submit,
+      formProxy: formProxy || {},
+      widgetFormType: props["form-type"],
+      debouncedFilter
+    });
+    const clearFilter = useMemo(
+      () => handleSubmit((data, e) => {
+        e == null ? void 0 : e.preventDefault();
+        e == null ? void 0 : e.stopPropagation();
+        formresetFn();
+        const transformedData = transformRangeFilterData(data);
+        livefilterFn(transformedData, true, formfieldsRef.current);
+      }),
+      [handleSubmit, livefilterFn]
+    );
+    const expandCollapsePanel = useCallback(() => {
+      if (collapsible) {
+        setExpanded(!expanded);
+      }
+    }, [collapsible, expanded]);
+    const handleCancel = useCallback(() => {
+      if (typeof props.cancel === "function") {
+        props.cancel();
+        return;
+      }
+      setShowViewMode(true);
+      formresetFn();
+    }, [setShowViewMode, props.cancel, formresetFn]);
+    const getFieldValue = useCallback((fieldName) => watch(fieldName), [watch]);
+    const highlightInvalidFields = useCallback(async () => {
+      await validateFieldsOnSubmit();
+    }, [validateFieldsOnSubmit]);
+    useEffect(() => {
+      formfieldsRef.current = formfields;
+    }, [formfields]);
+    useEffect(() => {
+      if ((listener == null ? void 0 : listener.onChange) && formName) {
+        listener.onChange(formName, { valid: isValid });
+      }
+    }, [isValid, formName]);
+    useEffect(() => {
+      if (parentFormData && effectiveChildDatasetNode) {
+        const dataAtNode = get(parentFormData, effectiveChildDatasetNode);
+        const isArrayData = Array.isArray(dataAtNode);
+        let childData;
+        if (isArrayData && formArrayIndex >= 0) {
+          childData = formArrayIndex < dataAtNode.length ? dataAtNode[formArrayIndex] : {};
+        } else {
+          childData = dataAtNode != null ? dataAtNode : {};
+        }
+        setChildFormData(childData);
+      }
+    }, [parentFormData, effectiveChildDatasetNode, formArrayIndex]);
+    useEffect(() => {
+      var _a2;
+      if (isChildForm && (parentFormDataContext == null ? void 0 : parentFormDataContext.lastUpdateOrigin) === "child") {
+        return;
+      }
+      let dataSource;
+      if (formType === FormType.DIRECT_CHILD || formType === FormType.LIST_CHILD) {
+        dataSource = childFormData;
+      } else if (formType === FormType.PREFAB_CHILD || formType === FormType.LIST_PREFAB_CHILD) {
+        const contextFormData = parentFormDataContext == null ? void 0 : parentFormDataContext.formdata;
+        if (formType === FormType.LIST_PREFAB_CHILD && Array.isArray(contextFormData) && formArrayIndex >= 0 && formArrayIndex < contextFormData.length) {
+          dataSource = (_a2 = contextFormData[formArrayIndex]) != null ? _a2 : void 0;
+        } else {
+          dataSource = contextFormData;
+        }
+      } else {
+        dataSource = widgetFormData || formdata || (parentFormDataContext == null ? void 0 : parentFormDataContext.formdata);
+      }
+      if (dataSource && typeof dataSource === "object" && !Array.isArray(dataSource)) {
+        syncFormData(dataSource);
+        lastUpdateOriginRef.current = "external";
+        if (props["form-type"] === "live-filter" && Object.keys(dataSource).length > 0) {
+          debouncedFilter();
+        }
+      }
+    }, [
+      formType,
+      isChildForm,
+      childFormData,
+      widgetFormData,
+      formdata,
+      formArrayIndex,
+      parentFormDataContext == null ? void 0 : parentFormDataContext.formdata,
+      parentFormDataContext == null ? void 0 : parentFormDataContext.lastUpdateOrigin,
+      syncFormData,
+      debouncedFilter
+    ]);
+    useEffect(() => {
+      return () => {
+        var _a2;
+        if (!formName || !formRef.current) return;
+        (_a2 = props == null ? void 0 : props.destroy) == null ? void 0 : _a2.call(props, formName);
+        formresetFn();
+      };
+    }, []);
+    useEffect(() => {
+      const registerFn = parentFormDataContext == null ? void 0 : parentFormDataContext.registerChildField;
+      if (!registerFn || !formName) return;
+      const widgetFormFields = getWidgetFormFields(listener, formName);
+      const formFieldsToRegister = widgetFormFields || formfields;
+      Object.entries(formFieldsToRegister).forEach(([key, widget]) => {
+        if (key.includes("formWidget")) return;
+        const typedWidget = widget;
+        const formKey = (typedWidget == null ? void 0 : typedWidget.formKey) || (typedWidget == null ? void 0 : typedWidget.fieldName) || key;
+        const fieldName = (typedWidget == null ? void 0 : typedWidget.fieldName) || key;
+        registerFn({
+          childFormName: formName,
+          widget,
+          formKey,
+          fieldName
+        });
+      });
+    }, [formfields, formName, parentFormDataContext == null ? void 0 : parentFormDataContext.registerChildField]);
+    useEffect(() => {
+      const el = formRef.current;
+      if (!el) return;
+      const emit = () => {
+        el.dispatchEvent(
+          new CustomEvent("wm:form-validity", {
+            bubbles: true,
+            detail: { isValid }
+          })
+        );
+      };
+      emit();
+      const unsubscribe = watch((values) => {
+        emit();
+        if (isUpdating()) return;
+        const serialized = JSON.stringify(values);
+        if (serialized !== lastEmittedValuesSerialized.current) {
+          lastEmittedValuesSerialized.current = serialized;
+          let normalizedValues = hasPrefixedFields && formName ? values[formName] : values;
+          if (isChildForm && normalizedValues && typeof normalizedValues === "object" && !Array.isArray(normalizedValues)) {
+            const childFormNames = formReff.current ? Object.keys(formReff.current) : [];
+            if (childFormNames.length > 0) {
+              const filteredValues = {};
+              Object.keys(normalizedValues).forEach((key) => {
+                const value = normalizedValues[key];
+                if (value === null || typeof value !== "object") {
+                  filteredValues[key] = value;
+                }
+              });
+              normalizedValues = filteredValues;
+            }
+          }
+          markCurrentData(normalizedValues);
+          if (fullDataPath && (parentFormDataContext == null ? void 0 : parentFormDataContext.onChildDataChange)) {
+            parentFormDataContext.onChildDataChange(fullDataPath, normalizedValues);
+          }
+          const autoupdate = props.autoupdate;
+          const isAutoupdateEnabled = autoupdate !== false && String(autoupdate).toLowerCase() !== "false" && String(autoupdate).toLowerCase() !== "0";
+          const isAutoUpdateLiveFilter = props["form-type"] === "live-filter" && isAutoupdateEnabled;
+          if (isAutoUpdateLiveFilter) {
+            debouncedFilter == null ? void 0 : debouncedFilter();
+          }
+          notifyDataOutput(getValues());
+        }
+      });
+      return () => {
+        if (typeof unsubscribe === "function") {
+          unsubscribe();
+        }
+      };
+    }, [
+      watch,
+      isValid,
+      rootParentForm,
+      fullDataPath,
+      formName,
+      formType,
+      hasPrefixedFields,
+      isChildForm,
+      debouncedFilter
+    ]);
+    useEffect(() => {
+      if (!props.onDataSourceChange || !formName) return;
+      if (onDataSourceChangeFiredRef.current) return;
+      const Widgets = (formProxy == null ? void 0 : formProxy.formfields) || {};
+      const currentFields = Object.keys(Widgets).filter((key) => !key.includes("formWidget") && Widgets[key]).map((key) => Widgets[key]);
+      if (currentFields.length > 0) {
+        onDataSourceChangeFiredRef.current = true;
+        props.onDataSourceChange(currentFields);
+      }
+    }, [props.onDataSourceChange, formName]);
+    useEffect(() => {
+      if (formRef.current) {
+        const formEl = formRef.current;
+        formEl.getFormData = () => ({ values: watch(), isValid });
+        formEl.validateForm = () => submitCount === 0 ? isValid : trigger();
+        formEl.clearErrors = () => clearErrors();
+        formEl.getProps = () => props;
+        formEl.formWidgets = formfields;
+        formEl.getValidationMessages = () => validationMessagesRef.current;
+        formEl.validationMessages = validationMessagesRef.current;
+      }
+    }, [watch, trigger, isValid, errors, formfields, clearErrors, props, submitCount]);
+    useEffect(() => {
+      if (!parentFormRef) return;
+      if (!parentFormRef.current) {
+        parentFormRef.current = {};
+      }
+      const formId = formIdRef.current;
+      parentFormRef.current[formId] = {
+        formreset: formresetFn,
+        validateFieldsOnSubmit
+      };
+      return () => {
+        if (parentFormRef.current && parentFormRef.current[formId]) {
+          delete parentFormRef.current[formId];
+        }
+      };
+    }, [parentFormRef, formresetFn, validateFieldsOnSubmit]);
+    const computedFormdata = widgetFormData || childFormData || formdata;
+    const ref = useMemo(
+      () => ({
+        ref: formReff,
+        updateFormData,
+        control,
+        watch,
+        registerHeaderAction,
+        onChangeHandler,
+        trigger,
+        errors,
+        name: formName,
+        captionposition: props.captionposition,
+        captionCls,
+        widgetCls,
+        itemsPerRow,
+        validationtype: props.validationtype,
+        submitCount,
+        showViewMode,
+        formdata: computedFormdata,
+        submit,
+        formreset: formresetFn
+      }),
+      [
+        updateFormData,
+        control,
+        watch,
+        registerHeaderAction,
+        onChangeHandler,
+        trigger,
+        errors,
+        formName,
+        props.captionposition,
+        captionCls,
+        widgetCls,
+        itemsPerRow,
+        props.validationtype,
+        submitCount,
+        showViewMode,
+        computedFormdata,
+        submit,
+        formresetFn
+      ]
+    );
+    const conditionalProps = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, props.target && { target: props.target }), props.method && { method: props.method }), props.encType && { encType: props.encType }), props.action && { action: props.action });
+    const formProps = __spreadProps(__spreadValues(__spreadValues({}, props), conditionalProps), {
+      submit,
+      formreset: formresetFn,
+      formfields,
+      formWidgets: formfields,
+      headerActions,
+      ref,
+      formElementRef: formRef,
+      toggleMessage,
+      clearMessage,
+      expandCollapsePanel,
+      expanded,
+      showmessage,
+      statusMessage,
+      showViewMode,
+      filter,
+      clearFilter,
+      validateFieldsOnSubmit,
+      errors,
+      validationMessages: validationMessagesRef.current,
+      delete: deleteEntry,
+      cancel: handleCancel,
+      new: create,
+      edit,
+      setShowViewMode,
+      dataoutput: getValues(),
+      save: submit,
+      setFormData,
+      reset,
+      numberoffields: Object.keys(formfields).length,
+      className: formClassName,
+      saveAndNew,
+      saveAndView,
+      highlightInvalidFields,
+      formdata: widgetFormData || childFormData || formdata,
+      captionCls,
+      widgetCls,
+      itemsPerRow
+    });
+    const parentFormDataContextValue = useMemo(
+      () => {
+        var _a2;
+        return {
+          formdata: (_a2 = currentFormData != null ? currentFormData : widgetFormData) != null ? _a2 : formdata,
+          formName: formName || "",
+          isValid,
+          rootParentForm: isChildForm ? rootParentForm || "" : formName || "",
+          parentDataPath: isChildForm ? fullDataPath : void 0,
+          lastUpdateOrigin: isChildForm ? parentFormDataContext == null ? void 0 : parentFormDataContext.lastUpdateOrigin : lastUpdateOriginRef.current,
+          onChildDataChange: isChildForm ? parentFormDataContext == null ? void 0 : parentFormDataContext.onChildDataChange : handleChildDataChange,
+          registerChildField: isChildForm ? parentFormDataContext == null ? void 0 : parentFormDataContext.registerChildField : handleRegisterChildField
+        };
+      },
+      [
+        currentFormData,
+        widgetFormData,
+        formdata,
+        formName,
+        isValid,
+        isChildForm,
+        rootParentForm,
+        fullDataPath,
+        parentFormDataContext == null ? void 0 : parentFormDataContext.lastUpdateOrigin,
+        parentFormDataContext == null ? void 0 : parentFormDataContext.onChildDataChange,
+        parentFormDataContext == null ? void 0 : parentFormDataContext.registerChildField,
+        handleChildDataChange,
+        handleRegisterChildField
+      ]
+    );
+    return /* @__PURE__ */ jsx(ParentFormDataContext.Provider, { value: parentFormDataContextValue, children: /* @__PURE__ */ jsx(FormProvider, { value: ref, isViewMode: showViewMode, children: /* @__PURE__ */ jsx(WrappedComponent, __spreadProps(__spreadValues({}, formProps), { formWidgets: formfields, formfields })) }) });
+  };
+  return ControlledForm;
+};
+var base_form_default = BaseForm;
+export {
+  base_form_default as default
+};