@wavemaker-ai/react-runtime 1.0.0-rc.309

package/components/data/form/form-context.d.ts

@@ -0,0 +1,91 @@
+import React from "react";
+export interface FormContextValue {
+    updateFormData?: (data: any) => void;
+    control?: any;
+    watch?: any;
+    registerFormField?: (formKey: string, fieldName: string, fieldInstance: any) => void;
+    registerFormWidget?: (widgetName: string, widgetInstance: any) => void;
+    registerHeaderAction?: (actionName: string, action: any) => void;
+    onChangeHandler?: (fieldName: string, value: any) => void;
+    getFieldValue?: (fieldName: string) => any;
+    trigger?: any;
+    errors?: any;
+    name?: string;
+    captionposition?: string;
+    captionCls?: string;
+    widgetCls?: string;
+    validationtype?: string;
+    isViewMode?: boolean;
+    resetField?: (fieldName: string) => void;
+    submitCount?: number;
+    ref?: any;
+    itemsPerRow?: string;
+    submit?: (e?: any) => Promise<boolean | undefined>;
+    formreset?: () => Promise<void>;
+}
+declare const FormContext: React.Context<FormContextValue>;
+/**
+ * ParentFormDataContext provides instance-specific form data to child forms.
+ *
+ * This solves the problem where multiple instances of the same form exist inside
+ * a list (e.g., DeptEmpContactForm2 at index 0, 1, 2). The shared Widgets proxy
+ * (Widgets["DeptEmpContactForm2"].formdata) is contaminated across instances.
+ *
+ * With this context, each form instance provides its own formdata, and child forms
+ * consume from the nearest parent provider - naturally scoping to the correct instance.
+ *
+ * Additionally, this context provides the ROOT parent form name and current data path
+ * so that deeply nested forms can emit data updates directly to the root form using
+ * the full data path (e.g., "employeeDetailses[0].emergencyContact").
+ */
+/** Data for registering a child form field in the parent's widget context */
+export interface ChildFieldRegistration {
+    childFormName: string;
+    widget: any;
+    formKey: string;
+    fieldName: string;
+}
+/**
+ * Origin of the last data update - used to prevent circular sync.
+ * - 'external': Data came from props, widget assignment, or API
+ * - 'child': Data came from a child form's onChildDataChange
+ */
+export type UpdateOrigin = "external" | "child";
+export interface ParentFormDataContextValue {
+    /** Current form data of this form instance */
+    formdata: any;
+    /** The form's name */
+    formName: string;
+    /** Whether the form is currently valid (all validations pass) */
+    isValid?: boolean;
+    /** The ROOT parent form name - all nested forms emit to this form */
+    rootParentForm?: string;
+    /** The current data path prefix for nested forms to build their full path */
+    parentDataPath?: string;
+    /**
+     * Origin of the last data update - used to prevent circular sync.
+     * Child forms skip sync when origin is 'child' (data already in their RHF).
+     */
+    lastUpdateOrigin?: UpdateOrigin;
+    /**
+     * Callback for child forms to send data UP to root parent.
+     * Called when child form data changes - root form uses setValue to update nested path.
+     */
+    onChildDataChange?: (fullDataPath: string, formData: any) => void;
+    /**
+     * Callback for child/prefab forms to register fields in parent's widget context.
+     * Used for cross-context field registration (e.g., prefab forms).
+     */
+    registerChildField?: (data: ChildFieldRegistration) => void;
+}
+export declare const ParentFormDataContext: React.Context<ParentFormDataContextValue>;
+export declare const useParentFormData: () => ParentFormDataContextValue;
+export declare const FormProvider: React.FC<{
+    value: FormContextValue;
+    isViewMode: boolean;
+    children: React.ReactNode;
+}>;
+export declare const useFormContext: () => FormContextValue;
+export declare const useIsViewMode: () => boolean;
+export declare const useFormRef: () => any;
+export default FormContext;

package/components/data/form/form-context.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useParentFormData = exports.useIsViewMode = exports.useFormRef = exports.useFormContext = exports["default"] = exports.ParentFormDataContext = exports.FormProvider = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireWildcard(require("react"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var __jsx = _react["default"].createElement;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var FormContext = /*#__PURE__*/(0, _react.createContext)(null);
+
+/**
+ * ParentFormDataContext provides instance-specific form data to child forms.
+ *
+ * This solves the problem where multiple instances of the same form exist inside
+ * a list (e.g., DeptEmpContactForm2 at index 0, 1, 2). The shared Widgets proxy
+ * (Widgets["DeptEmpContactForm2"].formdata) is contaminated across instances.
+ *
+ * With this context, each form instance provides its own formdata, and child forms
+ * consume from the nearest parent provider - naturally scoping to the correct instance.
+ *
+ * Additionally, this context provides the ROOT parent form name and current data path
+ * so that deeply nested forms can emit data updates directly to the root form using
+ * the full data path (e.g., "employeeDetailses[0].emergencyContact").
+ */
+/** Data for registering a child form field in the parent's widget context */
+
+/**
+ * Origin of the last data update - used to prevent circular sync.
+ * - 'external': Data came from props, widget assignment, or API
+ * - 'child': Data came from a child form's onChildDataChange
+ */
+
+var ParentFormDataContext = exports.ParentFormDataContext = /*#__PURE__*/(0, _react.createContext)(null);
+var useParentFormData = exports.useParentFormData = function useParentFormData() {
+  return (0, _react.useContext)(ParentFormDataContext);
+};
+var FormProvider = exports.FormProvider = function FormProvider(_ref) {
+  var value = _ref.value,
+    isViewMode = _ref.isViewMode,
+    children = _ref.children;
+  return __jsx(FormContext.Provider, {
+    value: _objectSpread(_objectSpread({}, value), {}, {
+      isViewMode: isViewMode
+    })
+  }, children);
+};
+var useFormContext = exports.useFormContext = function useFormContext() {
+  var context = (0, _react.useContext)(FormContext);
+  return context;
+};
+var useIsViewMode = exports.useIsViewMode = function useIsViewMode() {
+  var context = useFormContext();
+  return context === null || context === void 0 ? void 0 : context.isViewMode;
+};
+var useFormRef = exports.useFormRef = function useFormRef() {
+  var _useContext$ref, _useContext;
+  return (_useContext$ref = (_useContext = (0, _react.useContext)(FormContext)) === null || _useContext === void 0 ? void 0 : _useContext.ref) !== null && _useContext$ref !== void 0 ? _useContext$ref : null;
+};
+var _default = exports["default"] = FormContext;

package/components/data/form/form-controller/hooks/index.d.ts

@@ -0,0 +1,7 @@
+import { ValidationTypes, ValidatorConfig } from "../props";
+declare const useFormRegistration: (name: string, fieldProxy: any, contextFormRef: any) => void;
+declare const useExternalDataSync: (datavalue: any, fieldRef: React.RefObject<any>) => void;
+declare const useDefaultValueSync: (defaultvalue: any, datavalue: any, fieldRef: React.RefObject<any>) => void;
+declare const useValidationRules: (validationType: ValidationTypes, validators?: ValidatorConfig[], asyncValidators?: ValidatorConfig[], required?: boolean, maxchars?: number, regexp?: string | RegExp, validationmessage?: string, minvalue?: number | string, maxvalue?: number | string, form?: any, customValidationMsg?: string | null) => import("react-hook-form").RegisterOptions;
+declare const useHTMLValidationProps: (validationType: ValidationTypes, required?: boolean, maxchars?: number, regexp?: string | RegExp) => any;
+export { useFormRegistration, useExternalDataSync, useDefaultValueSync, useValidationRules, useHTMLValidationProps, };

package/components/data/form/form-controller/hooks/index.js

@@ -0,0 +1,132 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useValidationRules = exports.useHTMLValidationProps = exports.useFormRegistration = exports.useExternalDataSync = exports.useDefaultValueSync = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _react = require("react");
+var _validationContrustor = require("../validation-contrustor");
+// Custom hooks for better separation of concerns
+var useFormRegistration = exports.useFormRegistration = function useFormRegistration(name, fieldProxy, contextFormRef) {
+  var hasRegisteredRef = (0, _react.useRef)(false);
+  (0, _react.useEffect)(function () {
+    if (contextFormRef !== null && contextFormRef !== void 0 && contextFormRef.registerFormWidget && fieldProxy && !hasRegisteredRef.current) {
+      contextFormRef.registerFormWidget(name, fieldProxy);
+      hasRegisteredRef.current = true;
+    }
+  }, [fieldProxy, name, contextFormRef]);
+};
+var useExternalDataSync = exports.useExternalDataSync = function useExternalDataSync(datavalue, fieldRef) {
+  (0, _react.useEffect)(function () {
+    if (fieldRef.current && datavalue !== undefined) {
+      var currentValue = fieldRef.current.value;
+      if (currentValue !== datavalue) {
+        fieldRef.current.onChange(datavalue);
+      }
+    }
+  }, [datavalue]);
+};
+var useDefaultValueSync = exports.useDefaultValueSync = function useDefaultValueSync(defaultvalue, datavalue, fieldRef) {
+  var hasInitializedRef = (0, _react.useRef)(false);
+  var prevDefaultValueRef = (0, _react.useRef)(defaultvalue);
+  (0, _react.useEffect)(function () {
+    if (!fieldRef.current) return;
+
+    // Initial sync: only when datavalue is undefined and we haven't initialized yet
+    if (!hasInitializedRef.current && defaultvalue !== undefined && datavalue === undefined) {
+      var currentValue = fieldRef.current.value;
+      if (currentValue === undefined || currentValue === null || currentValue === "") {
+        fieldRef.current.onChange(defaultvalue);
+        hasInitializedRef.current = true;
+      }
+      prevDefaultValueRef.current = defaultvalue;
+      return;
+    }
+
+    // Dynamic defaultvalue sync: when defaultvalue prop changes (e.g. conditional default from toggle)
+    // React Hook Form's Controller uses defaultValue only at registration; we must sync on prop change
+    if (prevDefaultValueRef.current !== defaultvalue) {
+      var _currentValue = fieldRef.current.value;
+      // Only update if current value matches previous default - user hasn't typed something different
+      var valueWasFromDefault = _currentValue === prevDefaultValueRef.current || prevDefaultValueRef.current === "" && (_currentValue === undefined || _currentValue === null || _currentValue === "");
+      if (valueWasFromDefault) {
+        fieldRef.current.onChange(defaultvalue);
+      }
+      prevDefaultValueRef.current = defaultvalue;
+    }
+  }, [defaultvalue, datavalue]);
+};
+var useValidationRules = exports.useValidationRules = function useValidationRules(validationType, validators, asyncValidators, required, maxchars, regexp, validationmessage, minvalue, maxvalue, form, customValidationMsg) {
+  if (validationType === "none") {
+    return {};
+  }
+  var combinedValidators = [].concat((0, _toConsumableArray2["default"])(validators || []), (0, _toConsumableArray2["default"])(asyncValidators || []));
+  var hasValidatorType = function hasValidatorType(type) {
+    return validators === null || validators === void 0 ? void 0 : validators.some(function (v) {
+      return typeof v !== "function" && v.type === type;
+    });
+  };
+  if (required && !hasValidatorType("required")) {
+    combinedValidators.push({
+      type: "required",
+      validator: true,
+      errorMessage: validationmessage || "This field is required"
+    });
+  }
+  if (maxchars !== undefined) {
+    combinedValidators.push({
+      type: "maxchars",
+      validator: maxchars,
+      errorMessage: validationmessage || "Maximum length is ".concat(maxchars, " characters.")
+    });
+  }
+  var normalizedMin = minvalue !== undefined && minvalue !== null && minvalue !== "" ? Number(minvalue) : undefined;
+  var normalizedMax = maxvalue !== undefined && maxvalue !== null && maxvalue !== "" ? Number(maxvalue) : undefined;
+  if (normalizedMin !== undefined && !Number.isNaN(normalizedMin)) {
+    combinedValidators.push({
+      type: "minvalue",
+      validator: normalizedMin,
+      errorMessage: validationmessage || "Value must be greater than or equal to ".concat(normalizedMin, ".")
+    });
+  }
+  if (normalizedMax !== undefined && !Number.isNaN(normalizedMax)) {
+    combinedValidators.push({
+      type: "maxvalue",
+      validator: normalizedMax,
+      errorMessage: validationmessage || "Value must be less than or equal to ".concat(normalizedMax, ".")
+    });
+  }
+  if (regexp) {
+    combinedValidators.push({
+      type: "regexp",
+      validator: regexp,
+      errorMessage: validationmessage || "Invalid format."
+    });
+  }
+  if (customValidationMsg) {
+    combinedValidators.push(function () {
+      return customValidationMsg;
+    });
+  }
+  return (0, _validationContrustor.createValidationRules)(combinedValidators, form);
+};
+var useHTMLValidationProps = exports.useHTMLValidationProps = function useHTMLValidationProps(validationType, required, maxchars, regexp) {
+  return (0, _react.useMemo)(function () {
+    if (validationType !== "html") {
+      return {};
+    }
+    var htmlProps = {};
+    if (required) {
+      htmlProps.required = true;
+    }
+    if (maxchars) {
+      htmlProps.maxLength = maxchars;
+    }
+    if (regexp) {
+      htmlProps.pattern = typeof regexp === "string" ? regexp : regexp.source;
+    }
+    return htmlProps;
+  }, [validationType, required, maxchars, regexp]);
+};

package/components/data/form/form-controller/props.d.ts

@@ -0,0 +1,139 @@
+export declare const VALIDATOR: {
+    readonly REQUIRED: "required";
+    readonly MAXCHARS: "maxchars";
+    readonly MINVALUE: "minvalue";
+    readonly MAXVALUE: "maxvalue";
+    readonly REGEXP: "regexp";
+    readonly MINDATE: "mindate";
+    readonly MAXDATE: "maxdate";
+    readonly MINTIME: "mintime";
+    readonly MAXTIME: "maxtime";
+    readonly EXCLUDEDATES: "excludedates";
+    readonly EXCLUDEDAYS: "excludedays";
+};
+export interface ValidationProps {
+    required?: boolean;
+    maxchars?: number;
+    regexp?: string | RegExp;
+    minvalue?: number | string;
+    maxvalue?: number | string;
+    excludedays?: number[] | string;
+    excludedates?: (string | Date)[];
+    mintime?: string;
+    maxtime?: string;
+    mindate?: string | Date;
+    maxdate?: string | Date;
+}
+type ValidatorType = (typeof VALIDATOR)[keyof typeof VALIDATOR] | string;
+export type ErrorMessageFunction = (field: {
+    value: any;
+}, form: any) => string | Promise<string>;
+export interface BaseValidator {
+    type: ValidatorType;
+    errorMessage: string | ErrorMessageFunction;
+}
+export interface RequiredValidator extends BaseValidator {
+    type: typeof VALIDATOR.REQUIRED | "required";
+    validator: Function | boolean;
+}
+export interface MaxCharsValidator extends BaseValidator {
+    type: typeof VALIDATOR.MAXCHARS | "maxchars";
+    validator: number;
+}
+export interface MinValueValidator extends BaseValidator {
+    type: typeof VALIDATOR.MINVALUE | "minvalue";
+    validator: number;
+}
+export interface MaxValueValidator extends BaseValidator {
+    type: typeof VALIDATOR.MAXVALUE | "maxvalue";
+    validator: number;
+}
+export interface RegexpValidator extends BaseValidator {
+    type: typeof VALIDATOR.REGEXP | "regexp";
+    validator: RegExp | string;
+}
+export interface MinDateValidator extends BaseValidator {
+    type: typeof VALIDATOR.MINDATE | "mindate";
+    validator: string | Date;
+}
+export interface MaxDateValidator extends BaseValidator {
+    type: typeof VALIDATOR.MAXDATE | "maxdate";
+    validator: string | Date;
+}
+export interface MinTimeValidator extends BaseValidator {
+    type: typeof VALIDATOR.MINTIME | "mintime";
+    validator: string;
+}
+export interface MaxTimeValidator extends BaseValidator {
+    type: typeof VALIDATOR.MAXTIME | "maxtime";
+    validator: string;
+}
+export interface ExcludeDatesValidator extends BaseValidator {
+    type: typeof VALIDATOR.EXCLUDEDATES | "excludedates";
+    validator: (string | Date)[];
+}
+export interface ExcludeDaysValidator extends BaseValidator {
+    type: typeof VALIDATOR.EXCLUDEDAYS | "excludedays";
+    validator: number[];
+}
+export interface FunctionValidator {
+    (params: {
+        value: any;
+        fieldName?: string;
+    }, form: any): string | undefined | null | boolean | {
+        errorMessage: string;
+    } | Promise<string | undefined | null | boolean | {
+        errorMessage: string;
+    }>;
+}
+export type ValidatorConfig = RequiredValidator | MaxCharsValidator | MinValueValidator | MaxValueValidator | RegexpValidator | MinDateValidator | MaxDateValidator | MinTimeValidator | MaxTimeValidator | ExcludeDatesValidator | ExcludeDaysValidator | FunctionValidator;
+export type ValidationTypes = "default" | "html" | "none";
+export interface ErrorState {
+    error: boolean;
+    errorMessage?: string;
+    fieldState?: any;
+}
+export interface ControlledFieldProps {
+    validationType?: "default" | "html" | "none";
+    formRef?: any;
+    formKey?: string;
+    name: string;
+    validators?: ValidatorConfig[];
+    asyncValidators?: ValidatorConfig[];
+    required?: boolean;
+    maxchars?: number;
+    regexp?: string | RegExp;
+    validationmessage?: string;
+    hint?: string;
+    defaultvalue?: any;
+    value?: any;
+    datavalue?: any;
+    type?: string;
+    enhancedProps?: any;
+    observe?: any[];
+    onChange?: (e: any, widget?: any, newValue?: any, oldValue?: any) => void;
+    onBlur?: (e: any) => void;
+    onChangeHandler?: (key: string, field: any) => void;
+    renderFormFields?: (props: any) => React.ReactNode;
+}
+export interface WithFormControllerProps {
+    /** Set via the `withStandalone` HOC for widgets used outside normal form embedding. */
+    standalone?: boolean;
+    formRef?: any;
+    formKey?: string;
+    name: string;
+    datavalue?: any;
+    defaultvalue?: any;
+    validators?: ValidatorConfig[];
+    asyncValidators?: ValidatorConfig[];
+    required?: boolean;
+    maxchars?: number;
+    regexp?: string | RegExp;
+    validationmessage?: string;
+    hint?: string;
+    type?: string;
+    observe?: string[];
+    onBlur?: (e: any) => void;
+    [key: string]: any;
+}
+export {};

package/components/data/form/form-controller/props.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VALIDATOR = void 0;
+var VALIDATOR = exports.VALIDATOR = {
+  REQUIRED: "required",
+  MAXCHARS: "maxchars",
+  MINVALUE: "minvalue",
+  MAXVALUE: "maxvalue",
+  REGEXP: "regexp",
+  MINDATE: "mindate",
+  MAXDATE: "maxdate",
+  MINTIME: "mintime",
+  MAXTIME: "maxtime",
+  EXCLUDEDATES: "excludedates",
+  EXCLUDEDAYS: "excludedays"
+};

package/components/data/form/form-controller/utils.d.ts

@@ -0,0 +1,5 @@
+import { ErrorState, ValidatorConfig, ValidationProps, ValidationTypes } from "./props";
+export declare function extractDynamicValidationProps(validators: ValidatorConfig[], rules: ValidationProps): ValidationProps;
+export declare const processFieldValue: (fieldValue: any, type?: string, datafield?: string) => any;
+export declare const getErrorState: (fieldState: any, validationType: ValidationTypes, touched: boolean) => ErrorState;
+export declare const shouldShowErrorMessage: (validationType: ValidationTypes, fieldState: any, touched: boolean) => boolean;

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

@@ -0,0 +1,135 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractDynamicValidationProps = extractDynamicValidationProps;
+exports.shouldShowErrorMessage = exports.processFieldValue = exports.getErrorState = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function resolveValue(value) {
+  if (value === null || value === undefined) return undefined;
+  if (typeof value === "function") {
+    try {
+      var resolved = value();
+      return resolved === null ? undefined : resolved;
+    } catch (error) {
+      console.warn("Error resolving function value:", error);
+      return undefined;
+    }
+  }
+  return value === null ? undefined : value;
+}
+function extractDynamicValidationProps(validators, rules) {
+  var result = {
+    required: rules.required,
+    maxchars: rules.maxchars,
+    regexp: rules.regexp,
+    minvalue: rules.minvalue,
+    maxvalue: rules.maxvalue,
+    excludedays: rules.excludedays,
+    excludedates: rules.excludedates,
+    mintime: rules.mintime,
+    maxtime: rules.maxtime,
+    mindate: rules.mindate,
+    maxdate: rules.maxdate
+  };
+  if (!(validators !== null && validators !== void 0 && validators.length)) return result;
+  validators.forEach(function (validator) {
+    if (typeof validator === "function") return;
+    switch (validator.type) {
+      case "required":
+        result.required = resolveValue(validator.validator);
+        break;
+      case "maxchars":
+        result.maxchars = resolveValue(validator.validator);
+        break;
+      case "regexp":
+        result.regexp = resolveValue(validator.validator);
+        break;
+      case "minvalue":
+        result.minvalue = resolveValue(validator.validator);
+        break;
+      case "maxvalue":
+        result.maxvalue = resolveValue(validator.validator);
+        break;
+      case "excludedays":
+        result.excludedays = resolveValue(validator.validator);
+        break;
+      case "excludedates":
+        // Extract excludedates from validators
+        result.excludedates = resolveValue(validator.validator);
+        break;
+      case "mintime":
+        // Extract mintime from validators
+        result.mintime = resolveValue(validator.validator);
+        break;
+      case "maxtime":
+        // Extract maxtime from validators
+        result.maxtime = resolveValue(validator.validator);
+        break;
+      case "mindate":
+        // Extract mindate from validators
+        result.mindate = resolveValue(validator.validator);
+        break;
+      case "maxdate":
+        // Extract maxdate from validators
+        result.maxdate = resolveValue(validator.validator);
+        break;
+    }
+  });
+
+  // Convert excludedays from array to string format if it's an array (for widgets that expect string)
+  if (result.excludedays !== undefined && Array.isArray(result.excludedays)) {
+    result.excludedays = result.excludedays.join(",");
+  }
+  return result;
+}
+
+// Utility functions
+var processFieldValue = exports.processFieldValue = function processFieldValue(fieldValue, type, datafield) {
+  // If fieldValue is an object and datafield is specified, extract the value
+  if (fieldValue && (0, _typeof2["default"])(fieldValue) === "object" && !Array.isArray(fieldValue) && datafield) {
+    fieldValue = datafield === "All Fields" ? fieldValue : fieldValue[datafield];
+  }
+  if (type === "number") {
+    return fieldValue === "" || fieldValue === null || fieldValue === undefined ? "" : fieldValue;
+  }
+  return fieldValue;
+};
+var getErrorState = exports.getErrorState = function getErrorState(fieldState, validationType, touched) {
+  switch (validationType) {
+    case "default":
+      return {
+        error: touched && !!fieldState.error,
+        errorMessage: touched && fieldState.error ? fieldState.error.message : undefined,
+        fieldState: fieldState
+      };
+    case "html":
+      return {
+        error: touched && !!fieldState.error,
+        errorMessage: touched && fieldState.error ? fieldState.error.message : undefined,
+        fieldState: fieldState
+      };
+    case "none":
+      return {
+        error: false,
+        errorMessage: undefined,
+        fieldState: _objectSpread(_objectSpread({}, fieldState), {}, {
+          error: undefined
+        })
+      };
+    default:
+      return {
+        error: false,
+        errorMessage: undefined,
+        fieldState: undefined
+      };
+  }
+};
+var shouldShowErrorMessage = exports.shouldShowErrorMessage = function shouldShowErrorMessage(validationType, fieldState, touched) {
+  return validationType !== "none" && (validationType === "default" && fieldState.error || validationType === "html" && fieldState.error);
+};

package/components/data/form/form-controller/validation-contrustor.d.ts

@@ -0,0 +1,3 @@
+import { RegisterOptions } from "react-hook-form";
+import { ValidatorConfig } from "./props";
+export declare const createValidationRules: (validators: ValidatorConfig[], form?: any, fieldName?: string) => RegisterOptions;