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

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

@@ -0,0 +1,298 @@
+var __defProp = Object.defineProperty;
+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;
+};
+import {
+  forEach,
+  split,
+  set as lodashSet,
+  isPlainObject,
+  omit,
+  mapValues,
+  pickBy,
+  filter,
+  find,
+  get,
+  keys,
+  some
+} from "lodash-es";
+import { REGEX } from "./constant";
+let userAgent = "";
+if (typeof window !== "undefined") {
+  userAgent = window.navigator.userAgent;
+}
+const isAndroid = () => REGEX.ANDROID.test(userAgent);
+const getFieldLayoutConfig = (captionWidth, captionPosition, os) => {
+  let captionCls = "", widgetCls = "";
+  captionPosition = captionPosition || "top";
+  if (captionPosition === "top" || captionPosition === "floating") {
+    if (os && os === "android" || isAndroid()) {
+      captionCls = widgetCls = "col-xs-12";
+    }
+  } else if (captionWidth) {
+    forEach(split(captionWidth, " "), function(cls) {
+      const keys2 = split(cls, "-"), tier = keys2[0];
+      let _captionWidth, widgetWidth;
+      _captionWidth = parseInt(keys2[1], 10);
+      widgetWidth = 12 - _captionWidth;
+      widgetWidth = widgetWidth <= 0 ? 12 : widgetWidth;
+      captionCls += " col-" + tier + "-" + _captionWidth;
+      widgetCls += " col-" + tier + "-" + widgetWidth;
+    });
+  }
+  return {
+    captionCls,
+    widgetCls
+  };
+};
+const isElementInViewport = (el) => {
+  if (!el) return false;
+  const rect = el.getBoundingClientRect();
+  return rect.top >= 0 && rect.left >= 0 && rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) && rect.right <= (window.innerWidth || document.documentElement.clientWidth);
+};
+const focusOnFirstInvalidField = (formElement, errorFieldNames) => {
+  if (!formElement) return;
+  setTimeout(() => {
+    var _a;
+    if (!formElement) return;
+    let focusableElement = null;
+    if (errorFieldNames == null ? void 0 : errorFieldNames.length) {
+      const selectors = [
+        (name) => `input[name="${name}"]:not([type="hidden"]), textarea[name="${name}"], select[name="${name}"]`,
+        (name) => `#${name}`,
+        (name) => `[data-name="${name}"], div[name="${name}"]`
+      ];
+      for (const fieldName of errorFieldNames) {
+        for (const selector of selectors) {
+          const element = formElement.querySelector(selector(fieldName));
+          if (element) {
+            focusableElement = element.matches("input, textarea, select") ? element : element.querySelector(
+              'input:not([type="hidden"]), textarea, select, [contenteditable="true"]'
+            );
+            if (focusableElement) break;
+          }
+        }
+        if (focusableElement) break;
+      }
+    }
+    const fallbackSelectors = [
+      'input.ng-invalid:not([type="hidden"]), textarea.ng-invalid, select.ng-invalid',
+      '.app-input-wrapper.ng-invalid input:not([type="hidden"]), .MuiFormControl-root.Mui-error input:not([type="hidden"])',
+      ".help-block.text-danger",
+      'input[aria-invalid="true"], textarea[aria-invalid="true"], select[aria-invalid="true"]'
+    ];
+    for (const selector of fallbackSelectors) {
+      if (focusableElement) break;
+      const element = formElement.querySelector(selector);
+      if (element) {
+        focusableElement = element.matches("input, textarea, select") ? element : (_a = element.parentElement) == null ? void 0 : _a.querySelector(
+          'input:not([type="hidden"]), textarea, select'
+        );
+      }
+    }
+    if (focusableElement) {
+      if (!isElementInViewport(focusableElement)) {
+        focusableElement.scrollIntoView({ behavior: "smooth", block: "center" });
+      }
+      setTimeout(() => focusableElement == null ? void 0 : focusableElement.focus({ preventScroll: true }), 100);
+    }
+  }, 100);
+};
+const scrollToElement = (el) => {
+  if (el) {
+    el.scrollIntoView({ behavior: "smooth", block: "start" });
+  }
+};
+const cleanNullValues = (data) => {
+  return mapValues(data, (value) => value === null ? "" : value);
+};
+const filterTableColumns = (data) => {
+  return pickBy(data, (_, key) => !key.startsWith("wm_table_column_"));
+};
+const transformToNestedObject = (data, formfields, formName) => {
+  if (!data || typeof data !== "object") return {};
+  const result = {};
+  const dataKeys = keys(data);
+  const childFormKeys = new Set(
+    filter(dataKeys, (key) => {
+      const fieldInfo = formfields[`${formName}.${key}`];
+      return !fieldInfo && isPlainObject(data[key]);
+    })
+  );
+  const childFormNestedPaths = /* @__PURE__ */ new Map();
+  if (childFormKeys.size > 0) {
+    forEach(dataKeys, (parentKey) => {
+      const parentValue = data[parentKey];
+      if (isPlainObject(parentValue)) {
+        forEach(keys(parentValue), (nestedKey) => {
+          if (childFormKeys.has(nestedKey) && nestedKey !== parentKey && isPlainObject(data[nestedKey])) {
+            childFormNestedPaths.set(nestedKey, `${parentKey}.${nestedKey}`);
+          }
+        });
+      }
+    });
+  }
+  forEach(dataKeys, (key) => {
+    const fieldInfo = formfields[`${formName}.${key}`];
+    const nestedPath = childFormNestedPaths.get(key);
+    const transformedKey = nestedPath || (fieldInfo == null ? void 0 : fieldInfo.dataKey) || key;
+    let valueToSet = data[key];
+    if (isPlainObject(valueToSet) && childFormNestedPaths.size > 0) {
+      const staleKeys = filter(keys(valueToSet), (k) => childFormNestedPaths.has(k));
+      if (staleKeys.length > 0) {
+        valueToSet = omit(valueToSet, staleKeys);
+      }
+    }
+    lodashSet(result, transformedKey, valueToSet);
+  });
+  return result;
+};
+const hasArrayData = (data) => {
+  if (!data || typeof data !== "object") return false;
+  return some(data, Array.isArray);
+};
+const filterArrayItems = (items, shouldIncludeKey) => {
+  return items.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+    return pickBy(item, shouldIncludeKey);
+  });
+};
+const getChildFormFieldNames = (arrayKey, widgets) => {
+  if (!widgets) return null;
+  const childForm = find(
+    Object.entries(widgets),
+    ([_, widget]) => (widget == null ? void 0 : widget.parentListName) === arrayKey && (widget == null ? void 0 : widget.parentForm)
+  );
+  if (!childForm) return null;
+  const [childFormName, childWidget] = childForm;
+  const parentFormfields = get(widgets, [childWidget.parentForm, "formfields"]);
+  if (!parentFormfields || typeof parentFormfields !== "object") return null;
+  const prefix = `${childFormName}.`;
+  const fieldNames = /* @__PURE__ */ new Set();
+  keys(parentFormfields).forEach((key) => {
+    if (!key.includes("_formWidget") && key.startsWith(prefix)) {
+      const fieldName = key.substring(prefix.length);
+      if (fieldName) fieldNames.add(fieldName);
+    }
+  });
+  return fieldNames.size > 0 ? fieldNames : null;
+};
+const filterArraysByRenderedForms = (data, widgets) => {
+  if (!widgets || !data || !hasArrayData(data)) return data;
+  const rootArrayKeys = new Set(
+    filter(keys(data), (key) => Array.isArray(data[key]) && widgets[key])
+  );
+  return mapValues(data, (value, key) => {
+    if (!Array.isArray(value) || !widgets[key]) return value;
+    const { $index, listItems } = widgets[key];
+    const renderedCount = $index !== void 0 && $index >= 0 ? $index + 1 : (listItems == null ? void 0 : listItems.length) !== void 0 && listItems.length >= 0 ? listItems.length : void 0;
+    let filtered = renderedCount !== void 0 ? value.slice(0, renderedCount) : value;
+    if (rootArrayKeys.size > 0) {
+      filtered = filterArrayItems(filtered, (k, v) => !(Array.isArray(v) && rootArrayKeys.has(k)));
+    }
+    const fieldNames = getChildFormFieldNames(key, widgets);
+    if (fieldNames) {
+      filtered = filterArrayItems(filtered, (k) => fieldNames.has(k));
+    }
+    return filtered;
+  });
+};
+const mergeWithFormDataRef = (data, formDataref) => {
+  if (!formDataref) return data;
+  return __spreadValues(__spreadValues({}, data), mapValues(
+    pickBy(formDataref, (_, key) => formDataref.hasOwnProperty(key)),
+    (val) => val || []
+  ));
+};
+const transformRangeFilterData = (data) => {
+  const maxWidgetKeys = filter(keys(data), (key) => key.endsWith("_maxWidget"));
+  return __spreadValues(__spreadValues({}, omit(data, maxWidgetKeys)), mapValues(
+    pickBy(
+      mapValues(maxWidgetKeys, (maxKey) => {
+        const baseKey = maxKey.replace("_maxWidget", "");
+        const min = data[baseKey];
+        const max = data[maxKey];
+        const processedMin = min !== void 0 && min !== "" && min !== null ? min : void 0;
+        const processedMax = max !== void 0 && max !== "" && max !== null ? max : void 0;
+        if (processedMin !== void 0 || processedMax !== void 0) {
+          return {
+            key: baseKey,
+            value: {
+              minValue: processedMin,
+              maxValue: processedMax,
+              min: processedMin,
+              max: processedMax
+            }
+          };
+        }
+        return null;
+      }),
+      (val) => val !== null
+    ),
+    (val) => val.value
+  ));
+};
+const getWidgetFormData = (listener, formName) => {
+  if (!formName || !(listener == null ? void 0 : listener.Widgets)) return void 0;
+  return listener.Widgets[formName];
+};
+const setWidgetFormData = (listener, formName, formdata) => {
+  var _a;
+  if (formName && ((_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[formName])) {
+    listener.Widgets[formName].formdata = formdata;
+  }
+};
+const getWidgetFormFields = (listener, formName) => {
+  var _a;
+  if (!formName || !(listener == null ? void 0 : listener.Widgets)) return void 0;
+  return (_a = listener.Widgets[formName]) == null ? void 0 : _a.formfields;
+};
+const setWidgetValidationMessages = (listener, formName, messages) => {
+  var _a;
+  if (formName && ((_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[formName])) {
+    listener.Widgets[formName].validationMessages = messages;
+  }
+};
+const registerChildFieldInWidget = (listener, formName, data) => {
+  var _a;
+  if (!formName || !((_a = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a[formName])) return;
+  const { formKey, fieldName, widget } = data;
+  const parentFormContext = listener.Widgets[formName];
+  parentFormContext.formfields = parentFormContext.formfields || {};
+  parentFormContext.formWidgets = parentFormContext.formWidgets || {};
+  parentFormContext.formfields[formKey] = widget;
+  parentFormContext.formWidgets[fieldName] = widget;
+  parentFormContext.formfields[`${fieldName}_formWidget`] = widget;
+  parentFormContext.formWidgets[`${fieldName}_formWidget`] = widget;
+};
+export {
+  cleanNullValues,
+  filterArraysByRenderedForms,
+  filterTableColumns,
+  focusOnFirstInvalidField,
+  getFieldLayoutConfig,
+  getWidgetFormData,
+  getWidgetFormFields,
+  hasArrayData,
+  isAndroid,
+  isElementInViewport,
+  mergeWithFormDataRef,
+  registerChildFieldInWidget,
+  scrollToElement,
+  setWidgetFormData,
+  setWidgetValidationMessages,
+  transformRangeFilterData,
+  transformToNestedObject
+};

package/components/data/form/dynamic-fields/constant.d.ts

@@ -0,0 +1 @@
+export declare const COMPONENT_MAP: Record<string, React.ComponentType<any>>;

package/components/data/form/dynamic-fields/constant.js

@@ -0,0 +1,43 @@
+import WmText from "../../../input/text";
+import WmTextarea from "../../../input/textarea";
+import WmNumber from "../../../input/number";
+import WmCurrency from "../../../input/currency";
+import WmSelect from "../../../input/select";
+import WmSlider from "../../../input/slider";
+import WmRating from "../../../input/rating";
+import WmCheckbox from "../../../input/default/checkbox";
+import WmCheckboxset from "../../../input/default/checkboxset";
+import WmRadioset from "../../../input/default/radioset";
+import WmSwitch from "../../../input/default/switch";
+import WmDate from "../../../input/epoch/date";
+import WmDatetime from "../../../input/epoch/datetime";
+import WmTime from "../../../input/epoch/time";
+import WmChips from "../../../input/chips";
+import WmColorPicker from "../../../input/color-picker";
+import WmFileupload from "../../../input/fileupload";
+import WmUpload from "../../../input/upload";
+import WmCalendar from "../../../input/calendar";
+const COMPONENT_MAP = {
+  text: WmText,
+  textarea: WmTextarea,
+  number: WmNumber,
+  currency: WmCurrency,
+  select: WmSelect,
+  slider: WmSlider,
+  rating: WmRating,
+  checkbox: WmCheckbox,
+  checkboxset: WmCheckboxset,
+  radioset: WmRadioset,
+  switch: WmSwitch,
+  date: WmDate,
+  datetime: WmDatetime,
+  time: WmTime,
+  chips: WmChips,
+  colorpicker: WmColorPicker,
+  fileupload: WmFileupload,
+  upload: WmUpload,
+  calendar: WmCalendar
+};
+export {
+  COMPONENT_MAP
+};

package/components/data/form/dynamic-fields/index.d.ts

@@ -0,0 +1,2 @@
+import { DynamicFormProps } from "./props";
+export default function DynamicForm(props: DynamicFormProps): import("react/jsx-runtime").JSX.Element;

package/components/data/form/dynamic-fields/index.js

@@ -0,0 +1,162 @@
+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));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useRef, useEffect } from "react";
+import isArray from "lodash-es/isArray";
+import clsx from "clsx";
+import { useFormContext } from "../form-context";
+import WmText from "../../../input/text";
+import WmLayoutGrid from "../../../container/layout-grid";
+import WmGridRow from "../../../container/layout-grid/grid-row";
+import WmGridColumn from "../../../container/layout-grid/grid-column";
+import WmLabel from "../../../basic/label";
+import WmFormField from "../form-field";
+import { updateMetadata } from "./utils";
+import { COMPONENT_MAP } from "./constant";
+const DEFAULT_FIELD_CLASS = "app-dynamic-form-field";
+function DynamicForm(props) {
+  const {
+    metadata,
+    listener,
+    layout = "1-column",
+    noOfColumns = 1,
+    isHorizontal = false,
+    name = "dynamicForm",
+    formRef,
+    onBeforeRender
+  } = props;
+  const formContext = useFormContext();
+  const { captionposition } = formContext || {};
+  const metadataRef = useRef(metadata);
+  useEffect(() => {
+    if (onBeforeRender) {
+      const data = onBeforeRender(metadata, props);
+      if (data) {
+        metadataRef.current = updateMetadata(data, listener) || metadata;
+      }
+    } else metadataRef.current = metadata;
+  }, [metadata, onBeforeRender]);
+  if (!isArray(metadataRef.current) || metadataRef.current.length === 0) {
+    return null;
+  }
+  const getColumnWidth = (fieldColumnWidth) => {
+    if (fieldColumnWidth) return fieldColumnWidth;
+    const columns = layout === "custom" ? noOfColumns : parseInt(layout.split("-")[0]);
+    return Math.floor(12 / columns);
+  };
+  const renderFormField = (field) => {
+    const ComponentToRender = COMPONENT_MAP[field.widget] || WmText;
+    const fieldProps = __spreadValues(__spreadProps(__spreadValues({}, field), {
+      className: field.class,
+      listener,
+      captionposition: isHorizontal ? "horizontal" : captionposition
+    }), formContext && {
+      formContext,
+      onChangeHandler: formContext.onChangeHandler
+    });
+    const _a = fieldProps, { class: className } = _a, restProps = __objRest(_a, ["class"]);
+    return /* @__PURE__ */ jsx(ComponentToRender, __spreadProps(__spreadValues({}, restProps), { className: className || fieldProps.className }));
+  };
+  const renderFormFieldWithWrapper = (field) => {
+    const columnWidth = getColumnWidth(field.columnwidth);
+    return /* @__PURE__ */ jsx(
+      WmGridColumn,
+      {
+        name: `${field.name}Column`,
+        columnwidth: columnWidth,
+        listener,
+        children: /* @__PURE__ */ jsx(
+          WmFormField,
+          __spreadProps(__spreadValues({}, field), {
+            name: field.name,
+            formName: formContext == null ? void 0 : formContext.name,
+            formKey: field.name,
+            fieldName: field.name,
+            field: "true",
+            listener,
+            className: clsx(
+              DEFAULT_FIELD_CLASS,
+              field.className,
+              field.class,
+              " app-textbox",
+              formRef == null ? void 0 : formRef.itemsPerRow
+            ),
+            formRef,
+            required: field.required === true || String(field.required) === "true",
+            renderFormFields: ($formField) => /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx(
+                WmLabel,
+                {
+                  name: `${$formField.name}_formLabel`,
+                  caption: $formField.displayname,
+                  required: $formField.required,
+                  listener,
+                  hidden: !$formField.displayname,
+                  className: clsx(
+                    "app-label control-label formfield-label",
+                    (formRef == null ? void 0 : formRef.captionCls) || ""
+                  ),
+                  htmlFor: $formField.name
+                }
+              ),
+              renderFormField(__spreadProps(__spreadValues(__spreadValues({}, field), $formField), {
+                datavalue: $formField.datavalue || $formField.defaultvalue,
+                name: $formField.name + "_formWidget",
+                className: clsx(field.className, field.class, (formRef == null ? void 0 : formRef.widgetCls) || "")
+              }))
+            ] })
+          })
+        )
+      },
+      field.name
+    );
+  };
+  const groupFieldsIntoRows = (fields) => {
+    const columns = layout === "custom" ? noOfColumns : parseInt(layout.split("-")[0]);
+    const rows = [];
+    for (let i = 0; i < fields.length; i += columns) {
+      rows.push(fields.slice(i, i + columns));
+    }
+    return rows;
+  };
+  const renderFieldsInGrid = () => {
+    if (layout === "1-column") {
+      return metadataRef.current.map((field) => /* @__PURE__ */ jsx(WmGridRow, { name: `${field.name}Row`, listener, children: renderFormFieldWithWrapper(field) }, field.name));
+    }
+    const fieldRows = groupFieldsIntoRows(metadataRef.current);
+    return fieldRows.map((row, rowIndex) => /* @__PURE__ */ jsx(WmGridRow, { name: `dynamicFormRow${rowIndex}`, listener, children: row.map((field) => renderFormFieldWithWrapper(field)) }, `row-${rowIndex}`));
+  };
+  return /* @__PURE__ */ jsx(WmLayoutGrid, { name, listener, className: "dynamic-form-grid", children: renderFieldsInGrid() });
+}
+export {
+  DynamicForm as default
+};

package/components/data/form/dynamic-fields/props.d.ts

@@ -0,0 +1,70 @@
+export type WidgetType = "text" | "textarea" | "number" | "currency" | "select" | "slider" | "rating" | "checkbox" | "checkboxset" | "radioset" | "switch" | "date" | "datetime" | "time" | "chips" | "colorpicker" | "fileupload" | "calendar";
+export type CaptionPosition = "left" | "top" | "floating" | "right";
+export type FormLayout = "1-column" | "2-column" | "3-column" | "custom";
+export interface FormFieldMetadata {
+    name: string;
+    widget: WidgetType;
+    displayname?: string;
+    label?: string;
+    placeholder?: string;
+    required?: boolean | string;
+    disabled?: boolean;
+    readonly?: boolean;
+    datavalue?: any;
+    defaultvalue?: any;
+    maxchars?: number;
+    minvalue?: number;
+    maxvalue?: number;
+    step?: number;
+    dataset?: any[];
+    datafield?: string;
+    displayfield?: string;
+    displayExpression?: string;
+    multiple?: boolean;
+    columnwidth?: number;
+    regexp?: string;
+    regexpmessage?: string;
+    className?: string;
+    styles?: React.CSSProperties;
+    onChange?: (value: any) => void;
+    onBlur?: () => void;
+    onFocus?: () => void;
+    [key: string]: any;
+    class?: string;
+}
+export interface DynamicFormProps {
+    metadata: FormFieldMetadata[];
+    listener?: any;
+    captionposition?: CaptionPosition;
+    layout?: FormLayout;
+    noOfColumns?: number;
+    isHorizontal?: boolean;
+    className?: string;
+    name?: string;
+    formRef?: any;
+    onBeforeRender?: (metadata: FormFieldMetadata[], widget: DynamicFormProps) => FormFieldMetadata[];
+    onFieldChange?: (fieldName: string, value: any) => void;
+    onFormChange?: (formData: Record<string, any>) => void;
+    onValidation?: (errors: Record<string, string>) => void;
+}
+export interface APIFieldResponse {
+    name: string;
+    type: string;
+    label?: string;
+    placeholder?: string;
+    required?: boolean;
+    validation?: {
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string;
+        min?: number;
+        max?: number;
+    };
+    options?: Array<{
+        value: any;
+        label: string;
+        [key: string]: any;
+    }>;
+    [key: string]: any;
+}
+export type APIResponseTransformer = (apiResponse: APIFieldResponse[]) => FormFieldMetadata[];

package/components/data/form/dynamic-fields/utils.d.ts

@@ -0,0 +1,46 @@
+import { FormFieldMetadata, APIFieldResponse, WidgetType } from "./props";
+/**
+ * Transform API response fields to FormFieldMetadata
+ */
+export declare const transformAPIResponse: (apiFields: APIFieldResponse[]) => FormFieldMetadata[];
+/**
+ * Transform a single API field to FormFieldMetadata
+ */
+export declare const transformSingleField: (apiField: APIFieldResponse) => FormFieldMetadata;
+/**
+ * Validate a form field value
+ */
+export declare const validateField: (field: FormFieldMetadata, value: any) => string | null;
+/**
+ * Validate all fields in a form
+ */
+export declare const validateForm: (fields: FormFieldMetadata[], formData: Record<string, any>) => Record<string, string>;
+/**
+ * Get form data values from fields
+ */
+export declare const getFormData: (fields: FormFieldMetadata[]) => Record<string, any>;
+/**
+ * Update a field's value in the fields array
+ */
+export declare const updateFieldValue: (fields: FormFieldMetadata[], fieldName: string, value: any) => FormFieldMetadata[];
+/**
+ * Get field by name
+ */
+export declare const getFieldByName: (fields: FormFieldMetadata[], fieldName: string) => FormFieldMetadata | undefined;
+/**
+ * Check if form has any validation errors
+ */
+export declare const hasFormErrors: (fields: FormFieldMetadata[], formData: Record<string, any>) => boolean;
+/**
+ * Create default field metadata
+ */
+export declare const createDefaultField: (name: string, widget?: WidgetType) => FormFieldMetadata;
+/**
+ * Sort fields by a given property
+ */
+export declare const sortFields: (fields: FormFieldMetadata[], sortBy?: keyof FormFieldMetadata) => FormFieldMetadata[];
+/**
+ * Filter fields by widget type
+ */
+export declare const filterFieldsByWidget: (fields: FormFieldMetadata[], widgetTypes: WidgetType[]) => FormFieldMetadata[];
+export declare function updateMetadata(metadata: FormFieldMetadata[], listener: any): FormFieldMetadata[];