@gnwebsoft/ui 3.0.8 → 4.0.0

package/dist/chunk-AEOF2TUF.cjs

@@ -0,0 +1,2273 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkHEHPKM4Bcjs = require('./chunk-HEHPKM4B.cjs');
+
+// src/wrappers/AsyncMultiSelect2/AsyncMultiSelect2.tsx
+
+
+
+
+
+
+var _material = require('@mui/material');
+var _lodash = require('lodash');
+var _react = require('react'); var React7 = _interopRequireWildcard(_react);
+var _reacthookform = require('react-hook-form');
+var _jsxruntime = require('react/jsx-runtime');
+var initialState = {
+  options: [],
+  selectedOptions: [],
+  inputValue: "",
+  loading: false,
+  initialLoaded: false
+};
+function componentReducer(state, action) {
+  switch (action.type) {
+    case "SET_OPTIONS":
+      return { ...state, options: action.payload, loading: false };
+    case "SET_SELECTED_OPTIONS":
+      return { ...state, selectedOptions: action.payload };
+    case "SET_INPUT_VALUE":
+      return { ...state, inputValue: action.payload };
+    case "SET_LOADING":
+      return { ...state, loading: action.payload };
+    case "SET_INITIAL_LOADED":
+      return { ...state, initialLoaded: action.payload };
+    case "RESET_OPTIONS":
+      return { ...state, options: state.selectedOptions };
+    default:
+      return state;
+  }
+}
+var AsyncMultiSelect2Component = ({
+  name,
+  control,
+  placeholder,
+  initialValues,
+  label,
+  queryFn,
+  variant = "outlined",
+  sx,
+  disabled = false,
+  debounceMs = 400,
+  loadingText = "Loading...",
+  noOptionsText = "No options",
+  renderInput,
+  ...rest
+}) => {
+  const [state, dispatch] = _react.useReducer.call(void 0, componentReducer, initialState);
+  const theme = _material.useTheme.call(void 0, );
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control
+  });
+  const debouncedFetch = _react.useMemo.call(void 0, 
+    () => _lodash.debounce.call(void 0, async (payload) => {
+      try {
+        const results = await queryFn(payload);
+        const mergedOptions = [
+          ...state.selectedOptions,
+          ...results.filter(
+            (option) => !state.selectedOptions.some((selected) => selected.value === option.value)
+          )
+        ];
+        dispatch({ type: "SET_OPTIONS", payload: mergedOptions });
+      } catch (_error) {
+        dispatch({ type: "SET_LOADING", payload: false });
+      }
+    }, debounceMs),
+    [queryFn, state.selectedOptions, debounceMs]
+  );
+  _react.useEffect.call(void 0, () => {
+    if (!_optionalChain([initialValues, 'optionalAccess', _2 => _2.length]) || state.initialLoaded) return;
+    dispatch({ type: "SET_LOADING", payload: true });
+    const payload = {
+      query: null,
+      initialValues
+    };
+    queryFn(payload).then((results) => {
+      if (results) {
+        dispatch({ type: "SET_SELECTED_OPTIONS", payload: results });
+        dispatch({ type: "SET_OPTIONS", payload: results });
+        dispatch({ type: "SET_INITIAL_LOADED", payload: true });
+        field.onChange(results.map((option) => option.value));
+      }
+      dispatch({ type: "SET_LOADING", payload: false });
+    }).catch((_error) => {
+      dispatch({ type: "SET_LOADING", payload: false });
+    });
+  }, [initialValues, state.initialLoaded, queryFn, field]);
+  _react.useEffect.call(void 0, () => {
+    if (!state.initialLoaded) return;
+    if (state.inputValue === "") {
+      dispatch({ type: "RESET_OPTIONS" });
+      return;
+    }
+    dispatch({ type: "SET_LOADING", payload: true });
+    const payload = {
+      query: state.inputValue,
+      initialValues: null
+    };
+    debouncedFetch(payload);
+  }, [state.inputValue, state.initialLoaded, debouncedFetch]);
+  const handleChange = _react.useCallback.call(void 0, 
+    (event, newValue) => {
+      dispatch({ type: "SET_SELECTED_OPTIONS", payload: newValue });
+      field.onChange(newValue.map((option) => option.value));
+    },
+    [field]
+  );
+  const handleInputChange = _react.useCallback.call(void 0, 
+    (event, newInputValue) => {
+      dispatch({ type: "SET_INPUT_VALUE", payload: newInputValue });
+    },
+    []
+  );
+  const isOptionEqualToValue = _react.useCallback.call(void 0, 
+    (option, value) => option.value === value.value,
+    []
+  );
+  const getOptionLabel = _react.useCallback.call(void 0, (option) => option.label, []);
+  const defaultRenderInput = _react.useCallback.call(void 0, 
+    (params) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.TextField,
+      {
+        ...params,
+        label,
+        placeholder,
+        variant,
+        error: !!error,
+        helperText: _optionalChain([error, 'optionalAccess', _3 => _3.message]),
+        slotProps: {
+          input: {
+            ...params.InputProps,
+            endAdornment: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+              state.loading && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.CircularProgress, { color: "inherit", size: 20 }),
+              params.InputProps.endAdornment
+            ] })
+          }
+        },
+        sx: {
+          "& .MuiInputBase-input": {
+            cursor: disabled ? "not-allowed" : "default"
+          },
+          bgcolor: disabled ? theme.palette.action.disabledBackground : "transparent",
+          ...sx
+        }
+      }
+    ),
+    [label, placeholder, variant, error, state.loading, disabled, theme.palette.action.disabledBackground, sx]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.Autocomplete,
+    {
+      multiple: true,
+      options: state.options,
+      value: state.selectedOptions,
+      loading: state.loading,
+      disabled,
+      isOptionEqualToValue,
+      getOptionLabel,
+      filterSelectedOptions: true,
+      onChange: handleChange,
+      onInputChange: handleInputChange,
+      loadingText,
+      noOptionsText,
+      renderInput: renderInput || defaultRenderInput,
+      ...rest
+    }
+  );
+};
+var AsyncMultiSelect2 = ({
+  gridProps,
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Grid, { ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AsyncMultiSelect2Component, { ...props }) });
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, AsyncMultiSelect2Component, { ...props });
+};
+AsyncMultiSelect2.displayName = "AsyncMultiSelect2";
+
+// src/wrappers/CheckboxElement/CheckboxElement.tsx
+
+
+
+
+
+
+
+
+
+
+
+
+
+var Component = function CheckboxElement(props) {
+  const {
+    name,
+    control,
+    label,
+    labelProps,
+    helperText,
+    parseError,
+    transform,
+    disabled,
+    sx,
+    onChange: customOnChange,
+    ...rest
+  } = props;
+  const theme = _material.useTheme.call(void 0, );
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control,
+    disabled
+  });
+  const { value, onChange } = _chunkHEHPKM4Bcjs.useTransform.call(void 0, {
+    value: field.value,
+    onChange: field.onChange,
+    transform: {
+      input: typeof _optionalChain([transform, 'optionalAccess', _4 => _4.input]) === "function" ? transform.input : (value2) => !!value2,
+      output: typeof _optionalChain([transform, 'optionalAccess', _5 => _5.output]) === "function" ? (eventOrValue, _value) => {
+        const event = eventOrValue;
+        const checked = _value;
+        return transform.output(event, checked);
+      } : (eventOrValue, _value) => {
+        const checked = _value;
+        return checked;
+      }
+    }
+  });
+  const handleChange = (event, checked) => {
+    onChange(event, checked);
+    if (typeof customOnChange === "function") {
+      customOnChange(event, checked);
+    }
+  };
+  const displayError = error ? typeof parseError === "function" ? parseError(error) : error.message : null;
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.FormControl, { error: !!error, disabled, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.FormGroup, { row: true, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.FormControlLabel,
+      {
+        label: label || "",
+        ...labelProps,
+        disabled,
+        control: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _material.Checkbox,
+          {
+            ...rest,
+            color: rest.color || "primary",
+            sx: [
+              ...Array.isArray(sx) ? sx : [sx],
+              {
+                color: error ? theme.palette.error.main : disabled ? theme.palette.action.disabled : void 0,
+                "&.Mui-disabled": {
+                  color: theme.palette.action.disabled
+                }
+              }
+            ],
+            checked: value,
+            disabled,
+            onChange: handleChange,
+            ref: field.ref
+          }
+        )
+      }
+    ) }),
+    (displayError || helperText) && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.FormHelperText, { error: !!error, children: displayError || helperText })
+  ] });
+};
+var CheckboxElement2 = ({
+  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.Grid,
+      {
+        ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps },
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component, { ...props })
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component, { ...props });
+};
+CheckboxElement2.displayName = "CheckboxElement";
+
+// src/wrappers/CheckboxGroup/CheckboxGroup.tsx
+
+
+
+
+
+
+
+
+
+
+
+
+
+var Component2 = function CheckboxGroup(props) {
+  const { name, control, label, labelProps, inputRef, options, ...rest } = props;
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control,
+    disabled: rest.disabled
+  });
+  const [selectedValues, setSelectedValues] = _react.useState.call(void 0, 
+    options.filter((c) => _optionalChain([field, 'access', _6 => _6.value, 'optionalAccess', _7 => _7.includes, 'call', _8 => _8(c.Value)])).map((c) => c.Value) || []
+  );
+  _react.useEffect.call(void 0, () => {
+    field.onChange(selectedValues ? [...selectedValues] : []);
+  }, [selectedValues]);
+  const handleChange = (event) => {
+    const value = parseInt(event.target.value, 10);
+    if (event.target.checked) {
+      setSelectedValues([...selectedValues, value]);
+    } else {
+      setSelectedValues(selectedValues.filter((item) => item !== value));
+    }
+  };
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.FormControl, { error: !!error, children: [
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.FormGroup, { row: true, children: options.map((option) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.FormControlLabel,
+      {
+        label: option.Label,
+        ...labelProps,
+        control: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _material.Checkbox,
+          {
+            ...rest,
+            color: rest.color || "primary",
+            sx: [
+              ...Array.isArray(rest.sx) ? rest.sx : [rest.sx],
+              {
+                color: error ? "error.main" : void 0
+              }
+            ],
+            value: option.Value,
+            checked: selectedValues.includes(option.Value),
+            onChange: handleChange
+          }
+        )
+      },
+      `${option.Value}`
+    )) }),
+    error && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.FormHelperText, { error: !!error, children: error.message })
+  ] });
+};
+var CheckboxGroup2 = ({
+  gridProps,
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Grid, { ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component2, { ...props }) });
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component2, { ...props });
+};
+CheckboxGroup2.displayName = "CheckboxGroup";
+
+// src/wrappers/DatePickerElement/DatePickerElement.tsx
+
+
+
+// src/wrappers/DatePickerElement/DatePickerElementCore.tsx
+
+var _xdatepickers = require('@mui/x-date-pickers');
+
+
+
+// src/wrappers/DatePickerElement/hooks/useDatePickerValue.ts
+var _internals = require('@mui/x-date-pickers/internals');
+
+function readDatePickerValueAsDate(adapter, value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "string") {
+    if (value === "") {
+      return null;
+    }
+    const parsedDate = adapter.utils.date(value);
+    return parsedDate;
+  }
+  return value;
+}
+function useDatePickerValue(options) {
+  const { field, transform } = options;
+  const adapter = _internals.useLocalizationContext.call(void 0, );
+  const value = _react.useMemo.call(void 0, () => {
+    if (typeof _optionalChain([transform, 'optionalAccess', _9 => _9.input]) === "function") {
+      return transform.input(field.value);
+    }
+    return readDatePickerValueAsDate(adapter, field.value);
+  }, [field.value, _optionalChain([transform, 'optionalAccess', _10 => _10.input]), adapter]);
+  const onChange = _react.useCallback.call(void 0, 
+    (newValue, context) => {
+      if (typeof _optionalChain([transform, 'optionalAccess', _11 => _11.output]) === "function") {
+        const transformedValue = transform.output(newValue, context);
+        field.onChange(transformedValue);
+      } else {
+        field.onChange(newValue);
+      }
+    },
+    [field.onChange, _optionalChain([transform, 'optionalAccess', _12 => _12.output])]
+  );
+  return {
+    value,
+    onChange
+  };
+}
+
+// src/wrappers/DatePickerElement/hooks/useDatePickerValidation.ts
+
+var DEFAULT_ERROR_MESSAGES = {
+  invalidDate: "Please enter a valid date",
+  minDate: "Date must be after the minimum allowed date",
+  maxDate: "Date must be before the maximum allowed date",
+  disabledDate: "This date is not allowed",
+  required: "This field is required"
+};
+function useDatePickerValidation(options) {
+  const { fieldState, validation, parseError, value } = options;
+  const validationResult = _react.useMemo.call(void 0, () => {
+    const { error: fieldError, invalid } = fieldState;
+    let currentError = fieldError;
+    if (!fieldError && value && validation) {
+      const { minDate, maxDate, shouldDisableDate, errorMessages } = validation;
+      if (minDate && value < minDate) {
+        currentError = {
+          type: "minDate",
+          message: _optionalChain([errorMessages, 'optionalAccess', _13 => _13.minDate]) || DEFAULT_ERROR_MESSAGES.minDate
+        };
+      } else if (maxDate && value > maxDate) {
+        currentError = {
+          type: "maxDate",
+          message: _optionalChain([errorMessages, 'optionalAccess', _14 => _14.maxDate]) || DEFAULT_ERROR_MESSAGES.maxDate
+        };
+      } else if (shouldDisableDate && shouldDisableDate(value)) {
+        currentError = {
+          type: "disabledDate",
+          message: _optionalChain([errorMessages, 'optionalAccess', _15 => _15.disabledDate]) || DEFAULT_ERROR_MESSAGES.disabledDate
+        };
+      }
+    }
+    const hasError = Boolean(currentError);
+    return {
+      hasError,
+      error: currentError,
+      invalid: invalid || hasError
+    };
+  }, [fieldState, validation, value]);
+  const errorMessage = _react.useMemo.call(void 0, () => {
+    if (!validationResult.error) {
+      return null;
+    }
+    if (parseError) {
+      return parseError(validationResult.error);
+    }
+    if (typeof validationResult.error === "string") {
+      return validationResult.error;
+    }
+    if ("message" in validationResult.error && validationResult.error.message) {
+      return validationResult.error.message;
+    }
+    if ("type" in validationResult.error) {
+      const errorType = validationResult.error.type;
+      switch (errorType) {
+        case "required":
+          return DEFAULT_ERROR_MESSAGES.required;
+        case "minDate":
+          return DEFAULT_ERROR_MESSAGES.minDate;
+        case "maxDate":
+          return DEFAULT_ERROR_MESSAGES.maxDate;
+        case "disabledDate":
+          return DEFAULT_ERROR_MESSAGES.disabledDate;
+        case "invalidDate":
+        default:
+          return DEFAULT_ERROR_MESSAGES.invalidDate;
+      }
+    }
+    return DEFAULT_ERROR_MESSAGES.invalidDate;
+  }, [validationResult.error, parseError]);
+  return {
+    ...validationResult,
+    errorMessage
+  };
+}
+
+// src/wrappers/DatePickerElement/hooks/useDatePickerStyles.ts
+
+
+function useDatePickerStyles(options = {}) {
+  const { disabled, hasError, loading, textReadOnly, sx: customSx } = options;
+  const theme = _material.useTheme.call(void 0, );
+  const computedSx = _react.useMemo.call(void 0, () => {
+    const baseStyles = {
+      // Input field styling
+      "& .MuiOutlinedInput-root": {
+        backgroundColor: disabled ? theme.palette.action.disabledBackground : "transparent",
+        // Transition for smooth state changes
+        transition: theme.transitions.create([
+          "background-color",
+          "border-color",
+          "color"
+        ], {
+          duration: theme.transitions.duration.short
+        }),
+        // Error state styling
+        ...hasError && {
+          borderColor: theme.palette.error.main,
+          "&:hover": {
+            borderColor: theme.palette.error.main
+          },
+          "&.Mui-focused": {
+            borderColor: theme.palette.error.main,
+            boxShadow: `0 0 0 2px ${theme.palette.error.main}25`
+            // 25 is 15% opacity in hex
+          }
+        },
+        // Loading state styling
+        ...loading && {
+          opacity: 0.7,
+          pointerEvents: "none"
+        }
+      },
+      // Input element styling
+      "& .MuiInputBase-input": {
+        cursor: disabled ? "not-allowed" : textReadOnly ? "pointer" : "text",
+        // Read-only specific styling
+        ...textReadOnly && !disabled && {
+          cursor: "pointer",
+          userSelect: "none",
+          caretColor: "transparent"
+          // Hide text cursor in read-only mode
+        },
+        // Loading state
+        ...loading && {
+          cursor: "wait"
+        }
+      },
+      // Required field asterisk styling
+      "& .MuiInputLabel-asterisk": {
+        color: theme.palette.error.main,
+        fontSize: "1.2em"
+      },
+      // Label styling with better contrast
+      "& .MuiInputLabel-root": {
+        color: hasError ? theme.palette.error.main : theme.palette.text.secondary,
+        // Ensure proper contrast for disabled state
+        ...disabled && {
+          color: theme.palette.text.disabled
+        }
+      },
+      // Helper text styling
+      "& .MuiFormHelperText-root": {
+        marginLeft: theme.spacing(1),
+        marginRight: theme.spacing(1),
+        // Error state
+        ...hasError && {
+          color: theme.palette.error.main
+        }
+      },
+      // Calendar icon styling
+      "& .MuiInputAdornment-root": {
+        color: disabled ? theme.palette.action.disabled : hasError ? theme.palette.error.main : theme.palette.action.active
+      },
+      // Focus ring for accessibility
+      "& .MuiOutlinedInput-root.Mui-focused": {
+        outline: `2px solid ${theme.palette.primary.main}50`,
+        // 50 is 31% opacity
+        outlineOffset: "2px"
+      },
+      // Enhanced contrast for dark themes
+      ...theme.palette.mode === "dark" && {
+        "& .MuiOutlinedInput-root": {
+          borderWidth: 2
+        }
+      }
+    };
+    return customSx ? [baseStyles, customSx] : baseStyles;
+  }, [
+    theme,
+    disabled,
+    hasError,
+    loading,
+    textReadOnly,
+    customSx
+  ]);
+  const className = _react.useMemo.call(void 0, () => {
+    const classes = [];
+    if (disabled) classes.push("DatePickerElement--disabled");
+    if (hasError) classes.push("DatePickerElement--error");
+    if (loading) classes.push("DatePickerElement--loading");
+    if (textReadOnly) classes.push("DatePickerElement--readOnly");
+    return classes.length > 0 ? classes.join(" ") : void 0;
+  }, [disabled, hasError, loading, textReadOnly]);
+  return {
+    sx: computedSx,
+    className
+  };
+}
+
+// src/wrappers/DatePickerElement/DatePickerElementCore.tsx
+
+var DatePickerElementCore = _react.forwardRef.call(void 0, (props, ref) => {
+  const {
+    name,
+    required = false,
+    rules,
+    control,
+    parseError,
+    transform,
+    validation,
+    label,
+    placeholder,
+    textReadOnly = false,
+    helperText,
+    inputProps = {},
+    slotProps = {},
+    datePickerProps = {},
+    variant = "outlined",
+    sx: customSx,
+    loading = false,
+    LoadingComponent,
+    ...restProps
+  } = props;
+  const {
+    disabled,
+    inputRef: externalInputRef,
+    onClose,
+    ...restDatePickerProps
+  } = datePickerProps;
+  const {
+    field,
+    fieldState
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control,
+    rules,
+    defaultValue: null
+    // Let react-hook-form handle the default value typing
+  });
+  const { value, onChange: onValueChange } = useDatePickerValue({
+    field,
+    transform
+  });
+  const { hasError, errorMessage, invalid } = useDatePickerValidation({
+    fieldState,
+    validation,
+    parseError,
+    value
+  });
+  const { sx: computedSx, className } = useDatePickerStyles({
+    disabled,
+    hasError,
+    loading,
+    textReadOnly,
+    sx: customSx
+  });
+  const handleInputRef = _material.useForkRef.call(void 0, field.ref, externalInputRef);
+  const handleChange = _react.useCallback.call(void 0, 
+    (newValue, context) => {
+      onValueChange(newValue, context);
+    },
+    [onValueChange]
+  );
+  const handleClose = _react.useCallback.call(void 0, 
+    (...args) => {
+      field.onBlur();
+      if (onClose) {
+        onClose(...args);
+      }
+    },
+    [field.onBlur, onClose]
+  );
+  const handleTextFieldBlur = _react.useCallback.call(void 0, 
+    (event) => {
+      field.onBlur();
+      if (typeof inputProps.onBlur === "function") {
+        inputProps.onBlur(event);
+      }
+    },
+    [field.onBlur, inputProps.onBlur]
+  );
+  const memoizedSlotProps = _react.useMemo.call(void 0, () => ({
+    ...slotProps,
+    actionBar: {
+      actions: ["clear", "today", "cancel", "accept"],
+      ...slotProps.actionBar
+    },
+    textField: {
+      ...inputProps,
+      required,
+      placeholder,
+      fullWidth: true,
+      variant,
+      onBlur: handleTextFieldBlur,
+      error: hasError,
+      helperText: hasError ? errorMessage : helperText,
+      inputProps: {
+        readOnly: textReadOnly,
+        "aria-invalid": invalid,
+        "aria-describedby": hasError ? `${name}-error` : void 0,
+        ...inputProps.inputProps
+      },
+      // Add loading indicator if provided
+      ...loading && LoadingComponent && {
+        InputProps: {
+          endAdornment: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, LoadingComponent, {}),
+          ...inputProps.InputProps
+        }
+      },
+      ...slotProps.textField
+    }
+  }), [
+    slotProps,
+    inputProps,
+    required,
+    placeholder,
+    variant,
+    handleTextFieldBlur,
+    hasError,
+    errorMessage,
+    helperText,
+    textReadOnly,
+    invalid,
+    name,
+    loading,
+    LoadingComponent
+  ]);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _xdatepickers.DatePicker,
+    {
+      ...restProps,
+      ...restDatePickerProps,
+      ref,
+      name,
+      value,
+      onChange: handleChange,
+      onClose: handleClose,
+      inputRef: handleInputRef,
+      label,
+      disabled,
+      sx: computedSx,
+      className,
+      slotProps: memoizedSlotProps,
+      "aria-invalid": invalid,
+      "aria-describedby": hasError ? `${name}-error` : void 0
+    }
+  );
+});
+DatePickerElementCore.displayName = "DatePickerElementCore";
+
+// src/wrappers/DatePickerElement/DatePickerElement.tsx
+
+var DatePickerElement = _react.forwardRef.call(void 0, (props, ref) => {
+  const {
+    gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+    ...coreProps
+  } = props;
+  if (gridProps === false) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      DatePickerElementCore,
+      {
+        ref,
+        ...coreProps
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.Grid,
+    {
+      ref,
+      ...gridProps,
+      children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        DatePickerElementCore,
+        {
+          ...coreProps
+        }
+      )
+    }
+  );
+});
+DatePickerElement.displayName = "DatePickerElement";
+
+// src/wrappers/DatePickerElement/utils.ts
+function isValidDate(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (value instanceof Date) {
+    return !isNaN(value.getTime());
+  }
+  if (typeof value === "object" && value !== null) {
+    if ("isValid" in value && typeof value.isValid === "function") {
+      return value.isValid();
+    }
+    if ("isValid" in value && typeof value.isValid === "boolean") {
+      return value.isValid;
+    }
+  }
+  return false;
+}
+function isParsableDateString(value) {
+  if (typeof value !== "string" || value === "") {
+    return false;
+  }
+  const isoDateRegex = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|[+-]\d{2}:\d{2})?)?$/;
+  if (isoDateRegex.test(value)) {
+    return true;
+  }
+  const parsed = new Date(value);
+  return !isNaN(parsed.getTime());
+}
+function createDateInputTransform(adapter) {
+  return (value) => {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (typeof value === "string") {
+      if (value === "") {
+        return null;
+      }
+      try {
+        const parsed = adapter.utils.date(value);
+        return isValidDate(parsed) ? parsed : null;
+      } catch (e2) {
+        return null;
+      }
+    }
+    if (isValidDate(value)) {
+      return value;
+    }
+    return null;
+  };
+}
+function createDateOutputTransform(format) {
+  return (value) => {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (!isValidDate(value)) {
+      return null;
+    }
+    if (!format) {
+      return value;
+    }
+    try {
+      if (value instanceof Date) {
+        if (format === "iso") {
+          return value.toISOString();
+        }
+        if (format === "date-only") {
+          return value.toISOString().split("T")[0];
+        }
+      }
+      if (typeof value.format === "function") {
+        return value.format(format);
+      }
+      if (typeof value.format === "function") {
+        return value.format(format);
+      }
+      if (typeof value.toFormat === "function") {
+        return value.toFormat(format);
+      }
+      return value;
+    } catch (e3) {
+      return null;
+    }
+  };
+}
+function createDefaultDatePickerConfig() {
+  return {
+    // Default slot props for consistent behavior
+    slotProps: {
+      actionBar: {
+        actions: ["clear", "today", "cancel", "accept"]
+      },
+      textField: {
+        fullWidth: true,
+        variant: "outlined"
+      }
+    },
+    // Default grid props for layout consistency
+    gridProps: {
+      size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }
+    },
+    // Default validation configuration
+    validation: {
+      errorMessages: {
+        invalidDate: "Please enter a valid date",
+        minDate: "Date must be after the minimum allowed date",
+        maxDate: "Date must be before the maximum allowed date",
+        disabledDate: "This date is not allowed"
+      }
+    }
+  };
+}
+function extractErrorMessage(error) {
+  if (error === null || error === void 0) {
+    return "";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    if ("message" in error && typeof error.message === "string") {
+      return error.message;
+    }
+    if ("type" in error && typeof error.type === "string") {
+      const errorType = error.type;
+      switch (errorType) {
+        case "invalidDate":
+          return "Please enter a valid date";
+        case "minDate":
+          return "Date is too early";
+        case "maxDate":
+          return "Date is too late";
+        case "disabledDate":
+          return "This date is not available";
+        default:
+          return "Invalid date selection";
+      }
+    }
+  }
+  return "Invalid input";
+}
+function createStableKey(config) {
+  try {
+    return JSON.stringify(config, (key, value) => {
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const sorted = {};
+        Object.keys(value).sort().forEach((k) => {
+          sorted[k] = value[k];
+        });
+        return sorted;
+      }
+      return value;
+    });
+  } catch (e4) {
+    return Object.keys(config).sort().join("-");
+  }
+}
+
+// src/wrappers/PasswordElement/PasswordElement.tsx
+var _Visibility = require('@mui/icons-material/Visibility'); var _Visibility2 = _interopRequireDefault(_Visibility);
+var _VisibilityOff = require('@mui/icons-material/VisibilityOff'); var _VisibilityOff2 = _interopRequireDefault(_VisibilityOff);
+
+
+
+
+
+
+
+
+
+
+
+
+var Component3 = function PasswordEl(props) {
+  const {
+    type,
+    required,
+    iconColor,
+    renderIcon = (password2) => password2 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _Visibility2.default, {}) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _VisibilityOff2.default, {}),
+    slotProps,
+    name,
+    control,
+    component: TextFieldComponent = _material.TextField,
+    inputRef,
+    onBlur,
+    ...rest
+  } = props;
+  const [password, setPassword] = _react.useState.call(void 0, true);
+  const endAdornment = /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.InputAdornment, { position: "end", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.IconButton,
+    {
+      onMouseDown: (e) => e.preventDefault(),
+      onClick: () => setPassword(!password),
+      tabIndex: -1,
+      color: _nullishCoalesce(iconColor, () => ( "default")),
+      children: renderIcon(password)
+    }
+  ) });
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control
+  });
+  const handleInputRef = _material.useForkRef.call(void 0, field.ref, inputRef);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.TextField,
+    {
+      ...rest,
+      inputRef: handleInputRef,
+      type: password ? "password" : "text",
+      value: field.value,
+      fullWidth: true,
+      onChange: (event) => {
+        field.onChange(event);
+        if (typeof rest.onChange === "function") {
+          rest.onChange(event);
+        }
+      },
+      onBlur: (event) => {
+        field.onBlur();
+        if (typeof onBlur === "function") {
+          onBlur(event);
+        }
+      },
+      ...typeof slotProps === "undefined" ? {
+        InputProps: {
+          endAdornment
+        }
+      } : {
+        slotProps: {
+          ...slotProps,
+          input: {
+            endAdornment,
+            ..._optionalChain([slotProps, 'optionalAccess', _16 => _16.input])
+          }
+        }
+      },
+      error: !!error,
+      helperText: error ? error.message : ""
+    }
+  );
+};
+var PasswordElement = ({
+  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.Grid,
+      {
+        ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps },
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component3, { ...props })
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component3, { ...props });
+};
+PasswordElement.displayName = "PasswordElement";
+var PasswordElement_default = PasswordElement;
+
+// src/wrappers/RadioButtonGroup/RadioButtonGroup.tsx
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var Component4 = function RadioButtonGroup(props) {
+  const {
+    options,
+    label,
+    name,
+    labelKey = "label",
+    valueKey = "id",
+    disabledKey = "disabled",
+    required,
+    emptyOptionLabel,
+    returnObject,
+    row,
+    control,
+    type,
+    labelProps,
+    disabled,
+    formLabelProps,
+    radioProps,
+    transform,
+    ...rest
+  } = props;
+  const theme = _material.useTheme.call(void 0, );
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    disabled,
+    control
+  });
+  const { value, onChange } = _chunkHEHPKM4Bcjs.useTransform.call(void 0, {
+    value: field.value,
+    onChange: field.onChange,
+    transform: {
+      input: typeof _optionalChain([transform, 'optionalAccess', _17 => _17.input]) === "function" ? transform.input : (value2) => {
+        return value2 || "";
+      },
+      output: typeof _optionalChain([transform, 'optionalAccess', _18 => _18.output]) === "function" ? _optionalChain([transform, 'optionalAccess', _19 => _19.output]) : (_event, value2) => {
+        if (value2 && type === "number") {
+          return Number(value2);
+        }
+        if (value2 && type === "boolean") {
+          return Boolean(value2);
+        }
+        return value2;
+      }
+    }
+  });
+  const onRadioChange = (event, radioValue) => {
+    const returnValue = returnObject ? options.find((option) => option[valueKey] === radioValue) : radioValue;
+    onChange(event, returnValue);
+    if (typeof rest.onChange === "function") {
+      rest.onChange(returnValue);
+    }
+  };
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.FormControl, { error: !!error, children: [
+    label && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.FormLabel, { ...formLabelProps, required, error: !!error, children: label }),
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _material.RadioGroup, { onChange: onRadioChange, name, row, value, children: [
+      emptyOptionLabel && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _material.FormControlLabel,
+        {
+          ...labelProps,
+          control: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            _material.Radio,
+            {
+              ...radioProps,
+              sx: {
+                color: error ? theme.palette.error.main : void 0
+              },
+              checked: !value
+            }
+          ),
+          label: emptyOptionLabel,
+          value: ""
+        }
+      ),
+      options.map((option) => {
+        const optionKey = option[valueKey];
+        const optionDisabled = option[disabledKey] || false;
+        let val = returnObject ? _optionalChain([value, 'optionalAccess', _20 => _20[valueKey]]) : value;
+        if (type === "number" && val !== void 0) {
+          val = Number(val);
+        } else if (type === "boolean" && val !== void 0) {
+          val = Boolean(val);
+        }
+        const isChecked = val === optionKey;
+        return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _material.FormControlLabel,
+          {
+            ...labelProps,
+            control: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              _material.Radio,
+              {
+                ...radioProps,
+                sx: {
+                  color: error ? theme.palette.error.main : void 0
+                },
+                disabled: disabled || optionDisabled,
+                checked: isChecked
+              }
+            ),
+            value: optionKey,
+            label: option[labelKey]
+          },
+          String(optionKey)
+        );
+      })
+    ] }),
+    error && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.FormHelperText, { children: error.message })
+  ] });
+};
+var RadioButtonGroup2 = ({
+  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.Grid,
+      {
+        ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps },
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component4, { ...props })
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component4, { ...props });
+};
+RadioButtonGroup2.displayName = "RadioButtonGroup";
+var RadioButtonGroup_default = RadioButtonGroup2;
+
+// src/wrappers/SelectCascadeElement/SelectCascadeElement.tsx
+
+
+
+
+
+
+
+
+
+
+
+var Component5 = function SelectCascadeElement(props) {
+  const {
+    labelKey = "Label",
+    valueKey = "Value",
+    name,
+    onBlur,
+    onChange,
+    disabled,
+    options,
+    control,
+    loading = false,
+    placeholder,
+    label,
+    dependsOn,
+    textFieldProps = {},
+    variant,
+    sx,
+    isEdit = false,
+    ...rest
+  } = props;
+  const { required } = textFieldProps;
+  const getOptionKey = _react.useCallback.call(void 0, 
+    (option) => {
+      if (typeof option === "string" || typeof option === "number") return option;
+      const key = option ? option[valueKey] : void 0;
+      return key !== void 0 && key !== null ? String(key) : "";
+    },
+    [valueKey]
+  );
+  const getOptionLabel = _react.useCallback.call(void 0, 
+    (option) => {
+      if (typeof option === "string") return option;
+      return option ? String(option[labelKey]) : "";
+    },
+    [labelKey]
+  );
+  const isOptionEqualToValue = (option, value) => getOptionKey(option) === getOptionKey(value);
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control
+  });
+  const theme = _material.useTheme.call(void 0, );
+  const { field: dependentField } = _reacthookform.useController.call(void 0, {
+    name: dependsOn,
+    control
+  });
+  const parentValueRef = _react.useRef.call(void 0, _nullishCoalesce(dependentField.value, () => ( null)));
+  const [hasAutoSelected, setHasAutoSelected] = _react.useState.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    if (!!dependentField.value && _optionalChain([parentValueRef, 'optionalAccess', _21 => _21.current]) !== dependentField.value || dependentField.value === null) {
+      field.onChange(null);
+      setHasAutoSelected(false);
+    }
+  }, [dependentField.value]);
+  _react.useEffect.call(void 0, () => {
+    if (isEdit && !disabled && options.length === 1 && field.value == null && !hasAutoSelected) {
+      field.onChange(getOptionKey(options[0]));
+      setHasAutoSelected(true);
+    } else {
+      if (options.length === 1 && field.value == null && !hasAutoSelected) {
+        field.onChange(getOptionKey(options[0]));
+        setHasAutoSelected(true);
+      }
+    }
+  }, [
+    options,
+    field.value,
+    field.onChange,
+    hasAutoSelected,
+    isEdit,
+    disabled,
+    field,
+    getOptionKey,
+    dependentField.onChange
+  ]);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.Autocomplete,
+    {
+      ...rest,
+      value: options.map((option) => getOptionKey(option) === field.value ? option : null).find(Boolean) || null,
+      size: "small",
+      loading,
+      options,
+      getOptionKey,
+      getOptionLabel,
+      isOptionEqualToValue,
+      ref: field.ref,
+      disabled: dependentField.value == null || disabled,
+      onChange: (event, newValue, reason) => {
+        field.onChange(newValue ? getOptionKey(newValue) : null);
+        if (onChange && typeof onChange === "function") {
+          onChange(event, newValue, reason);
+        }
+      },
+      onBlur: (event) => {
+        field.onBlur();
+        if (typeof onBlur === "function") {
+          onBlur(event);
+        }
+      },
+      fullWidth: true,
+      renderInput: (params) => (
+        // @ts-ignore
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _material.TextField,
+          {
+            ...params,
+            fullWidth: true,
+            error: !!error,
+            required,
+            helperText: error ? error.message : "",
+            placeholder,
+            label,
+            variant: variant ? variant : "outlined",
+            sx: {
+              "& .MuiOutlinedInput-root": {
+                bgcolor: disabled || dependentField.value == null ? theme.palette.action.disabledBackground : "transparent"
+              },
+              "& .MuiInputLabel-asterisk": { color: "red" },
+              "& .MuiInputBase-input": {
+                cursor: disabled || dependentField.value == null ? "not-allowed" : "default"
+              },
+              ...sx
+            }
+          }
+        )
+      )
+    }
+  );
+};
+var SelectCascadeElement2 = ({
+  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Grid, { ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component5, { ...props }) });
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component5, { ...props });
+};
+SelectCascadeElement2.displayName = "SelectCascadeElement";
+var SelectCascadeElement_default = SelectCascadeElement2;
+
+// src/wrappers/SelectElement/SelectElement.tsx
+
+
+
+
+
+
+
+
+
+
+var Component6 = function SelectElement(props) {
+  const {
+    name,
+    control,
+    onChange,
+    isEdit,
+    options,
+    label,
+    sx,
+    variant,
+    disabled,
+    labelKey = "Label",
+    valueKey = "Value",
+    placeholder,
+    textFieldProps = {},
+    ...rest
+  } = props;
+  const { required } = textFieldProps;
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control
+  });
+  const theme = _material.useTheme.call(void 0, );
+  const getOptionValue = _react.useCallback.call(void 0, 
+    (option) => {
+      if (typeof option === "string") return option;
+      return option ? option[valueKey] : null;
+    },
+    [valueKey]
+  );
+  const getOptionLabel = _react.useCallback.call(void 0, 
+    (option) => {
+      if (typeof option === "string") return option;
+      return option ? String(option[labelKey]) : "";
+    },
+    [labelKey]
+  );
+  const handleChange = (event, newValue, reason) => {
+    const option = newValue;
+    field.onChange(option ? getOptionValue(option) : null);
+    _optionalChain([onChange, 'optionalCall', _22 => _22(event, newValue, reason)]);
+  };
+  _react.useEffect.call(void 0, () => {
+    if (!isEdit && options.length === 1 && (field.value == null || field.value == void 0 || field.value === "")) {
+      const defaultOption = options[0];
+      const defaultValue = getOptionValue(defaultOption);
+      field.onChange(defaultValue);
+    }
+  }, [isEdit, options]);
+  const autocompleteValue = _react.useMemo.call(void 0, 
+    () => _nullishCoalesce(options.find((option) => getOptionValue(option) === field.value), () => ( null)),
+    [field.value, options, getOptionValue]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.Autocomplete,
+    {
+      ...rest,
+      filterSelectedOptions: false,
+      options,
+      value: autocompleteValue,
+      onChange: handleChange,
+      disabled,
+      getOptionLabel: (option) => getOptionLabel(option),
+      ref: field.ref,
+      isOptionEqualToValue: (option, value) => getOptionValue(option) === getOptionValue(value),
+      renderInput: (params) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _material.TextField,
+        {
+          ...params,
+          fullWidth: true,
+          required,
+          error: !!error,
+          helperText: error ? error.message : "",
+          label,
+          placeholder,
+          variant: variant ? variant : "outlined",
+          sx: {
+            "& .MuiOutlinedInput-root": {
+              bgcolor: disabled ? theme.palette.action.disabledBackground : "transparent"
+            },
+            "& .MuiInputLabel-asterisk": { color: "red" },
+            "& .MuiInputBase-input": {
+              cursor: disabled ? "not-allowed" : "default"
+            },
+            ...sx
+          }
+        }
+      )
+    }
+  );
+};
+var SelectElement2 = ({
+  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.Grid,
+      {
+        ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps },
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component6, { ...props })
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component6, { ...props });
+};
+SelectElement2.displayName = "SelectElement";
+var SelectElement_default = SelectElement2;
+
+// src/wrappers/SelectMultiElement/SelectMultiElement.tsx
+var _CheckBox = require('@mui/icons-material/CheckBox'); var _CheckBox2 = _interopRequireDefault(_CheckBox);
+var _CheckBoxOutlineBlank = require('@mui/icons-material/CheckBoxOutlineBlank'); var _CheckBoxOutlineBlank2 = _interopRequireDefault(_CheckBoxOutlineBlank);
+
+
+
+
+var Component7 = function SelectMultiElement(props) {
+  const {
+    name,
+    control,
+    onBlur,
+    disabled,
+    options,
+    loading = false,
+    placeholder,
+    label,
+    variant,
+    sx,
+    labelKey = "Label",
+    valueKey = "Value",
+    ...rest
+  } = props;
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control
+  });
+  const getOptionValue = (option) => {
+    if (typeof option === "string") return option;
+    return option ? option[valueKey] : null;
+  };
+  const getOptionLabel = (option) => {
+    if (typeof option === "string") return option;
+    return option ? option[labelKey] : "";
+  };
+  const selectedValue = field.value && Array.isArray(field.value) ? options.filter((option) => field.value.includes(getOptionValue(option))) : [];
+  const handleChange = (_, selectedOptions, reason) => {
+    if (reason === "clear") {
+      field.onChange([]);
+    } else if (reason === "selectOption" || reason === "removeOption") {
+      const newValues = selectedOptions.map((option) => getOptionValue(option));
+      field.onChange(newValues);
+    }
+  };
+  const icon = /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _CheckBoxOutlineBlank2.default, { fontSize: "small" });
+  const checkedIcon = /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _CheckBox2.default, { fontSize: "small" });
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.Autocomplete,
+    {
+      multiple: true,
+      value: selectedValue,
+      loading,
+      options,
+      getOptionLabel,
+      isOptionEqualToValue: (option, value) => getOptionValue(option) === getOptionValue(value),
+      filterSelectedOptions: true,
+      disableCloseOnSelect: true,
+      ref: field.ref,
+      disabled: _nullishCoalesce(disabled, () => ( field.disabled)),
+      onChange: handleChange,
+      onBlur: (event) => {
+        field.onBlur();
+        if (typeof onBlur === "function") {
+          onBlur(event);
+        }
+      },
+      fullWidth: true,
+      renderOption: (props1, option, { selected }) => {
+        const { key, ...optionProps } = props1;
+        return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "li", { ...optionProps, children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Checkbox, { icon, checkedIcon, checked: selected }),
+          getOptionLabel(option)
+        ] }, key);
+      },
+      renderInput: (params) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _material.TextField,
+        {
+          ...params,
+          label,
+          error: !!error,
+          helperText: error ? error.message : "",
+          placeholder,
+          slotProps: {
+            input: {
+              ...params.InputProps,
+              endAdornment: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _react.Fragment, { children: [
+                loading ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.CircularProgress, { color: "inherit", size: 20 }) : null,
+                params.InputProps.endAdornment
+              ] })
+            }
+          },
+          variant: variant ? variant : "outlined",
+          sx: {
+            ...sx
+          }
+        }
+      ),
+      ...rest
+    }
+  );
+};
+var SelectMultiElement2 = ({
+  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.Grid, { ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component7, { ...props }) });
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component7, { ...props });
+};
+SelectMultiElement2.displayName = "SelectMultiElement";
+var SelectMultiElement_default = SelectMultiElement2;
+
+// src/wrappers/TextFieldElement/TextFieldElement.tsx
+
+
+
+
+
+
+
+
+
+
+var Component8 = function TextFieldElement(props) {
+  const {
+    rules = {},
+    parseError,
+    name,
+    control,
+    component: TextFieldComponent = _material.TextField,
+    gridProps,
+    transform,
+    label,
+    placeholder,
+    textFieldProps = {},
+    variant,
+    sx,
+    ...rest
+  } = props;
+  const {
+    type,
+    required,
+    helperText,
+    inputRef,
+    onBlur,
+    disabled,
+    ...restTextProps
+  } = textFieldProps;
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control
+  });
+  const theme = _material.useTheme.call(void 0, );
+  const { value, onChange } = _chunkHEHPKM4Bcjs.useTransform.call(void 0, {
+    value: field.value,
+    onChange: field.onChange,
+    transform: {
+      input: typeof _optionalChain([transform, 'optionalAccess', _23 => _23.input]) === "function" ? transform.input : (value2) => {
+        return _nullishCoalesce(value2, () => ( ""));
+      },
+      output: typeof _optionalChain([transform, 'optionalAccess', _24 => _24.output]) === "function" ? transform.output : (eventOrValue, value2) => {
+        const extractedValue = value2 !== void 0 ? value2 : typeof eventOrValue === "object" && eventOrValue !== null && "target" in eventOrValue && typeof eventOrValue.target === "object" && eventOrValue.target !== null && "value" in eventOrValue.target ? eventOrValue.target.value : eventOrValue;
+        if (type !== "number") {
+          return extractedValue;
+        }
+        if (extractedValue === "") {
+          return null;
+        }
+        if (extractedValue == null) {
+          return extractedValue;
+        }
+        return Number(extractedValue);
+      }
+    }
+  });
+  const handleInputRef = _material.useForkRef.call(void 0, field.ref, inputRef);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    TextFieldComponent,
+    {
+      ...rest,
+      ...restTextProps,
+      name: field.name,
+      value,
+      onChange: (event) => {
+        field.onChange(event);
+        if (typeof onChange === "function") {
+          onChange(event);
+        }
+      },
+      onBlur: (event) => {
+        field.onBlur();
+        if (typeof onBlur === "function") {
+          onBlur(event);
+        }
+      },
+      disabled,
+      label,
+      placeholder,
+      fullWidth: true,
+      required,
+      type,
+      error: !!error,
+      helperText: error ? error.message : helperText,
+      inputRef: handleInputRef,
+      variant: variant ? variant : "outlined",
+      size: "small",
+      sx: {
+        "& .MuiInputLabel-asterisk": { color: "red" },
+        "& .MuiInputBase-input": {
+          cursor: disabled ? "not-allowed" : "default"
+        },
+        bgcolor: disabled ? theme.palette.action.disabledBackground : "transparent",
+        ...sx
+      }
+    }
+  );
+};
+var TextFieldElement2 = ({
+  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.Grid,
+      {
+        ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps },
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component8, { ...props })
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component8, { ...props });
+};
+TextFieldElement2.displayName = "TextFieldElement";
+var TextFieldElement_default = TextFieldElement2;
+
+// src/wrappers/TextFieldElement/EnhancedTextFieldElement.tsx
+
+
+
+
+
+
+
+
+
+
+var Component9 = function EnhancedTextFieldElement(props) {
+  const {
+    rules = {},
+    parseError,
+    name,
+    control,
+    component: TextFieldComponent = _material.TextField,
+    gridProps,
+    transform,
+    fieldType = "text",
+    // Default to text type
+    defaultValue,
+    label,
+    placeholder,
+    textFieldProps = {},
+    variant,
+    sx,
+    onChange: customOnChange,
+    enableWarnings = process.env.NODE_ENV === "development",
+    ...rest
+  } = props;
+  const {
+    type,
+    required,
+    helperText,
+    inputRef,
+    onBlur,
+    disabled,
+    ...restTextProps
+  } = textFieldProps;
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control,
+    rules
+  });
+  const theme = _material.useTheme.call(void 0, );
+  const { value, onChange } = _chunkHEHPKM4Bcjs.useEnhancedTransform.call(void 0, {
+    value: field.value,
+    onChange: field.onChange,
+    transform: transform ? {
+      input: transform.input,
+      output: transform.output
+    } : void 0,
+    fieldType: !transform ? type === "number" ? "number" : fieldType : void 0,
+    // Auto-detect number type
+    defaultValue,
+    enableWarnings
+  });
+  const handleInputRef = _material.useForkRef.call(void 0, field.ref, inputRef);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    TextFieldComponent,
+    {
+      ...rest,
+      ...restTextProps,
+      name: field.name,
+      value,
+      onChange: (event) => {
+        onChange(event);
+        if (typeof customOnChange === "function") {
+          customOnChange(event);
+        }
+      },
+      onBlur: (event) => {
+        field.onBlur();
+        if (typeof onBlur === "function") {
+          onBlur(event);
+        }
+      },
+      disabled,
+      label,
+      placeholder,
+      fullWidth: true,
+      required,
+      type,
+      error: !!error,
+      helperText: error ? parseError ? parseError(error) : error.message : helperText,
+      inputRef: handleInputRef,
+      variant: variant ? variant : "outlined",
+      size: "small",
+      sx: {
+        "& .MuiInputLabel-asterisk": { color: "red" },
+        "& .MuiInputBase-input": {
+          cursor: disabled ? "not-allowed" : "default"
+        },
+        bgcolor: disabled ? theme.palette.action.disabledBackground : "transparent",
+        ...sx
+      }
+    }
+  );
+};
+var EnhancedTextFieldElement2 = ({
+  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.Grid,
+      {
+        ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps },
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component9, { ...props })
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component9, { ...props });
+};
+EnhancedTextFieldElement2.displayName = "EnhancedTextFieldElement";
+
+// src/wrappers/TimePickerElement/TimePickerElement.tsx
+
+
+
+
+
+
+function readValueAsDate(adapter, value) {
+  if (typeof value === "string") {
+    if (value === "") {
+      return null;
+    }
+    return adapter.utils.date(value);
+  }
+  return value;
+}
+function useTransform2(options) {
+  const value = typeof _optionalChain([options, 'access', _25 => _25.transform, 'optionalAccess', _26 => _26.input]) === "function" ? options.transform.input(options.value) : options.value;
+  const onChange = _react.useCallback.call(void 0, 
+    (eventOrValue, value2) => {
+      if (typeof _optionalChain([options, 'access', _27 => _27.transform, 'optionalAccess', _28 => _28.output]) === "function") {
+        options.onChange(options.transform.output(eventOrValue, value2));
+      } else {
+        options.onChange(eventOrValue);
+      }
+    },
+    [options]
+  );
+  return {
+    value,
+    onChange
+  };
+}
+var Component10 = function TimePickerElement(props) {
+  const {
+    name,
+    required,
+    inputProps,
+    control,
+    textReadOnly,
+    label,
+    placeholder,
+    slotProps,
+    timePickerProps = {},
+    transform,
+    sx,
+    ...rest
+  } = props;
+  const adapter = _internals.useLocalizationContext.call(void 0, );
+  const theme = _material.useTheme.call(void 0, );
+  const { disabled, inputRef, onClose, ...restTimePickerProps } = timePickerProps;
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control,
+    defaultValue: null
+  });
+  const { value, onChange } = useTransform2({
+    value: field.value,
+    onChange: field.onChange,
+    transform: {
+      input: typeof _optionalChain([transform, 'optionalAccess', _29 => _29.input]) === "function" ? transform.input : (newValue) => readValueAsDate(adapter, newValue),
+      output: (eventOrValue, value2) => {
+        const actualValue = value2 !== void 0 ? value2 : eventOrValue;
+        if (actualValue === null) return null;
+        return actualValue;
+      }
+    }
+  });
+  const handleInputRef = _material.useForkRef.call(void 0, field.ref, inputRef);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _xdatepickers.TimePicker,
+    {
+      ...rest,
+      ...restTimePickerProps,
+      ...field,
+      value,
+      label,
+      disabled,
+      ...timePickerProps,
+      inputRef: handleInputRef,
+      onClose: (...args) => {
+        field.onBlur();
+        if (onClose) {
+          onClose(...args);
+        }
+      },
+      onChange: (newValue, context) => {
+        onChange(newValue, context);
+        if (typeof timePickerProps.onChange === "function") {
+          timePickerProps.onChange(newValue, context);
+        }
+      },
+      sx: {
+        "& .MuiOutlinedInput-root": {
+          bgcolor: disabled ? theme.palette.action.disabledBackground : "transparent"
+        },
+        "& .MuiInputLabel-asterisk": { color: "red" },
+        "& .MuiInputBase-input": {
+          cursor: disabled ? "not-allowed" : "default"
+        },
+        ...sx
+      },
+      slotProps: {
+        ...slotProps,
+        actionBar: {
+          actions: ["clear", "cancel", "accept"]
+        },
+        textField: {
+          ...inputProps,
+          required,
+          placeholder,
+          fullWidth: true,
+          onBlur: (event) => {
+            field.onBlur();
+            if (typeof _optionalChain([inputProps, 'optionalAccess', _30 => _30.onBlur]) === "function") {
+              inputProps.onBlur(event);
+            }
+          },
+          error: !!error,
+          helperText: error ? error.message : _optionalChain([inputProps, 'optionalAccess', _31 => _31.helperText]) || rest.helperText,
+          inputProps: {
+            readOnly: !!textReadOnly,
+            ..._optionalChain([inputProps, 'optionalAccess', _32 => _32.inputProps])
+          }
+        }
+      }
+    }
+  );
+};
+var TimePickerElement2 = ({
+  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.Grid,
+      {
+        ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps },
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component10, { ...props })
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component10, { ...props });
+};
+TimePickerElement2.displayName = "TimePickerElement";
+var TimePickerElement_default = TimePickerElement2;
+
+// src/wrappers/AsyncSelect/index.tsx
+
+var _utils = require('@mui/material/utils');
+
+
+
+
+
+
+
+
+
+
+
+var Component11 = function AsyncSelectElement(props) {
+  const {
+    name,
+    disabled,
+    control,
+    placeholder,
+    initialValue,
+    label,
+    queryFn,
+    variant,
+    labelKey = "Label",
+    valueKey = "Value",
+    sx,
+    ...rest
+  } = props;
+  const {
+    field,
+    fieldState: { error }
+  } = _reacthookform.useController.call(void 0, {
+    name,
+    control
+  });
+  const theme = _material.useTheme.call(void 0, );
+  const [loading, setLoading] = _react.useState.call(void 0, false);
+  const [selectedOption, setSelectedOption] = _react.useState.call(void 0, null);
+  const [inputValue, setInputValue] = _react.useState.call(void 0, "");
+  const inputValue2 = _react.useMemo.call(void 0, () => inputValue, [inputValue]);
+  const setInputValue2 = _react.useCallback.call(void 0, 
+    (newValue) => setInputValue(newValue),
+    []
+  );
+  const [options, setOptions] = _react.useState.call(void 0, []);
+  const initialValueLoaded = _react.useRef.call(void 0, 
+    !initialValue ? true : !(initialValue != null)
+  );
+  const fieldValue = _react.useRef.call(void 0, field.value);
+  const fetchData = _react.useMemo.call(void 0, 
+    () => _utils.debounce.call(void 0, 
+      (payload, callback) => {
+        queryFn(payload).then((c) => callback(c));
+      },
+      400
+    ),
+    [queryFn]
+  );
+  const fillOptions = _react.useCallback.call(void 0, (results) => {
+    let newOptions = [];
+    if (selectedOption) {
+      newOptions = [selectedOption];
+    }
+    if (results) {
+      newOptions = [...newOptions, ...results];
+    }
+    setOptions(newOptions);
+    setLoading(false);
+  }, [selectedOption]);
+  _react.useEffect.call(void 0, () => {
+    if (initialValueLoaded.current) return void 0;
+    let active = true;
+    const payload = {
+      query: null,
+      initialValue
+    };
+    setLoading(true);
+    fetchData(payload, (results) => {
+      if (active) {
+        if (!!results && results.length > 0) {
+          fillOptions(_optionalChain([results, 'optionalAccess', _33 => _33.filter, 'call', _34 => _34((c) => c[valueKey] == initialValue)]));
+          setSelectedOption(results[0]);
+          field.onChange(results[0][valueKey]);
+          fieldValue.current = results[0][valueKey];
+        }
+        initialValueLoaded.current = true;
+        setLoading(false);
+      }
+    });
+    return () => {
+      active = false;
+    };
+  }, [initialValue, fetchData, field, fillOptions, valueKey]);
+  React7.useEffect(() => {
+    let active = true;
+    if (inputValue2 === "" || initialValueLoaded.current === false) {
+      setOptions(selectedOption ? [selectedOption] : []);
+      setLoading(false);
+      return void 0;
+    }
+    if (fieldValue.current) {
+      if (field.value === fieldValue.current) {
+        return void 0;
+      }
+    }
+    setLoading(true);
+    const payload = {
+      query: inputValue2,
+      initialValue: null
+    };
+    fetchData(payload, (results) => {
+      if (active) {
+        fillOptions(results);
+      }
+    });
+    return () => {
+      active = false;
+    };
+  }, [initialValue, inputValue2, fetchData, field.value, fillOptions, selectedOption]);
+  const selectRef = _react.useRef.call(void 0, null);
+  const handleChange = (_, newSelectedOption, reason) => {
+    if (reason === "clear") {
+      setSelectedOption(null);
+      field.onChange(null);
+      setLoading(false);
+    } else if (reason === "selectOption" || reason === "removeOption") {
+      if (newSelectedOption) {
+        setSelectedOption(newSelectedOption);
+        field.onChange(newSelectedOption[valueKey]);
+        fieldValue.current = newSelectedOption[valueKey];
+        setLoading(false);
+      }
+    }
+    setOptions([]);
+    setLoading(false);
+  };
+  _react.useEffect.call(void 0, () => {
+    if (!field.value) {
+      setInputValue("");
+      setSelectedOption(null);
+      setLoading(false);
+    }
+  }, [field.value]);
+  const getOptionValue = (option) => {
+    return option ? String(option[valueKey]) : "";
+  };
+  const getOptionLabel = (option) => {
+    return option ? String(option[labelKey]) : "";
+  };
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _material.Autocomplete,
+    {
+      ...rest,
+      ref: selectRef,
+      fullWidth: true,
+      loading,
+      getOptionLabel,
+      getOptionKey: getOptionValue,
+      isOptionEqualToValue: (option, value) => getOptionValue(option) === getOptionValue(value),
+      autoComplete: true,
+      disabled,
+      includeInputInList: true,
+      options,
+      filterOptions: (x) => x,
+      value: selectedOption,
+      filterSelectedOptions: true,
+      onChange: handleChange,
+      onInputChange: (_, newInputValue) => {
+        setInputValue2(newInputValue);
+      },
+      noOptionsText: "Type Something...",
+      renderInput: (params) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _material.TextField,
+        {
+          ...params,
+          label,
+          error: !!error,
+          helperText: error ? error.message : "",
+          placeholder,
+          slotProps: {
+            input: {
+              ...params.InputProps,
+              endAdornment: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _react.Fragment, { children: [
+                loading ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _material.CircularProgress, { color: "inherit", size: 20 }) : null,
+                params.InputProps.endAdornment
+              ] })
+            }
+          },
+          variant: variant ? variant : "outlined",
+          sx: {
+            "& .MuiInputBase-input": {
+              cursor: disabled ? "not-allowed" : "default"
+            },
+            bgcolor: disabled ? theme.palette.action.disabledBackground : "transparent",
+            ...sx
+          }
+        }
+      ),
+      renderOption: (renderProps, option) => {
+        const { key, ...optionProps } = renderProps;
+        return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "li", { ...optionProps, children: option[labelKey] }, key);
+      }
+    }
+  );
+};
+var AsyncSelectElement2 = ({
+  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },
+  ...props
+}) => {
+  if (gridProps) {
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _material.Grid,
+      {
+        ...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps },
+        children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component11, { ...props })
+      }
+    );
+  }
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Component11, { ...props });
+};
+AsyncSelectElement2.displayName = "AsyncSelectElement";
+
+// src/wrappers/Field/index.ts
+var Field = {
+  Text: TextFieldElement_default,
+  Checkbox: CheckboxElement2,
+  Date: DatePickerElement,
+  RadioGroup: RadioButtonGroup_default,
+  Password: PasswordElement_default,
+  Time: TimePickerElement_default,
+  Select: SelectElement_default,
+  SelectMulti: SelectMultiElement_default,
+  SelectCascade: SelectCascadeElement_default,
+  AsyncSelect: AsyncSelectElement2,
+  AsyncMultiSelect: AsyncMultiSelect2,
+  CheckboxGroup: CheckboxGroup2
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AsyncMultiSelect2 = AsyncMultiSelect2; exports.CheckboxElement = CheckboxElement2; exports.CheckboxGroup = CheckboxGroup2; exports.readDatePickerValueAsDate = readDatePickerValueAsDate; exports.useDatePickerValue = useDatePickerValue; exports.useDatePickerValidation = useDatePickerValidation; exports.useDatePickerStyles = useDatePickerStyles; exports.DatePickerElementCore = DatePickerElementCore; exports.DatePickerElement = DatePickerElement; exports.isValidDate = isValidDate; exports.isParsableDateString = isParsableDateString; exports.createDateInputTransform = createDateInputTransform; exports.createDateOutputTransform = createDateOutputTransform; exports.createDefaultDatePickerConfig = createDefaultDatePickerConfig; exports.extractErrorMessage = extractErrorMessage; exports.createStableKey = createStableKey; exports.PasswordElement_default = PasswordElement_default; exports.RadioButtonGroup_default = RadioButtonGroup_default; exports.SelectCascadeElement_default = SelectCascadeElement_default; exports.SelectElement_default = SelectElement_default; exports.SelectMultiElement_default = SelectMultiElement_default; exports.TextFieldElement_default = TextFieldElement_default; exports.EnhancedTextFieldElement = EnhancedTextFieldElement2; exports.TimePickerElement_default = TimePickerElement_default; exports.Field = Field;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/builds/libs/GNWebSoft.UI/packages/ui/dist/chunk-AEOF2TUF.cjs","../src/wrappers/AsyncMultiSelect2/AsyncMultiSelect2.tsx","../src/wrappers/CheckboxElement/CheckboxElement.tsx","../src/wrappers/CheckboxGroup/CheckboxGroup.tsx","../src/wrappers/DatePickerElement/DatePickerElement.tsx","../src/wrappers/DatePickerElement/DatePickerElementCore.tsx","../src/wrappers/DatePickerElement/hooks/useDatePickerValue.ts","../src/wrappers/DatePickerElement/hooks/useDatePickerValidation.ts","../src/wrappers/DatePickerElement/hooks/useDatePickerStyles.ts","../src/wrappers/DatePickerElement/utils.ts","../src/wrappers/PasswordElement/PasswordElement.tsx","../src/wrappers/RadioButtonGroup/RadioButtonGroup.tsx","../src/wrappers/SelectCascadeElement/SelectCascadeElement.tsx","../src/wrappers/SelectElement/SelectElement.tsx","../src/wrappers/SelectMultiElement/SelectMultiElement.tsx","../src/wrappers/TextFieldElement/TextFieldElement.tsx","../src/wrappers/TextFieldElement/EnhancedTextFieldElement.tsx","../src/wrappers/TimePickerElement/TimePickerElement.tsx","../src/wrappers/AsyncSelect/index.tsx","../src/wrappers/Field/index.ts"],"names":["useTheme","useController","value","jsxs","jsx","CheckboxElement","Grid","Component","useEffect","FormControl","FormGroup","FormControlLabel","Checkbox","CheckboxGroup","TextField","RadioButtonGroup","Autocomplete","SelectCascadeElement","SelectElement","SelectMultiElement","TextFieldElement","EnhancedTextFieldElement","TimePickerElement","AsyncSelectElement"],"mappings":"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","file":"/builds/libs/GNWebSoft.UI/packages/ui/dist/chunk-AEOF2TUF.cjs","sourcesContent":[null,"import {\n  Autocomplete,\n  CircularProgress,\n  Grid,\n  TextField,\n  useTheme,\n} from \"@mui/material\";\nimport { debounce } from \"lodash\";\nimport React, { useCallback, useEffect, useReducer, useMemo } from \"react\";\nimport { useController } from \"react-hook-form\";\nimport type { FieldPath, FieldValues } from \"react-hook-form\";\n\nimport type { AsyncMultiSelect2Props, AsyncSelect2Payload, Option2Item } from \"./types\";\n\ninterface ComponentState {\n  options: Option2Item[];\n  selectedOptions: Option2Item[];\n  inputValue: string;\n  loading: boolean;\n  initialLoaded: boolean;\n}\n\ntype ComponentAction =\n  | { type: \"SET_OPTIONS\"; payload: Option2Item[] }\n  | { type: \"SET_SELECTED_OPTIONS\"; payload: Option2Item[] }\n  | { type: \"SET_INPUT_VALUE\"; payload: string }\n  | { type: \"SET_LOADING\"; payload: boolean }\n  | { type: \"SET_INITIAL_LOADED\"; payload: boolean }\n  | { type: \"RESET_OPTIONS\" };\n\nconst initialState: ComponentState = {\n  options: [],\n  selectedOptions: [],\n  inputValue: \"\",\n  loading: false,\n  initialLoaded: false,\n};\n\nfunction componentReducer(state: ComponentState, action: ComponentAction): ComponentState {\n  switch (action.type) {\n    case \"SET_OPTIONS\":\n      return { ...state, options: action.payload, loading: false };\n    case \"SET_SELECTED_OPTIONS\":\n      return { ...state, selectedOptions: action.payload };\n    case \"SET_INPUT_VALUE\":\n      return { ...state, inputValue: action.payload };\n    case \"SET_LOADING\":\n      return { ...state, loading: action.payload };\n    case \"SET_INITIAL_LOADED\":\n      return { ...state, initialLoaded: action.payload };\n    case \"RESET_OPTIONS\":\n      return { ...state, options: state.selectedOptions };\n    default:\n      return state;\n  }\n}\n\nconst AsyncMultiSelect2Component = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>\n>({\n  name,\n  control,\n  placeholder,\n  initialValues,\n  label,\n  queryFn,\n  variant = \"outlined\",\n  sx,\n  disabled = false,\n  debounceMs = 400,\n  loadingText = \"Loading...\",\n  noOptionsText = \"No options\",\n  renderInput,\n  ...rest\n}: AsyncMultiSelect2Props<TFieldValues, TName>) => {\n  const [state, dispatch] = useReducer(componentReducer, initialState);\n  const theme = useTheme();\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n  });\n\n  const debouncedFetch = useMemo(\n    () =>\n      debounce(async (payload: AsyncSelect2Payload) => {\n        try {\n          const results = await queryFn(payload);\n\n          // Merge selected options with search results, avoiding duplicates\n          const mergedOptions = [\n            ...state.selectedOptions,\n            ...results.filter(\n              (option) => !state.selectedOptions.some((selected) => selected.value === option.value)\n            ),\n          ];\n\n          dispatch({ type: \"SET_OPTIONS\", payload: mergedOptions });\n        } catch (_error) {\n          dispatch({ type: \"SET_LOADING\", payload: false });\n        }\n      }, debounceMs),\n    [queryFn, state.selectedOptions, debounceMs]\n  );\n\n  // Load initial values\n  useEffect(() => {\n    if (!initialValues?.length || state.initialLoaded) return;\n\n    dispatch({ type: \"SET_LOADING\", payload: true });\n\n    const payload: AsyncSelect2Payload = {\n      query: null,\n      initialValues,\n    };\n\n    queryFn(payload).then((results) => {\n      if (results) {\n        dispatch({ type: \"SET_SELECTED_OPTIONS\", payload: results });\n        dispatch({ type: \"SET_OPTIONS\", payload: results });\n        dispatch({ type: \"SET_INITIAL_LOADED\", payload: true });\n        field.onChange(results.map((option) => option.value));\n      }\n\n      dispatch({ type: \"SET_LOADING\", payload: false });\n    }).catch((_error) => {\n      dispatch({ type: \"SET_LOADING\", payload: false });\n    });\n  }, [initialValues, state.initialLoaded, queryFn, field]);\n\n  // Handle search input changes\n  useEffect(() => {\n    if (!state.initialLoaded) return;\n\n    if (state.inputValue === \"\") {\n      dispatch({ type: \"RESET_OPTIONS\" });\n\n      return;\n    }\n\n    dispatch({ type: \"SET_LOADING\", payload: true });\n\n    const payload: AsyncSelect2Payload = {\n      query: state.inputValue,\n      initialValues: null,\n    };\n\n    debouncedFetch(payload);\n  }, [state.inputValue, state.initialLoaded, debouncedFetch]);\n\n  const handleChange = useCallback(\n    (event: React.SyntheticEvent, newValue: Option2Item[]) => {\n      dispatch({ type: \"SET_SELECTED_OPTIONS\", payload: newValue });\n      field.onChange(newValue.map((option) => option.value));\n    },\n    [field]\n  );\n\n  const handleInputChange = useCallback(\n    (event: React.SyntheticEvent, newInputValue: string) => {\n      dispatch({ type: \"SET_INPUT_VALUE\", payload: newInputValue });\n    },\n    []\n  );\n\n  const isOptionEqualToValue = useCallback(\n    (option: Option2Item, value: Option2Item) => option.value === value.value,\n    []\n  );\n\n  const getOptionLabel = useCallback((option: Option2Item) => option.label, []);\n\n  const defaultRenderInput = useCallback(\n    (params: Parameters<Required<AsyncMultiSelect2Props>[\"renderInput\"]>[0]) => (\n      <TextField\n        {...params}\n        label={label}\n        placeholder={placeholder}\n        variant={variant}\n        error={!!error}\n        helperText={error?.message}\n        slotProps={{\n          input: {\n            ...params.InputProps,\n            endAdornment: (\n              <>\n                {state.loading && <CircularProgress color=\"inherit\" size={20} />}\n                {params.InputProps.endAdornment}\n              </>\n            ),\n          },\n        }}\n        sx={{\n          \"& .MuiInputBase-input\": {\n            cursor: disabled ? \"not-allowed\" : \"default\",\n          },\n          bgcolor: disabled\n            ? theme.palette.action.disabledBackground\n            : \"transparent\",\n          ...sx,\n        }}\n      />\n    ),\n    [label, placeholder, variant, error, state.loading, disabled, theme.palette.action.disabledBackground, sx]\n  );\n\n  return (\n    <Autocomplete\n      multiple\n      options={state.options}\n      value={state.selectedOptions}\n      loading={state.loading}\n      disabled={disabled}\n      isOptionEqualToValue={isOptionEqualToValue}\n      getOptionLabel={getOptionLabel}\n      filterSelectedOptions\n      onChange={handleChange}\n      onInputChange={handleInputChange}\n      loadingText={loadingText}\n      noOptionsText={noOptionsText}\n      renderInput={renderInput || defaultRenderInput}\n      {...rest}\n    />\n  );\n};\n\nconst AsyncMultiSelect2 = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>\n>({\n  gridProps,\n  ...props\n}: AsyncMultiSelect2Props<TFieldValues, TName>) => {\n  if (gridProps) {\n    return (\n      <Grid {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}>\n        <AsyncMultiSelect2Component {...props} />\n      </Grid>\n    );\n  }\n\n  return <AsyncMultiSelect2Component {...props} />;\n};\n\nAsyncMultiSelect2.displayName = \"AsyncMultiSelect2\";\n\nexport { AsyncMultiSelect2 };\n","import {\n  Checkbox,\n  FormControl,\n  FormControlLabel,\n  FormGroup,\n  FormHelperText,\n  Grid,\n  useTheme,\n} from \"@mui/material\";\nimport type { ReactNode } from \"react\";\nimport React from \"react\";\nimport type {\n  FieldPath,\n  FieldValues,\n  PathValue\n} from \"react-hook-form\";\nimport {\n  useController,\n} from \"react-hook-form\";\n\nimport { useTransform } from \"../../hooks/useTransform\";\n\nimport type { CheckboxElementProps } from \"./types\";\n\nconst Component = function CheckboxElement<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n>(\n  props: CheckboxElementProps<TFieldValues, TName>\n) {\n  const {\n    name,\n    control,\n    label,\n    labelProps,\n    helperText,\n    parseError,\n    transform,\n    disabled,\n    sx,\n    onChange: customOnChange,\n    ...rest\n  } = props;\n\n  const theme = useTheme();\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n    disabled,\n  });\n\n  const { value, onChange } = useTransform<TFieldValues, TName, boolean>({\n    value: field.value,\n    onChange: field.onChange,\n    transform: {\n      input:\n        typeof transform?.input === \"function\"\n          ? transform.input\n          : (value) => !!value,\n      output:\n        typeof transform?.output === \"function\"\n          ? (eventOrValue, _value) => {\n              // Adapter: Extract event and checked from the checkbox onChange signature\n              // CheckboxElement passes (event, checked), but useTransform expects (eventOrValue, value)\n              const event = eventOrValue as React.ChangeEvent<HTMLInputElement>;\n              const checked = _value as unknown as boolean;\n              return transform.output!(event, checked);\n            }\n          : (eventOrValue, _value) => {\n              // Default: extract checked state from the second parameter\n              const checked = _value as unknown as boolean;\n              return checked as PathValue<TFieldValues, TName>;\n            },\n    },\n  });\n\n  const handleChange = (event: React.ChangeEvent<HTMLInputElement>, checked: boolean) => {\n    onChange(event, checked);\n    if (typeof customOnChange === \"function\") {\n      customOnChange(event, checked);\n    }\n  };\n\n  const displayError: ReactNode = error\n    ? typeof parseError === \"function\"\n      ? parseError(error)\n      : error.message\n    : null;\n\n  return (\n    <FormControl error={!!error} disabled={disabled}>\n      <FormGroup row>\n        <FormControlLabel\n          label={label || \"\"}\n          {...labelProps}\n          disabled={disabled}\n          control={\n            <Checkbox\n              {...rest}\n              color={rest.color || \"primary\"}\n              sx={[\n                ...(Array.isArray(sx) ? sx : [sx]),\n                {\n                  color: error\n                    ? theme.palette.error.main\n                    : disabled\n                      ? theme.palette.action.disabled\n                      : undefined,\n                  \"&.Mui-disabled\": {\n                    color: theme.palette.action.disabled,\n                  },\n                },\n              ]}\n              checked={value}\n              disabled={disabled}\n              onChange={handleChange}\n              ref={field.ref}\n            />\n          }\n        />\n      </FormGroup>\n      {(displayError || helperText) && (\n        <FormHelperText error={!!error}>\n          {displayError || helperText}\n        </FormHelperText>\n      )}\n    </FormControl>\n  );\n};\n\n/**\n * A react-hook-form integrated Checkbox component with automatic validation and grid layout.\n *\n * This component provides a fully integrated checkbox input that works seamlessly with react-hook-form,\n * including automatic validation, error handling, value transformation, and optional Grid wrapper for responsive layouts.\n *\n * Features:\n * - Full react-hook-form integration with useController\n * - Automatic error display with custom parsing support\n * - Value transformation with useTransform hook for boolean values\n * - Customizable label and positioning\n * - Grid layout wrapper with responsive design\n * - TypeScript type safety with generic constraints\n * - Disabled state support with proper theming\n * - Helper text support for additional context\n * - Custom error parsing for internationalization\n * - Simple boolean value handling with optional custom transforms\n *\n * @example\n * Basic usage:\n * ```tsx\n * <CheckboxElement\n *   control={control}\n *   name=\"acceptTerms\"\n *   label=\"I agree to the terms and conditions\"\n * />\n * ```\n *\n * @example\n * With validation and helper text:\n * ```tsx\n * <CheckboxElement\n *   control={control}\n *   name=\"newsletter\"\n *   label=\"Subscribe to newsletter\"\n *   helperText=\"You can unsubscribe at any time\"\n *   rules={{ required: 'Please accept to continue' }}\n * />\n * ```\n *\n * @example\n * Custom grid layout and styling:\n * ```tsx\n * <CheckboxElement\n *   control={control}\n *   name=\"isPublic\"\n *   label=\"Make this public\"\n *   gridProps={{ size: { xs: 12, md: 6 } }}\n *   labelProps={{ sx: { fontWeight: 'bold' } }}\n *   sx={{ color: 'primary.main' }}\n * />\n * ```\n *\n * @example\n * With value transformation (string to boolean):\n * ```tsx\n * <CheckboxElement\n *   control={control}\n *   name=\"status\"\n *   label=\"Active\"\n *   transform={{\n *     input: (value) => value === 'active',\n *     output: (checked) => checked ? 'active' : 'inactive'\n *   }}\n * />\n * ```\n *\n * @example\n * Simple boolean field:\n * ```tsx\n * <CheckboxElement\n *   control={control}\n *   name=\"isEnabled\"\n *   label=\"Enable feature\"\n * />\n * ```\n *\n * @example\n * Custom error parsing for internationalization:\n * ```tsx\n * <CheckboxElement\n *   control={control}\n *   name=\"terms\"\n *   label=\"Accept Terms\"\n *   parseError={(error) => t(`validation.${error.type}`, { field: 'Terms' })}\n * />\n * ```\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n *\n * @param props - Component props\n * @returns React element with optional Grid wrapper\n *\n * @public\n */\nconst CheckboxElement = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n>({\n  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n  ...props\n}: CheckboxElementProps<TFieldValues, TName>) => {\n  if (gridProps) {\n    return (\n      <Grid\n        {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}\n      >\n        <Component<TFieldValues, TName> {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component<TFieldValues, TName> {...props} />;\n};\n\nCheckboxElement.displayName = \"CheckboxElement\";\n\nexport { CheckboxElement };\n\nexport type { CheckboxElementProps } from \"./types\";\n","import type {\n  CheckboxProps,\n  FormControlLabelProps,\n  GridProps\n} from \"@mui/material\";\nimport {\n  Checkbox,\n  FormControl,\n  FormControlLabel,\n  FormGroup,\n  FormHelperText,\n  Grid,\n} from \"@mui/material\";\nimport type { ChangeEvent } from \"react\";\nimport React, { useEffect, useState } from \"react\";\nimport type {\n  Control,\n  FieldPath,\n  FieldValues\n} from \"react-hook-form\";\nimport {\n  useController,\n} from \"react-hook-form\";\n\nexport type CheckboxGroupProps<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends number[] = number[]\n> = Omit<CheckboxProps, \"name\"> & {\n  name: TName;\n  control?: Control<TFieldValues>;\n  label?: FormControlLabelProps[\"label\"];\n  labelProps?: Omit<FormControlLabelProps, \"label\" | \"control\">;\n  gridProps?: GridProps;\n  options: Array<{ Value: number; Label: string }>;\n};\n\nconst Component = function CheckboxGroup<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends number[] = number[]\n>(props: CheckboxGroupProps<TFieldValues, TName, TValue>) {\n  const { name, control, label, labelProps, inputRef, options, ...rest } =\n    props;\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n    disabled: rest.disabled,\n  });\n\n  const [selectedValues, setSelectedValues] = useState<number[]>(\n    options.filter((c) => field.value?.includes(c.Value)).map((c) => c.Value) ||\n    []\n  );\n\n  useEffect(() => {\n    field.onChange(selectedValues ? [...selectedValues] : []);\n  }, [selectedValues]);\n\n  const handleChange = (event: ChangeEvent<HTMLInputElement>) => {\n    const value = parseInt(event.target.value, 10);\n\n    if (event.target.checked) {\n      setSelectedValues([...selectedValues, value]);\n    } else {\n      setSelectedValues(selectedValues.filter((item) => item !== value));\n    }\n  };\n\n  return (\n    <FormControl error={!!error}>\n      <FormGroup row>\n        {options.map((option) => (\n          <FormControlLabel\n            key={`${option.Value}`}\n            label={option.Label}\n            {...labelProps}\n            control={\n              <Checkbox\n                {...rest}\n                color={rest.color || \"primary\"}\n                sx={[\n                  ...(Array.isArray(rest.sx) ? rest.sx : [rest.sx]),\n                  {\n                    color: error ? \"error.main\" : undefined,\n                  },\n                ]}\n                value={option.Value}\n                checked={selectedValues.includes(option.Value)}\n                onChange={handleChange}\n              />\n            }\n          />\n        ))}\n      </FormGroup>\n      {error && (\n        <FormHelperText error={!!error}>{error.message}</FormHelperText>\n      )}\n    </FormControl>\n  );\n};\n\nconst CheckboxGroup = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends number[] = number[]\n>({\n  gridProps,\n  ...props\n}: CheckboxGroupProps<TFieldValues, TName, TValue>) => {\n  if (gridProps) {\n    return (\n      <Grid {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}>\n        <Component {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component {...props} />;\n};\n\nCheckboxGroup.displayName = \"CheckboxGroup\";\n\nexport { CheckboxGroup };\n\n","import { Grid } from \"@mui/material\";\nimport type {\n  PickerValidDate,\n} from \"@mui/x-date-pickers\";\nimport React, { forwardRef } from \"react\";\nimport type {\n  FieldValues,\n  FieldPath,\n} from \"react-hook-form\";\n\nimport { DatePickerElementCore } from \"./DatePickerElementCore\";\nimport type { DatePickerElementProps } from \"./types\";\n\n/**\n * A fully-featured, type-safe DatePickerElement component for react-hook-form integration.\n *\n * This component combines the core date picker functionality with optional Grid layout wrapping,\n * providing a complete solution for form-based date selection with comprehensive TypeScript support.\n *\n * Key Features:\n * - 🎯 **Type Safety**: Full TypeScript inference for form field types and date values\n * - 🔧 **React Hook Form Integration**: Seamless integration with react-hook-form validation\n * - 🎨 **Theming**: Automatic adaptation to MUI theme with customizable styles\n * - ♿ **Accessibility**: WCAG-compliant with proper ARIA attributes and keyboard navigation\n * - 🚀 **Performance**: Optimized with memoization and efficient re-rendering\n * - 📱 **Responsive**: Built-in Grid layout with configurable breakpoints\n * - 🛡️ **Validation**: Comprehensive validation with custom error messages\n * - 🔄 **Transformation**: Flexible value transformation between form and picker formats\n * - 📚 **Developer Experience**: Rich TypeScript IntelliSense and comprehensive documentation\n *\n * @example\n * Basic usage with automatic Grid wrapper:\n * ```tsx\n * import { useForm } from 'react-hook-form';\n * import { DatePickerElement } from '@gnwebsoft/ui/wrappers';\n *\n * function MyForm() {\n *   const { control } = useForm<{ birthDate: string }>();\n *\n *   return (\n *     <DatePickerElement\n *       name=\"birthDate\"\n *       control={control}\n *       label=\"Date of Birth\"\n *       required\n *     />\n *   );\n * }\n * ```\n *\n * @example\n * Advanced usage with custom transformation and validation:\n * ```tsx\n * function AdvancedForm() {\n *   const { control } = useForm<{ startDate: Date }>();\n *\n *   return (\n *     <DatePickerElement\n *       name=\"startDate\"\n *       control={control}\n *       label=\"Project Start Date\"\n *       transform={{\n *         input: (dateString) => dateString ? new Date(dateString) : null,\n *         output: (date) => date ? date.toISOString() : null\n *       }}\n *       validation={{\n *         minDate: new Date(),\n *         maxDate: addYears(new Date(), 2),\n *         errorMessages: {\n *           minDate: 'Start date must be today or later',\n *           maxDate: 'Start date cannot be more than 2 years in the future'\n *         }\n *       }}\n *       gridProps={{ size: { xs: 12, md: 6 } }}\n *       sx={{\n *         '& .MuiInputLabel-root': {\n *           fontWeight: 'bold'\n *         }\n *       }}\n *     />\n *   );\n * }\n * ```\n *\n * @example\n * Without Grid wrapper for custom layouts:\n * ```tsx\n * function CustomLayout() {\n *   const { control } = useForm<{ eventDate: string }>();\n *\n *   return (\n *     <Box display=\"flex\" gap={2}>\n *       <DatePickerElement\n *         name=\"eventDate\"\n *         control={control}\n *         label=\"Event Date\"\n *         gridProps={false} // Disables Grid wrapper\n *       />\n *       <Button type=\"submit\">Submit</Button>\n *     </Box>\n *   );\n * }\n * ```\n *\n * @example\n * With loading state and custom error handling:\n * ```tsx\n * function LoadingForm() {\n *   const { control } = useForm();\n *   const [isValidating, setIsValidating] = useState(false);\n *\n *   return (\n *     <DatePickerElement\n *       name=\"appointmentDate\"\n *       control={control}\n *       label=\"Appointment Date\"\n *       loading={isValidating}\n *       LoadingComponent={() => <CircularProgress size={20} />}\n *       parseError={(error) => {\n *         if (typeof error === 'object' && error?.type === 'custom') {\n *           return 'This date conflicts with another appointment';\n *         }\n *         return error.message || 'Please select a valid date';\n *       }}\n *     />\n *   );\n * }\n * ```\n *\n * @template TFieldValues - The form values type (inferred from control)\n * @template TName - The field name type (inferred from name prop)\n * @template TValue - The transformed value type (inferred from transform functions)\n * @template TEnableAccessibleFieldDOMStructure - Whether accessible field DOM structure is enabled\n *\n * @param props - Component props with full TypeScript inference\n * @param ref - Forward ref for the root element (Grid or DatePicker container)\n * @returns Rendered DatePickerElement component with optional Grid wrapper\n */\nconst DatePickerElement = forwardRef<\n  HTMLDivElement,\n  DatePickerElementProps<any, any, any, any>\n>(<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends PickerValidDate = PickerValidDate,\n  TEnableAccessibleFieldDOMStructure extends boolean = false,\n>(\n  props: DatePickerElementProps<TFieldValues, TName, TValue, TEnableAccessibleFieldDOMStructure>,\n  ref: React.Ref<HTMLDivElement>\n) => {\n  const {\n    gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n    ...coreProps\n  } = props;\n\n  // If gridProps is explicitly false, render without Grid wrapper\n  if (gridProps === false) {\n    return (\n      <DatePickerElementCore\n        ref={ref}\n        {...coreProps}\n      />\n    );\n  }\n\n  // Render with Grid wrapper for responsive layout\n  return (\n    <Grid\n      ref={ref}\n      {...gridProps}\n    >\n      <DatePickerElementCore\n        {...coreProps}\n      />\n    </Grid>\n  );\n});\n\n// Set display name for React Developer Tools\nDatePickerElement.displayName = \"DatePickerElement\";\n\nexport { DatePickerElement };\n\nexport default DatePickerElement;\n","import { useForkRef } from \"@mui/material\";\nimport { DatePicker } from \"@mui/x-date-pickers\";\nimport type {\n  DateValidationError,\n  PickerChangeHandlerContext,\n  PickerValidDate,\n} from \"@mui/x-date-pickers\";\nimport React, { forwardRef, useCallback, useMemo } from \"react\";\nimport { useController } from \"react-hook-form\";\nimport type { FieldValues, FieldPath } from \"react-hook-form\";\n\nimport {\n  useDatePickerValue,\n  useDatePickerValidation,\n  useDatePickerStyles,\n} from \"./hooks\";\nimport type { DatePickerElementCoreProps } from \"./types\";\n\n/**\n * The core DatePickerElement component without Grid wrapper.\n *\n * This is a lightweight, performant date picker component that integrates seamlessly\n * with react-hook-form while providing comprehensive TypeScript support and\n * accessibility features.\n *\n * Features:\n * - Full TypeScript inference for form field types\n * - Automatic value transformation between form and picker formats\n * - Comprehensive validation with custom error messages\n * - Theme-aware styling with accessibility support\n * - Performance optimized with proper memoization\n * - Forward ref support for advanced use cases\n *\n * @example\n * Basic usage:\n * ```tsx\n * <DatePickerElementCore\n *   name=\"birthDate\"\n *   control={control}\n *   label=\"Date of Birth\"\n *   required\n * />\n * ```\n *\n * @example\n * With custom transformation:\n * ```tsx\n * <DatePickerElementCore\n *   name=\"startDate\"\n *   control={control}\n *   label=\"Start Date\"\n *   transform={{\n *     input: (dateString) => dateString ? new Date(dateString) : null,\n *     output: (date) => date ? date.toISOString() : null\n *   }}\n *   validation={{\n *     minDate: new Date(),\n *     errorMessages: {\n *       minDate: 'Start date must be today or later'\n *     }\n *   }}\n * />\n * ```\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n * @template TEnableAccessibleFieldDOMStructure - Whether accessible field DOM structure is enabled\n */\nconst DatePickerElementCore = forwardRef<\n  HTMLDivElement,\n  DatePickerElementCoreProps<any, any, any, any>\n>(<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends PickerValidDate = PickerValidDate,\n  TEnableAccessibleFieldDOMStructure extends boolean = false,\n>(\n  props: DatePickerElementCoreProps<TFieldValues, TName, TValue, TEnableAccessibleFieldDOMStructure>,\n  ref: React.Ref<HTMLDivElement>\n) => {\n  const {\n    name,\n    required = false,\n    rules,\n    control,\n    parseError,\n    transform,\n    validation,\n    label,\n    placeholder,\n    textReadOnly = false,\n    helperText,\n    inputProps = {},\n    slotProps = {},\n    datePickerProps = {},\n    variant = \"outlined\",\n    sx: customSx,\n    loading = false,\n    LoadingComponent,\n    ...restProps\n  } = props;\n\n  // Extract DatePicker-specific props\n  const {\n    disabled,\n    inputRef: externalInputRef,\n    onClose,\n    ...restDatePickerProps\n  } = datePickerProps;\n\n  // Set up form controller\n  const {\n    field,\n    fieldState,\n  } = useController({\n    name,\n    control,\n    rules,\n    defaultValue: null as any, // Let react-hook-form handle the default value typing\n  });\n\n  // Value transformation hook\n  const { value, onChange: onValueChange } = useDatePickerValue({\n    field,\n    transform,\n  });\n\n  // Validation hook\n  const { hasError, errorMessage, invalid } = useDatePickerValidation({\n    fieldState,\n    validation,\n    parseError,\n    value,\n  });\n\n  // Styling hook\n  const { sx: computedSx, className } = useDatePickerStyles({\n    disabled,\n    hasError,\n    loading,\n    textReadOnly,\n    sx: customSx,\n  });\n\n  // Merge input refs\n  const handleInputRef = useForkRef(field.ref, externalInputRef);\n\n  // Memoized change handler to prevent unnecessary re-renders\n  const handleChange = useCallback(\n    (newValue: TValue | null, context: PickerChangeHandlerContext<DateValidationError>) => {\n      onValueChange(newValue, context);\n    },\n    [onValueChange]\n  );\n\n  // Memoized close handler\n  const handleClose = useCallback(\n    (...args: Parameters<NonNullable<typeof onClose>>) => {\n      // Trigger form field blur for validation\n      field.onBlur();\n\n      // Call external onClose if provided\n      if (onClose) {\n        onClose(...args);\n      }\n    },\n    [field.onBlur, onClose]\n  );\n\n  // Memoized blur handler for text field\n  const handleTextFieldBlur = useCallback(\n    (event: React.FocusEvent<HTMLInputElement>) => {\n      field.onBlur();\n\n      // Call external onBlur if provided\n      if (typeof inputProps.onBlur === \"function\") {\n        inputProps.onBlur(event);\n      }\n    },\n    [field.onBlur, inputProps.onBlur]\n  );\n\n  // Memoized slot props to prevent unnecessary re-renders\n  const memoizedSlotProps = useMemo(() => ({\n    ...slotProps,\n    actionBar: {\n      actions: [\"clear\", \"today\", \"cancel\", \"accept\"] as Array<\"accept\" | \"cancel\" | \"clear\" | \"next\" | \"nextOrAccept\" | \"today\">,\n      ...slotProps.actionBar,\n    },\n    textField: {\n      ...inputProps,\n      required,\n      placeholder,\n      fullWidth: true,\n      variant,\n      onBlur: handleTextFieldBlur,\n      error: hasError,\n      helperText: hasError ? errorMessage : helperText,\n      inputProps: {\n        readOnly: textReadOnly,\n        \"aria-invalid\": invalid,\n        \"aria-describedby\": hasError ? `${name}-error` : undefined,\n        ...inputProps.inputProps,\n      },\n      // Add loading indicator if provided\n      ...(loading && LoadingComponent && {\n        InputProps: {\n          endAdornment: <LoadingComponent />,\n          ...inputProps.InputProps,\n        },\n      }),\n      ...slotProps.textField,\n    },\n  }), [\n    slotProps,\n    inputProps,\n    required,\n    placeholder,\n    variant,\n    handleTextFieldBlur,\n    hasError,\n    errorMessage,\n    helperText,\n    textReadOnly,\n    invalid,\n    name,\n    loading,\n    LoadingComponent,\n  ]);\n\n  return (\n    <DatePicker\n      // Spread rest props first so they can be overridden\n      {...restProps}\n      {...restDatePickerProps}\n\n      // Core props\n      ref={ref}\n      name={name}\n      value={value}\n      onChange={handleChange}\n      onClose={handleClose}\n      inputRef={handleInputRef}\n\n      // UI props\n      label={label}\n      disabled={disabled}\n      sx={computedSx}\n      className={className}\n\n      // Slot props\n      slotProps={memoizedSlotProps}\n\n      // Accessibility props\n      aria-invalid={invalid}\n      aria-describedby={hasError ? `${name}-error` : undefined}\n    />\n  );\n});\n\n// Set display name for debugging\nDatePickerElementCore.displayName = \"DatePickerElementCore\";\n\nexport { DatePickerElementCore };\n\nexport default DatePickerElementCore;\n","import type {\n  PickerValidDate,\n  DateValidationError,\n  PickerChangeHandlerContext,\n} from \"@mui/x-date-pickers\";\nimport { useLocalizationContext } from \"@mui/x-date-pickers/internals\";\nimport { useCallback, useMemo } from \"react\";\nimport type {\n  FieldValues,\n  FieldPath,\n  PathValue,\n  UseControllerReturn,\n} from \"react-hook-form\";\n\nimport type { DateTransform } from \"../types\";\n\n/**\n * Type-safe date value reader that handles string to date conversion\n * @template TDate - The date type from the date adapter\n * @param adapter - The localization context from MUI date pickers\n * @param value - The value to convert (string, date, or null)\n * @returns Properly typed date value or null\n */\nexport function readDatePickerValueAsDate<TDate extends PickerValidDate>(\n  adapter: ReturnType<typeof useLocalizationContext>,\n  value: string | null | TDate | undefined\n): TDate | null {\n  if (value === null || value === undefined) {\n    return null;\n  }\n\n  if (typeof value === \"string\") {\n    if (value === \"\") {\n      return null;\n    }\n\n    // Use the adapter to parse the string into a date\n    const parsedDate = adapter.utils.date(value);\n\n    return parsedDate as TDate;\n  }\n\n  return value;\n}\n\n/**\n * Options for the useDatePickerValue hook\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n */\nexport interface UseDatePickerValueOptions<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends PickerValidDate = PickerValidDate,\n> {\n  /** The field controller from react-hook-form */\n  field: UseControllerReturn<TFieldValues, TName>[\"field\"];\n  /** Optional transformation functions */\n  transform?: DateTransform<TFieldValues, TName, TValue>;\n}\n\n/**\n * Return type for the useDatePickerValue hook\n * @template TValue - The transformed value type\n */\nexport interface UseDatePickerValueReturn<TValue extends PickerValidDate = PickerValidDate> {\n  /** The transformed value for display in the picker */\n  value: TValue | null;\n  /** Change handler for picker value updates */\n  onChange: (\n    value: TValue | null,\n    context: PickerChangeHandlerContext<DateValidationError>\n  ) => void;\n}\n\n/**\n * Hook for managing date picker value transformations with type safety\n * \n * This hook handles the conversion between form field values and date picker values,\n * applying custom transformations while maintaining strict TypeScript typing.\n * \n * @example\n * Basic usage with string to date conversion:\n * ```tsx\n * const { value, onChange } = useDatePickerValue({\n *   field,\n *   transform: {\n *     input: (dateString) => dateString ? new Date(dateString) : null,\n *     output: (date) => date ? date.toISOString() : null\n *   }\n * });\n * ```\n * \n * @example\n * Usage with Day.js dates:\n * ```tsx\n * const { value, onChange } = useDatePickerValue({\n *   field,\n *   transform: {\n *     input: (dateString) => dateString ? dayjs(dateString) : null,\n *     output: (date) => date ? date.format('YYYY-MM-DD') : null\n *   }\n * });\n * ```\n * \n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n * @param options - Configuration options for value transformation\n * @returns Object with transformed value and change handler\n */\nexport function useDatePickerValue<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends PickerValidDate = PickerValidDate,\n>(\n  options: UseDatePickerValueOptions<TFieldValues, TName, TValue>\n): UseDatePickerValueReturn<TValue> {\n  const { field, transform } = options;\n  const adapter = useLocalizationContext();\n\n  // Transform the field value for display in the picker\n  const value = useMemo((): TValue | null => {\n    if (typeof transform?.input === \"function\") {\n      return transform.input(field.value);\n    }\n    \n    // Default transformation: handle string to date conversion\n    return readDatePickerValueAsDate(adapter, field.value) as TValue | null;\n  }, [field.value, transform?.input, adapter]);\n\n  // Create a stable change handler\n  const onChange = useCallback(\n    (newValue: TValue | null, context: PickerChangeHandlerContext<DateValidationError>) => {\n      if (typeof transform?.output === \"function\") {\n        const transformedValue = transform.output(newValue, context);\n\n        field.onChange(transformedValue);\n      } else {\n        // Default transformation: store the date as-is\n        field.onChange(newValue as PathValue<TFieldValues, TName>);\n      }\n    },\n    [field.onChange, transform?.output]\n  );\n\n  return {\n    value,\n    onChange,\n  };\n}\n\nexport default useDatePickerValue;","import type {\n  PickerValidDate,\n  DateValidationError,\n} from \"@mui/x-date-pickers\";\nimport { useMemo } from \"react\";\nimport type { ReactNode } from \"react\";\nimport type {\n  FieldError,\n  FieldValues,\n  FieldPath,\n  UseControllerReturn,\n} from \"react-hook-form\";\n\nimport type { DatePickerValidationConfig } from \"../types\";\n\n/**\n * Options for the useDatePickerValidation hook\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n */\nexport interface UseDatePickerValidationOptions<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends PickerValidDate = PickerValidDate,\n> {\n  /** The field state from react-hook-form controller */\n  fieldState: UseControllerReturn<TFieldValues, TName>[\"fieldState\"];\n  /** Validation configuration for the date picker */\n  validation?: DatePickerValidationConfig<TValue>;\n  /** Custom error message parser */\n  parseError?: (error: FieldError | DateValidationError) => ReactNode;\n  /** The current date value for validation */\n  value?: TValue | null;\n}\n\n/**\n * Return type for the useDatePickerValidation hook\n */\nexport interface UseDatePickerValidationReturn {\n  /** Whether the field has any validation errors */\n  hasError: boolean;\n  /** The current validation error (form or date-specific) */\n  error: FieldError | DateValidationError | undefined;\n  /** Formatted error message for display */\n  errorMessage: ReactNode;\n  /** Whether the field is in an invalid state */\n  invalid: boolean;\n}\n\n/**\n * Default error messages for common date validation scenarios\n */\nconst DEFAULT_ERROR_MESSAGES = {\n  invalidDate: \"Please enter a valid date\",\n  minDate: \"Date must be after the minimum allowed date\",\n  maxDate: \"Date must be before the maximum allowed date\",\n  disabledDate: \"This date is not allowed\",\n  required: \"This field is required\",\n} as const;\n\n/**\n * Hook for managing date picker validation with comprehensive error handling\n * \n * This hook centralizes validation logic for date pickers, handling both\n * react-hook-form validation errors and date-specific validation errors\n * from MUI date pickers.\n * \n * @example\n * Basic usage with form validation:\n * ```tsx\n * const { hasError, errorMessage, invalid } = useDatePickerValidation({\n *   fieldState,\n *   validation: {\n *     minDate: dayjs().subtract(1, 'year'),\n *     maxDate: dayjs().add(1, 'year'),\n *     errorMessages: {\n *       minDate: 'Date must be within the last year',\n *       maxDate: 'Date cannot be more than 1 year in the future'\n *     }\n *   }\n * });\n * ```\n * \n * @example\n * Usage with custom error parser:\n * ```tsx\n * const { hasError, errorMessage } = useDatePickerValidation({\n *   fieldState,\n *   parseError: (error) => {\n *     if (typeof error === 'string') {\n *       return `Date Error: ${error}`;\n *     }\n *     return error.message || 'Invalid date';\n *   }\n * });\n * ```\n * \n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n * @param options - Validation configuration options\n * @returns Validation state and error information\n */\nexport function useDatePickerValidation<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends PickerValidDate = PickerValidDate,\n>(\n  options: UseDatePickerValidationOptions<TFieldValues, TName, TValue>\n): UseDatePickerValidationReturn {\n  const { fieldState, validation, parseError, value } = options;\n\n  // Memoize validation results for performance\n  const validationResult = useMemo(() => {\n    const { error: fieldError, invalid } = fieldState;\n    \n    // Start with form validation error\n    let currentError: FieldError | DateValidationError | undefined = fieldError;\n    \n    // Check date-specific validations if no form error and we have a value\n    if (!fieldError && value && validation) {\n      const { minDate, maxDate, shouldDisableDate, errorMessages } = validation;\n      \n      // Check minimum date\n      if (minDate && value < minDate) {\n        currentError = {\n          type: 'minDate',\n          message: errorMessages?.minDate || DEFAULT_ERROR_MESSAGES.minDate,\n        } as unknown as DateValidationError;\n      }\n      \n      // Check maximum date\n      else if (maxDate && value > maxDate) {\n        currentError = {\n          type: 'maxDate',\n          message: errorMessages?.maxDate || DEFAULT_ERROR_MESSAGES.maxDate,\n        } as unknown as DateValidationError;\n      }\n      \n      // Check disabled date\n      else if (shouldDisableDate && shouldDisableDate(value)) {\n        currentError = {\n          type: 'disabledDate',\n          message: errorMessages?.disabledDate || DEFAULT_ERROR_MESSAGES.disabledDate,\n        } as unknown as DateValidationError;\n      }\n    }\n    \n    const hasError = Boolean(currentError);\n    \n    return {\n      hasError,\n      error: currentError,\n      invalid: invalid || hasError,\n    };\n  }, [fieldState, validation, value]);\n\n  // Memoize error message formatting\n  const errorMessage = useMemo((): ReactNode => {\n    if (!validationResult.error) {\n      return null;\n    }\n\n    // Use custom error parser if provided\n    if (parseError) {\n      return parseError(validationResult.error);\n    }\n\n    // Default error message handling\n    if (typeof validationResult.error === 'string') {\n      return validationResult.error;\n    }\n\n    if ('message' in validationResult.error && validationResult.error.message) {\n      return validationResult.error.message;\n    }\n\n    // Fallback error messages based on error type\n    if ('type' in validationResult.error) {\n      const errorType = validationResult.error.type;\n\n      switch (errorType) {\n        case 'required':\n          return DEFAULT_ERROR_MESSAGES.required;\n        case 'minDate':\n          return DEFAULT_ERROR_MESSAGES.minDate;\n        case 'maxDate':\n          return DEFAULT_ERROR_MESSAGES.maxDate;\n        case 'disabledDate':\n          return DEFAULT_ERROR_MESSAGES.disabledDate;\n        case 'invalidDate':\n        default:\n          return DEFAULT_ERROR_MESSAGES.invalidDate;\n      }\n    }\n\n    return DEFAULT_ERROR_MESSAGES.invalidDate;\n  }, [validationResult.error, parseError]);\n\n  return {\n    ...validationResult,\n    errorMessage,\n  };\n}\n\nexport default useDatePickerValidation;","import type { SxProps, Theme } from \"@mui/material\";\nimport { useTheme } from \"@mui/material\";\nimport { useMemo } from \"react\";\n\n/**\n * Options for the useDatePickerStyles hook\n */\nexport interface UseDatePickerStylesOptions {\n  /** Whether the component is disabled */\n  disabled?: boolean;\n  /** Whether the component has a validation error */\n  hasError?: boolean;\n  /** Whether the component is in loading state */\n  loading?: boolean;\n  /** Whether the text input is read-only */\n  textReadOnly?: boolean;\n  /** Custom styles to merge with defaults */\n  sx?: SxProps<Theme>;\n}\n\n/**\n * Return type for the useDatePickerStyles hook\n */\nexport interface UseDatePickerStylesReturn {\n  /** Computed styles for the date picker component */\n  sx: SxProps<Theme>;\n  /** Additional class names for styling */\n  className?: string;\n}\n\n/**\n * Hook for managing theme-aware date picker styles with consistent design system integration\n * \n * This hook provides optimized, memoized styles for date picker components that automatically\n * adapt to the current MUI theme and component state (disabled, error, loading, etc.).\n * It ensures consistent styling across all date picker instances while allowing customization.\n * \n * @example\n * Basic usage:\n * ```tsx\n * const { sx } = useDatePickerStyles({\n *   disabled: isDisabled,\n *   hasError: !!error,\n *   loading: isLoading\n * });\n * \n * return <DatePicker sx={sx} ... />;\n * ```\n * \n * @example\n * With custom styles:\n * ```tsx\n * const { sx } = useDatePickerStyles({\n *   hasError: !!error,\n *   sx: {\n *     '& .MuiInputLabel-root': {\n *       color: 'primary.main'\n *     }\n *   }\n * });\n * ```\n * \n * @param options - Style configuration options\n * @returns Computed styles and class names\n */\nexport function useDatePickerStyles(\n  options: UseDatePickerStylesOptions = {}\n): UseDatePickerStylesReturn {\n  const { disabled, hasError, loading, textReadOnly, sx: customSx } = options;\n  const theme = useTheme();\n\n  // Memoize computed styles for performance\n  const computedSx = useMemo((): SxProps<Theme> => {\n    const baseStyles: SxProps<Theme> = {\n      // Input field styling\n      \"& .MuiOutlinedInput-root\": {\n        backgroundColor: disabled \n          ? theme.palette.action.disabledBackground \n          : \"transparent\",\n        \n        // Transition for smooth state changes\n        transition: theme.transitions.create([\n          'background-color',\n          'border-color',\n          'color'\n        ], {\n          duration: theme.transitions.duration.short,\n        }),\n\n        // Error state styling\n        ...(hasError && {\n          borderColor: theme.palette.error.main,\n          '&:hover': {\n            borderColor: theme.palette.error.main,\n          },\n          '&.Mui-focused': {\n            borderColor: theme.palette.error.main,\n            boxShadow: `0 0 0 2px ${theme.palette.error.main}25`, // 25 is 15% opacity in hex\n          },\n        }),\n\n        // Loading state styling\n        ...(loading && {\n          opacity: 0.7,\n          pointerEvents: 'none',\n        }),\n      },\n\n      // Input element styling\n      \"& .MuiInputBase-input\": {\n        cursor: disabled \n          ? \"not-allowed\" \n          : textReadOnly \n            ? \"pointer\" \n            : \"text\",\n        \n        // Read-only specific styling\n        ...(textReadOnly && !disabled && {\n          cursor: \"pointer\",\n          userSelect: \"none\",\n          caretColor: \"transparent\", // Hide text cursor in read-only mode\n        }),\n\n        // Loading state\n        ...(loading && {\n          cursor: \"wait\",\n        }),\n      },\n\n      // Required field asterisk styling\n      \"& .MuiInputLabel-asterisk\": { \n        color: theme.palette.error.main,\n        fontSize: \"1.2em\",\n      },\n\n      // Label styling with better contrast\n      \"& .MuiInputLabel-root\": {\n        color: hasError \n          ? theme.palette.error.main \n          : theme.palette.text.secondary,\n        \n        // Ensure proper contrast for disabled state\n        ...(disabled && {\n          color: theme.palette.text.disabled,\n        }),\n      },\n\n      // Helper text styling\n      \"& .MuiFormHelperText-root\": {\n        marginLeft: theme.spacing(1),\n        marginRight: theme.spacing(1),\n        \n        // Error state\n        ...(hasError && {\n          color: theme.palette.error.main,\n        }),\n      },\n\n      // Calendar icon styling\n      \"& .MuiInputAdornment-root\": {\n        color: disabled \n          ? theme.palette.action.disabled \n          : hasError \n            ? theme.palette.error.main \n            : theme.palette.action.active,\n      },\n\n      // Focus ring for accessibility\n      \"& .MuiOutlinedInput-root.Mui-focused\": {\n        outline: `2px solid ${theme.palette.primary.main}50`, // 50 is 31% opacity\n        outlineOffset: \"2px\",\n      },\n\n      // Enhanced contrast for dark themes\n      ...(theme.palette.mode === 'dark' && {\n        \"& .MuiOutlinedInput-root\": {\n          borderWidth: 2,\n        },\n      }),\n    };\n\n    // Merge with custom styles\n    return customSx ? [baseStyles, customSx] as SxProps<Theme> : baseStyles;\n  }, [\n    theme,\n    disabled,\n    hasError,\n    loading,\n    textReadOnly,\n    customSx,\n  ]);\n\n  // Generate additional class names for external styling hooks\n  const className = useMemo(() => {\n    const classes: string[] = [];\n    \n    if (disabled) classes.push('DatePickerElement--disabled');\n    if (hasError) classes.push('DatePickerElement--error');\n    if (loading) classes.push('DatePickerElement--loading');\n    if (textReadOnly) classes.push('DatePickerElement--readOnly');\n    \n    return classes.length > 0 ? classes.join(' ') : undefined;\n  }, [disabled, hasError, loading, textReadOnly]);\n\n  return {\n    sx: computedSx,\n    className,\n  };\n}\n\nexport default useDatePickerStyles;","import type { PickerValidDate } from \"@mui/x-date-pickers\";\nimport type { useLocalizationContext } from \"@mui/x-date-pickers/internals\";\nimport type { FieldValues, FieldPath, PathValue } from \"react-hook-form\";\n\n/**\n * Utility type for creating branded date types to prevent mixing different date formats\n * @template TDate - The base date type\n * @template TBrand - The brand string for type safety\n */\nexport type BrandedDate<TDate extends PickerValidDate, TBrand extends string> = \n  TDate & { readonly __brand: TBrand };\n\n/**\n * Type guard to check if a value is a valid date\n * @param value - The value to check\n * @returns True if the value is a valid date-like object\n */\nexport function isValidDate(value: unknown): value is PickerValidDate {\n  if (value === null || value === undefined) {\n    return false;\n  }\n\n  // Check for Date object\n  if (value instanceof Date) {\n    return !isNaN(value.getTime());\n  }\n\n  // Check for date-like objects with common date library methods\n  if (typeof value === 'object' && value !== null) {\n    // Day.js, Moment.js, or similar\n    if ('isValid' in value && typeof (value as any).isValid === 'function') {\n      return (value as any).isValid();\n    }\n    \n    // Luxon DateTime\n    if ('isValid' in value && typeof (value as any).isValid === 'boolean') {\n      return (value as any).isValid;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Type guard to check if a value is a string that can be parsed as a date\n * @param value - The value to check\n * @returns True if the value is a parseable date string\n */\nexport function isParsableDateString(value: unknown): value is string {\n  if (typeof value !== 'string' || value === '') {\n    return false;\n  }\n\n  // Basic ISO date format check\n  const isoDateRegex = /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{3})?(?:Z|[+-]\\d{2}:\\d{2})?)?$/;\n\n  if (isoDateRegex.test(value)) {\n    return true;\n  }\n\n  // Check if Date constructor can parse it\n  const parsed = new Date(value);\n\n  return !isNaN(parsed.getTime());\n}\n\n/**\n * Creates a type-safe date transformation function that converts form values to date picker values\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TDate - The date type used by the picker\n * @param adapter - The date adapter from MUI localization context\n * @returns A transformation function that safely converts form values to dates\n */\nexport function createDateInputTransform<\n  TFieldValues extends FieldValues,\n  TName extends FieldPath<TFieldValues>,\n  TDate extends PickerValidDate = PickerValidDate,\n>(adapter: ReturnType<typeof useLocalizationContext>) {\n  return (value: PathValue<TFieldValues, TName>): TDate | null => {\n    if (value === null || value === undefined) {\n      return null;\n    }\n\n    if (typeof value === 'string') {\n      if (value === '') {\n        return null;\n      }\n      \n      try {\n        const parsed = adapter.utils.date(value);\n\n        return isValidDate(parsed) ? (parsed as TDate) : null;\n      } catch {\n        return null;\n      }\n    }\n\n    if (isValidDate(value)) {\n      return value as TDate;\n    }\n\n    return null;\n  };\n}\n\n/**\n * Creates a type-safe date transformation function that converts date picker values back to form values\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TDate - The date type used by the picker\n * @param format - The format to use for string conversion (optional)\n * @returns A transformation function that safely converts dates to form values\n */\nexport function createDateOutputTransform<\n  TFieldValues extends FieldValues,\n  TName extends FieldPath<TFieldValues>,\n  TDate extends PickerValidDate = PickerValidDate,\n>(format?: string) {\n  return (value: TDate | null): PathValue<TFieldValues, TName> => {\n    if (value === null || value === undefined) {\n      return null as PathValue<TFieldValues, TName>;\n    }\n\n    if (!isValidDate(value)) {\n      return null as PathValue<TFieldValues, TName>;\n    }\n\n    // If no format specified, return the date as-is\n    if (!format) {\n      return value as PathValue<TFieldValues, TName>;\n    }\n\n    try {\n      // Handle different date library formats\n      if (value instanceof Date) {\n        if (format === 'iso') {\n          return value.toISOString() as PathValue<TFieldValues, TName>;\n        }\n\n        if (format === 'date-only') {\n          return value.toISOString().split('T')[0] as PathValue<TFieldValues, TName>;\n        }\n      }\n\n      // Day.js format\n      if (typeof (value as any).format === 'function') {\n        return (value as any).format(format) as PathValue<TFieldValues, TName>;\n      }\n\n      // Moment.js format\n      if (typeof (value as any).format === 'function') {\n        return (value as any).format(format) as PathValue<TFieldValues, TName>;\n      }\n\n      // Luxon format\n      if (typeof (value as any).toFormat === 'function') {\n        return (value as any).toFormat(format) as PathValue<TFieldValues, TName>;\n      }\n\n      // Fallback: return as-is\n      return value as PathValue<TFieldValues, TName>;\n    } catch {\n      return null as PathValue<TFieldValues, TName>;\n    }\n  };\n}\n\n/**\n * Utility function to create default date picker configuration\n * @template TDate - The date type\n * @returns Default configuration object\n */\nexport function createDefaultDatePickerConfig<TDate extends PickerValidDate = PickerValidDate>() {\n  return {\n    // Default slot props for consistent behavior\n    slotProps: {\n      actionBar: {\n        actions: ['clear', 'today', 'cancel', 'accept'] as const,\n      },\n      textField: {\n        fullWidth: true,\n        variant: 'outlined' as const,\n      },\n    },\n    \n    // Default grid props for layout consistency\n    gridProps: {\n      size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } as const,\n    },\n    \n    // Default validation configuration\n    validation: {\n      errorMessages: {\n        invalidDate: \"Please enter a valid date\",\n        minDate: \"Date must be after the minimum allowed date\",\n        maxDate: \"Date must be before the maximum allowed date\",\n        disabledDate: \"This date is not allowed\",\n      },\n    },\n  } as const;\n}\n\n/**\n * Utility to safely extract error message from various error types\n * @param error - The error object (could be from react-hook-form or MUI date picker)\n * @returns A user-friendly error message string\n */\nexport function extractErrorMessage(error: unknown): string {\n  if (error === null || error === undefined) {\n    return '';\n  }\n\n  if (typeof error === 'string') {\n    return error;\n  }\n\n  if (typeof error === 'object' && error !== null) {\n    // React Hook Form FieldError\n    if ('message' in error && typeof (error as any).message === 'string') {\n      return (error as any).message;\n    }\n\n    // MUI DateValidationError\n    if ('type' in error && typeof (error as any).type === 'string') {\n      const errorType = (error as any).type;\n\n      switch (errorType) {\n        case 'invalidDate':\n          return 'Please enter a valid date';\n        case 'minDate':\n          return 'Date is too early';\n        case 'maxDate':\n          return 'Date is too late';\n        case 'disabledDate':\n          return 'This date is not available';\n        default:\n          return 'Invalid date selection';\n      }\n    }\n  }\n\n  return 'Invalid input';\n}\n\n/**\n * Performance utility to create stable references for complex props\n * This helps prevent unnecessary re-renders when using complex configuration objects\n * @template T - The type of the configuration object\n * @param config - The configuration object\n * @returns A JSON string that can be used as a dependency in useMemo/useCallback\n */\nexport function createStableKey<T extends Record<string, unknown>>(config: T): string {\n  try {\n    return JSON.stringify(config, (key, value) => {\n      // Sort object keys for consistent serialization\n      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n        const sorted: Record<string, unknown> = {};\n\n        Object.keys(value).sort().forEach(k => {\n          sorted[k] = (value as any)[k];\n        });\n\n        return sorted;\n      }\n\n      return value;\n    });\n  } catch {\n    // Fallback for non-serializable objects\n    return Object.keys(config).sort().join('-');\n  }\n}","import Visibility from \"@mui/icons-material/Visibility\";\nimport VisibilityOff from \"@mui/icons-material/VisibilityOff\";\nimport type {\n  IconButtonProps,\n  TextFieldProps,\n  GridProps\n} from \"@mui/material\";\nimport {\n  IconButton,\n  InputAdornment,\n  TextField,\n  useForkRef,\n  Grid\n} from \"@mui/material\";\nimport type { MouseEvent, ReactNode } from \"react\";\nimport React, { useState } from \"react\";\nimport type {\n  Control,\n  FieldPath,\n  FieldValues\n} from \"react-hook-form\";\nimport {\n  useController,\n} from \"react-hook-form\";\n\n/**\n * Props for the PasswordElement component.\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The value type\n *\n * @public\n */\nexport type PasswordElementProps<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown\n> = Omit<TextFieldProps, \"name\"> & {\n  /**\n   * The field name in the form\n   * @example \"password\" | \"user.currentPassword\"\n   */\n  name: TName;\n  /**\n   * The form control instance from react-hook-form\n   */\n  control?: Control<TFieldValues>;\n  /**\n   * Color of the visibility toggle icon button\n   * @defaultValue \"default\"\n   */\n  iconColor?: IconButtonProps[\"color\"];\n  /**\n   * Custom render function for the visibility toggle icon\n   * @param password - Whether password is currently hidden\n   * @returns ReactNode to render as the icon\n   * @defaultValue Default visibility/visibility-off icons\n   */\n  renderIcon?: (password: boolean) => ReactNode;\n  /**\n   * Grid layout props for the wrapper Grid component\n   * @defaultValue { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } }\n   */\n  gridProps?: GridProps;\n};\n\ntype PasswordElementComponent = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>\n>(\n  props: PasswordElementProps<TFieldValues, TName>\n) => React.JSX.Element;\n\nconst Component = function PasswordEl<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown\n>(props: PasswordElementProps<TFieldValues, TName, TValue>) {\n  const {\n    type,\n    required,\n    iconColor,\n    renderIcon = (password) => (password ? <Visibility /> : <VisibilityOff />),\n    slotProps,\n    name,\n    control,\n    component: TextFieldComponent = TextField,\n    inputRef,\n    onBlur,\n    ...rest\n  } = props;\n\n  const [password, setPassword] = useState<boolean>(true);\n\n  const endAdornment = (\n    <InputAdornment position={\"end\"}>\n      <IconButton\n        onMouseDown={(e: MouseEvent<HTMLButtonElement>) => e.preventDefault()}\n        onClick={() => setPassword(!password)}\n        tabIndex={-1}\n        color={iconColor ?? \"default\"}\n      >\n        {renderIcon(password)}\n      </IconButton>\n    </InputAdornment>\n  );\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n  });\n\n  const handleInputRef = useForkRef(field.ref, inputRef);\n\n  return (\n    <TextField\n      {...rest}\n      inputRef={handleInputRef}\n      type={password ? \"password\" : \"text\"}\n      value={field.value}\n      fullWidth\n      onChange={(event) => {\n        // this will be a breaking change for anyone using transform.output\n        // because now we are passing event instead of event.target.value or +event.target.value\n        field.onChange(event);\n        if (typeof rest.onChange === \"function\") {\n          rest.onChange(event);\n        }\n      }}\n      onBlur={(event) => {\n        field.onBlur();\n        if (typeof onBlur === \"function\") {\n          onBlur(event);\n        }\n      }}\n      {...(typeof slotProps === \"undefined\"\n        ? {\n          InputProps: {\n            endAdornment,\n          },\n        }\n        : {\n          slotProps: {\n            ...slotProps,\n            input: {\n              endAdornment,\n              ...slotProps?.input,\n            },\n          } as TextFieldProps[\"slotProps\"],\n        })}\n      error={!!error}\n      helperText={error ? error.message : \"\"}\n    />\n  );\n};\n\n/**\n * A react-hook-form integrated password TextField with show/hide functionality.\n *\n * This component provides a fully integrated password input that works seamlessly with react-hook-form,\n * including automatic validation, error handling, and a built-in visibility toggle button. The password\n * can be shown or hidden by clicking the eye icon in the input's end adornment.\n *\n * Features:\n * - Full react-hook-form integration\n * - Password visibility toggle\n * - Automatic error display\n * - Customizable visibility icons\n * - Grid layout wrapper\n * - TypeScript type safety\n * - Disabled state support\n *\n * @example\n * Basic usage:\n * ```tsx\n * <PasswordElement\n *   control={control}\n *   name=\"password\"\n *   label=\"Password\"\n *   rules={{\n *     required: 'Password is required',\n *     minLength: { value: 8, message: 'Minimum 8 characters' }\n *   }}\n * />\n * ```\n *\n * @example\n * With custom icon color:\n * ```tsx\n * <PasswordElement\n *   control={control}\n *   name=\"confirmPassword\"\n *   label=\"Confirm Password\"\n *   iconColor=\"primary\"\n *   placeholder=\"Re-enter your password\"\n * />\n * ```\n *\n * @example\n * Custom grid layout:\n * ```tsx\n * <PasswordElement\n *   control={control}\n *   name=\"newPassword\"\n *   label=\"New Password\"\n *   gridProps={{ size: { xs: 12, md: 6 } }}\n *   renderIcon={(hidden) => hidden ? <CustomHideIcon /> : <CustomShowIcon />}\n * />\n * ```\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The value type\n *\n * @param props - Component props\n * @returns React element with optional Grid wrapper\n *\n * @public\n */\nconst PasswordElement = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown\n>({\n  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n  ...props\n}: PasswordElementProps<TFieldValues, TName, TValue>) => {\n  if (gridProps) {\n    return (\n      <Grid\n        {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}\n      >\n        <Component {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component {...props} />;\n};\n\nPasswordElement.displayName = \"PasswordElement\";\n\nexport default PasswordElement;\n","import type {\n  FormControlLabelProps,\n  FormLabelProps,\n  RadioGroupProps,\n  RadioProps,\n  GridProps\n} from \"@mui/material\";\nimport {\n  FormControl,\n  FormControlLabel,\n  FormHelperText,\n  FormLabel,\n  Radio,\n  RadioGroup,\n  useTheme,\n  Grid\n} from \"@mui/material\";\nimport type { ReactNode } from \"react\";\nimport React from \"react\";\nimport type {\n  Control,\n  FieldError,\n  FieldPath,\n  FieldValues,\n  PathValue,\n} from \"react-hook-form\";\nimport {\n  useController\n} from \"react-hook-form\";\n\nimport { useTransform } from \"../../hooks/useTransform\";\n\n// Type for primitive values that can be used as radio button values\ntype PrimitiveValue = string | number | boolean;\n\n// Constraint to ensure option objects have the required keys\ntype OptionObject<\n  TValueKey extends string = string,\n  TLabelKey extends string = string,\n  TDisabledKey extends string = string\n> = Record<TValueKey, PrimitiveValue> &\n  Record<TLabelKey, string> &\n  Partial<Record<TDisabledKey, boolean>> &\n  Record<string, unknown>;\n\nexport interface RadioButtonGroupProps<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TOption extends OptionObject<TValueKey, TLabelKey, TDisabledKey> = OptionObject,\n  TValueKey extends keyof TOption & string = \"id\",\n  TLabelKey extends keyof TOption & string = \"label\",\n  TDisabledKey extends keyof TOption & string = \"disabled\"\n> {\n  options: TOption[];\n  helperText?: ReactNode;\n  name: TName;\n  required?: boolean;\n  parseError?: (error: FieldError) => ReactNode;\n  label?: string;\n  labelKey?: TLabelKey;\n  valueKey?: TValueKey;\n  disabledKey?: TDisabledKey;\n  type?: \"number\" | \"string\" | \"boolean\";\n  emptyOptionLabel?: string;\n  onChange?: (value: TOption[TValueKey] | TOption | undefined) => void;\n  returnObject?: boolean;\n  row?: boolean;\n  control?: Control<TFieldValues>;\n  labelProps?: Omit<FormControlLabelProps, \"label\" | \"control\" | \"value\">;\n  formLabelProps?: Omit<FormLabelProps, \"required\" | \"error\">;\n  radioProps?: RadioProps;\n  disabled?: boolean;\n  transform?: {\n    input?: (value: PathValue<TFieldValues, TName>) => TOption[TValueKey];\n    output?: (\n      eventOrValue: import(\"../../types/events\").EventOrValue<PathValue<TFieldValues, TName>>,\n      value?: PathValue<TFieldValues, TName>\n    ) => PathValue<TFieldValues, TName>;\n  };\n  gridProps?: GridProps;\n}\n\nconst Component = function RadioButtonGroup<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TOption extends OptionObject<TValueKey, TLabelKey, TDisabledKey> = OptionObject,\n  TValueKey extends keyof TOption & string = \"id\",\n  TLabelKey extends keyof TOption & string = \"label\",\n  TDisabledKey extends keyof TOption & string = \"disabled\"\n>(props: RadioButtonGroupProps<TFieldValues, TName, TOption, TValueKey, TLabelKey, TDisabledKey>) {\n  const {\n    options,\n    label,\n    name,\n    labelKey = \"label\" as TLabelKey,\n    valueKey = \"id\" as TValueKey,\n    disabledKey = \"disabled\" as TDisabledKey,\n    required,\n    emptyOptionLabel,\n    returnObject,\n    row,\n    control,\n    type,\n    labelProps,\n    disabled,\n    formLabelProps,\n    radioProps,\n    transform,\n    ...rest\n  } = props;\n  const theme = useTheme();\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    disabled,\n    control,\n  });\n\n  const { value, onChange } = useTransform<\n    TFieldValues,\n    TName,\n    TOption[TValueKey] | TOption\n  >({\n    value: field.value,\n    onChange: field.onChange,\n    transform: {\n      input:\n        typeof transform?.input === \"function\"\n          ? transform.input\n          : (value) => {\n            return value || (\"\" as TOption[TValueKey]);\n          },\n      output:\n        typeof transform?.output === \"function\"\n          ? transform?.output\n          : (_event, value) => {\n            if (value && type === \"number\") {\n              return Number(value) as PathValue<TFieldValues, TName>;\n            }\n\n            if (value && type === \"boolean\") {\n              return Boolean(value) as PathValue<TFieldValues, TName>;\n            }\n\n            return value as PathValue<TFieldValues, TName>;\n          },\n    },\n  });\n\n  const onRadioChange: RadioGroupProps[\"onChange\"] = (event, radioValue) => {\n    const returnValue = returnObject\n      ? (options as TOption[]).find((option) => option[valueKey] === radioValue)\n      : radioValue as TOption[TValueKey];\n\n    onChange(event, returnValue);\n    if (typeof rest.onChange === \"function\") {\n      rest.onChange(returnValue);\n    }\n  };\n\n  return (\n    <FormControl error={!!error}>\n      {label && (\n        <FormLabel {...formLabelProps} required={required} error={!!error}>\n          {label}\n        </FormLabel>\n      )}\n      <RadioGroup onChange={onRadioChange} name={name} row={row} value={value}>\n        {emptyOptionLabel && (\n          <FormControlLabel\n            {...labelProps}\n            control={\n              <Radio\n                {...radioProps}\n                sx={{\n                  color: error ? theme.palette.error.main : undefined,\n                }}\n                checked={!value}\n              />\n            }\n            label={emptyOptionLabel}\n            value=\"\"\n          />\n        )}\n        {options.map((option) => {\n          const optionKey = option[valueKey];\n          const optionDisabled = option[disabledKey] || false;\n          let val: TOption[TValueKey] | undefined = returnObject\n            ? (value as TOption)?.[valueKey]\n            : value as TOption[TValueKey];\n\n          if (type === \"number\" && val !== undefined) {\n            val = Number(val) as TOption[TValueKey];\n          } else if (type === \"boolean\" && val !== undefined) {\n            val = Boolean(val) as TOption[TValueKey];\n          }\n\n          const isChecked = val === optionKey;\n\n          return (\n            <FormControlLabel\n              key={String(optionKey)}\n              {...labelProps}\n              control={\n                <Radio\n                  {...radioProps}\n                  sx={{\n                    color: error ? theme.palette.error.main : undefined,\n                  }}\n                  disabled={disabled || optionDisabled}\n                  checked={isChecked}\n                />\n              }\n              value={optionKey}\n              label={option[labelKey]}\n            />\n          );\n        })}\n      </RadioGroup>\n      {error && <FormHelperText>{error.message}</FormHelperText>}\n    </FormControl>\n  );\n};\n\nconst RadioButtonGroup = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TOption extends OptionObject<TValueKey, TLabelKey, TDisabledKey> = OptionObject,\n  TValueKey extends keyof TOption & string = \"id\",\n  TLabelKey extends keyof TOption & string = \"label\",\n  TDisabledKey extends keyof TOption & string = \"disabled\"\n>({\n  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n  ...props\n}: RadioButtonGroupProps<TFieldValues, TName, TOption, TValueKey, TLabelKey, TDisabledKey>) => {\n  if (gridProps) {\n    return (\n      <Grid\n        {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}\n      >\n        <Component<TFieldValues, TName, TOption, TValueKey, TLabelKey, TDisabledKey> {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component<TFieldValues, TName, TOption, TValueKey, TLabelKey, TDisabledKey> {...props} />;\n};\n\nRadioButtonGroup.displayName = \"RadioButtonGroup\";\n\nexport default RadioButtonGroup;\n","import {\n  Grid,\n  useTheme,\n  TextField,\n  type SxProps,\n  Autocomplete,\n  type GridProps,\n  type ChipTypeMap,\n  type TextFieldProps,\n  type TextFieldVariants,\n  type AutocompleteProps,\n} from '@mui/material';\nimport type { JSX } from 'react';\nimport { useRef, useState, useEffect, useCallback } from 'react';\nimport {\n  type Control,\n  useController,\n  type FieldPath,\n  type FieldValues,\n  type UseControllerProps,\n} from 'react-hook-form';\n\nexport type SelectCascadeElementProps<\n  TOption,\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  Multiple extends boolean | undefined = false,\n  DisableClearable extends boolean | undefined = false,\n  FreeSolo extends boolean | undefined = false,\n  ChipComponent extends React.ElementType = ChipTypeMap['defaultComponent'],\n> = Omit<\n  AutocompleteProps<TOption, Multiple, DisableClearable, FreeSolo, ChipComponent>,\n  'name' | 'renderInput' | 'isOptionEqualToValue' | 'getOptionLabel' | 'disabled'\n> & {\n  rules?: UseControllerProps<TFieldValues, TName>['rules'];\n  name: TName;\n  dependsOn: TName;\n  control?: Control<TFieldValues>;\n  gridProps?: GridProps;\n  placeholder?: string;\n  label?: string;\n  variant?: TextFieldVariants;\n  disabled?: boolean;\n  sx?: SxProps;\n  isEdit?: boolean;\n  labelKey?: keyof TOption;\n  valueKey?: keyof TOption;\n  textFieldProps?: Omit<TextFieldProps, 'name'>;\n};\n\ntype SelectCascadeElementComponent = <\n  TOption,\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  Multiple extends boolean | undefined = false,\n  DisableClearable extends boolean | undefined = false,\n  FreeSolo extends boolean | undefined = false,\n  ChipComponent extends React.ElementType = ChipTypeMap['defaultComponent'],\n>(\n  props: SelectCascadeElementProps<\n    TOption,\n    TFieldValues,\n    TName,\n    Multiple,\n    DisableClearable,\n    FreeSolo,\n    ChipComponent\n  >\n) => React.JSX.Element;\n\nconst Component = function SelectCascadeElement<\n  TOption,\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n>(props: SelectCascadeElementProps<TOption, TFieldValues, TName>) {\n  const {\n    labelKey = 'Label',\n    valueKey = 'Value',\n    name,\n    onBlur,\n    onChange,\n    disabled,\n    options,\n    control,\n    loading = false,\n    placeholder,\n    label,\n    dependsOn,\n    textFieldProps = {},\n    variant,\n    sx,\n    isEdit = false,\n    ...rest\n  } = props;\n\n  const { required } = textFieldProps;\n\n  const getOptionKey = useCallback(\n    (option: TOption): string | number => {\n      if (typeof option === 'string' || typeof option === 'number') return option;\n      const key = option ? option[valueKey as keyof TOption] : undefined;\n\n      return key !== undefined && key !== null ? String(key) : '';\n    },\n    [valueKey]\n  );\n\n  const getOptionLabel = useCallback(\n    (option: TOption) => {\n      if (typeof option === 'string') return option;\n\n      return option ? String(option[labelKey as keyof TOption]) : '';\n    },\n    [labelKey]\n  );\n\n  const isOptionEqualToValue = (option: TOption, value: TOption) =>\n    getOptionKey(option) === getOptionKey(value);\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n  });\n\n  const theme = useTheme();\n\n  const { field: dependentField } = useController({\n    name: dependsOn,\n    control,\n  });\n\n  const parentValueRef = useRef<TOption>(dependentField.value ?? null);\n  const [hasAutoSelected, setHasAutoSelected] = useState(false);\n\n  useEffect(() => {\n    if (\n      (!!dependentField.value && parentValueRef?.current !== dependentField.value) ||\n      dependentField.value === null\n    ) {\n      field.onChange(null);\n      setHasAutoSelected(false);\n    }\n  }, [dependentField.value]);\n\n  useEffect(() => {\n    if (isEdit && !disabled && options.length === 1 && field.value == null && !hasAutoSelected) {\n      field.onChange(getOptionKey(options[0]));\n      setHasAutoSelected(true);\n    } else {\n      if (options.length === 1 && field.value == null && !hasAutoSelected) {\n        field.onChange(getOptionKey(options[0]));\n        setHasAutoSelected(true);\n      }\n    }\n  }, [\n    options,\n    field.value,\n    field.onChange,\n    hasAutoSelected,\n    isEdit,\n    disabled,\n    field,\n    getOptionKey,\n    dependentField.onChange,\n  ]);\n\n  return (\n    <Autocomplete\n      {...rest}\n      value={\n        options\n          .map((option) => (getOptionKey(option) === field.value ? option : null))\n          .find(Boolean) || null\n      }\n      size=\"small\"\n      loading={loading}\n      options={options}\n      getOptionKey={getOptionKey}\n      getOptionLabel={getOptionLabel}\n      isOptionEqualToValue={isOptionEqualToValue}\n      ref={field.ref}\n      disabled={dependentField.value == null || disabled}\n      onChange={(event, newValue, reason) => {\n        field.onChange(newValue ? getOptionKey(newValue) : null);\n        if (onChange && typeof onChange === 'function') {\n          onChange(event, newValue, reason);\n        }\n      }}\n      onBlur={(event) => {\n        field.onBlur();\n        if (typeof onBlur === 'function') {\n          onBlur(event);\n        }\n      }}\n      fullWidth\n      renderInput={(params) => (\n        // @ts-ignore\n        <TextField\n          {...params}\n          fullWidth\n          error={!!error}\n          required={required}\n          helperText={error ? error.message : ''}\n          placeholder={placeholder}\n          label={label}\n          variant={variant ? variant : 'outlined'}\n          // @ts-ignore\n          sx={{\n            '& .MuiOutlinedInput-root': {\n              bgcolor:\n                disabled || dependentField.value == null\n                  ? theme.palette.action.disabledBackground\n                  : 'transparent',\n            },\n            '& .MuiInputLabel-asterisk': { color: 'red' },\n            '& .MuiInputBase-input': {\n              cursor: disabled || dependentField.value == null ? 'not-allowed' : 'default',\n            },\n            ...sx,\n          }}\n        />\n      )}\n    />\n  );\n};\n\nexport const SelectCascadeElement = <\n  TOption,\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n>({\n  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n  ...props\n}: SelectCascadeElementProps<TOption, TFieldValues, TName>): React.ReactElement => {\n  if (gridProps) {\n    return (\n      <Grid {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}>\n        <Component {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component {...props} />;\n};\n\nSelectCascadeElement.displayName = 'SelectCascadeElement';\n\nexport default SelectCascadeElement;\n","import { Grid, useTheme, TextField, Autocomplete } from \"@mui/material\";\nimport type {\n  SxProps,\n  GridProps,\n  ChipTypeMap,\n  TextFieldProps,\n  AutocompleteProps,\n  TextFieldVariants,\n  AutocompleteValue,\n  AutocompleteChangeReason,\n  AutocompleteFreeSoloValueMapping,\n} from \"@mui/material\";\nimport {\n  useMemo,\n  type JSX,\n  useEffect,\n  useCallback,\n  type SyntheticEvent,\n} from \"react\";\nimport {\n  type Control,\n  useController,\n  type FieldPath,\n  type FieldValues,\n  type UseControllerProps,\n} from \"react-hook-form\";\n\n/**\n * Props for the SelectElement component.\n *\n * @template TOption - The option object type\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template Multiple - Whether multiple selection is enabled\n * @template DisableClearable - Whether the clear button is disabled\n * @template FreeSolo - Whether free text input is allowed\n * @template ChipComponent - The chip component type for multiple selection\n *\n * @public\n */\nexport type SelectElementProps<\n  TOption,\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  Multiple extends boolean | undefined = false,\n  DisableClearable extends boolean | undefined = false,\n  FreeSolo extends boolean | undefined = false,\n  ChipComponent extends React.ElementType = ChipTypeMap[\"defaultComponent\"]\n> = Omit<\n  AutocompleteProps<\n    TOption,\n    Multiple,\n    DisableClearable,\n    FreeSolo,\n    ChipComponent\n  >,\n  | \"name\"\n  | \"renderInput\"\n  | \"isOptionEqualToValue\"\n  | \"getOptionLabel\"\n  | \"disabled\"\n> & {\n  /**\n   * Validation rules for the field\n   * @example { required: 'Please select an option' }\n   */\n  rules?: UseControllerProps<TFieldValues, TName>[\"rules\"];\n  /**\n   * The field name in the form\n   * @example \"category\" | \"user.department\"\n   */\n  name: TName;\n  /**\n   * The form control instance from react-hook-form\n   */\n  control?: Control<TFieldValues>;\n  /**\n   * Grid layout props for the wrapper Grid component\n   * @defaultValue { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } }\n   */\n  gridProps?: GridProps;\n  /**\n   * Placeholder text for the select input\n   * @example \"Choose an option...\"\n   */\n  placeholder?: string;\n  /**\n   * The input label text\n   * @example \"Category\"\n   */\n  label?: string;\n  /**\n   * The TextField variant\n   * @defaultValue \"outlined\"\n   */\n  variant?: TextFieldVariants;\n  /**\n   * Custom styles for the component\n   */\n  sx?: SxProps;\n  /**\n   * Whether the component is in edit mode (affects auto-selection behavior)\n   * When false and only one option exists, that option is auto-selected\n   * @defaultValue false\n   */\n  isEdit?: boolean;\n  /**\n   * Whether the select is disabled\n   */\n  disabled?: boolean;\n  /**\n   * The property name in option objects to use as display label\n   * @defaultValue \"Label\"\n   * @example \"name\" | \"title\"\n   */\n  labelKey?: string;\n  /**\n   * The property name in option objects to use as the value\n   * @defaultValue \"Value\"\n   * @example \"id\" | \"code\"\n   */\n  valueKey?: keyof TOption;\n  /**\n   * Additional props for the underlying TextField component\n   */\n  textFieldProps?: Omit<TextFieldProps, \"name\">;\n};\n\nconst Component = function SelectElement<\n  TOption extends Record<string, any> = Record<string, any>,\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  Multiple extends boolean | undefined = false,\n  DisableClearable extends boolean | undefined = false,\n  FreeSolo extends boolean | undefined = false,\n  ChipComponent extends React.ElementType = ChipTypeMap[\"defaultComponent\"]\n>(\n  props: SelectElementProps<\n    TOption,\n    TFieldValues,\n    TName,\n    Multiple,\n    DisableClearable,\n    FreeSolo,\n    ChipComponent\n  >\n) {\n  const {\n    name,\n    control,\n    onChange,\n    isEdit,\n    options,\n    label,\n    sx,\n    variant,\n    disabled,\n    labelKey = \"Label\",\n    valueKey = \"Value\",\n    placeholder,\n    textFieldProps = {},\n    ...rest\n  } = props;\n\n  const { required } = textFieldProps;\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n  });\n\n  const theme = useTheme();\n\n  const getOptionValue = useCallback(\n    (option: TOption | AutocompleteFreeSoloValueMapping<FreeSolo>) => {\n      if (typeof option === \"string\") return option;\n\n      return option ? option[valueKey] : null; // Return null for consistency\n    },\n    [valueKey]\n  );\n\n  const getOptionLabel = useCallback(\n    (option: TOption | AutocompleteFreeSoloValueMapping<FreeSolo>) => {\n      if (typeof option === \"string\") return option;\n\n      return option ? String(option[labelKey]) : \"\";\n    },\n    [labelKey]\n  );\n\n  const handleChange = (\n    event: SyntheticEvent,\n    newValue: AutocompleteValue<TOption, Multiple, DisableClearable, FreeSolo>,\n    reason: AutocompleteChangeReason\n  ) => {\n    const option = newValue as TOption | null;\n\n    field.onChange(option ? getOptionValue(option) : null);\n    onChange?.(event, newValue, reason);\n  };\n\n  useEffect(() => {\n    if (\n      !isEdit &&\n      options.length === 1 &&\n      (field.value == null || field.value == undefined || field.value === \"\")\n    ) {\n      const defaultOption = options[0];\n      const defaultValue = getOptionValue(defaultOption);\n\n      field.onChange(defaultValue);\n    }\n  }, [isEdit, options]);\n\n  const autocompleteValue = useMemo(\n    () =>\n      options.find((option) => getOptionValue(option) === field.value) ?? null,\n    [field.value, options, getOptionValue]\n  );\n\n  return (\n    <Autocomplete\n      {...rest}\n      filterSelectedOptions={false}\n      options={options}\n      value={\n        autocompleteValue as AutocompleteValue<\n          TOption,\n          Multiple,\n          DisableClearable,\n          FreeSolo\n        >\n      }\n      onChange={handleChange}\n      disabled={disabled}\n      getOptionLabel={(\n        option: TOption | AutocompleteFreeSoloValueMapping<FreeSolo>\n      ) => getOptionLabel(option)}\n      ref={field.ref}\n      isOptionEqualToValue={(option, value) =>\n        getOptionValue(option) === getOptionValue(value)\n      }\n      renderInput={(params) => (\n        <TextField\n          {...params}\n          fullWidth\n          required={required}\n          error={!!error}\n          helperText={error ? error.message : \"\"}\n          label={label}\n          placeholder={placeholder}\n          variant={variant ? variant : \"outlined\"}\n          // @ts-ignore\n          sx={{\n            \"& .MuiOutlinedInput-root\": {\n              bgcolor: disabled\n                ? theme.palette.action.disabledBackground\n                : \"transparent\",\n            },\n            \"& .MuiInputLabel-asterisk\": { color: \"red\" },\n            \"& .MuiInputBase-input\": {\n              cursor: disabled ? \"not-allowed\" : \"default\",\n            },\n            ...sx,\n          }}\n        />\n      )}\n    />\n  );\n};\n\n/**\n * A react-hook-form integrated Autocomplete component for selecting from predefined options.\n *\n * This component provides a fully integrated select/autocomplete input that works seamlessly\n * with react-hook-form, including automatic validation, error handling, and optional Grid wrapper\n * for responsive layouts. It supports both single and multiple selection modes.\n *\n * Features:\n * - Full react-hook-form integration\n * - Autocomplete with filtering\n * - Single and multiple selection support\n * - Automatic error display\n * - Customizable option display (labelKey/valueKey)\n * - Auto-selection when only one option exists\n * - Grid layout wrapper\n * - TypeScript type safety\n * - Disabled state styling\n *\n * @example\n * Basic usage:\n * ```tsx\n * <SelectElement\n *   control={control}\n *   name=\"category\"\n *   label=\"Category\"\n *   options={[\n *     { Label: 'Technology', Value: 'tech' },\n *     { Label: 'Finance', Value: 'finance' }\n *   ]}\n *   rules={{ required: 'Please select a category' }}\n * />\n * ```\n *\n * @example\n * With custom keys:\n * ```tsx\n * <SelectElement\n *   control={control}\n *   name=\"userId\"\n *   label=\"Assign to User\"\n *   options={users}\n *   labelKey=\"fullName\"\n *   valueKey=\"id\"\n *   placeholder=\"Choose a user...\"\n * />\n * ```\n *\n * @example\n * Multiple selection:\n * ```tsx\n * <SelectElement\n *   control={control}\n *   name=\"tags\"\n *   label=\"Tags\"\n *   options={availableTags}\n *   multiple\n *   gridProps={{ size: { xs: 12, md: 8 } }}\n * />\n * ```\n *\n * @template TOption - The option object type\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template Multiple - Whether multiple selection is enabled\n * @template DisableClearable - Whether the clear button is disabled\n * @template FreeSolo - Whether free text input is allowed\n * @template ChipComponent - The chip component type for multiple selection\n *\n * @param props - Component props\n * @returns React element with optional Grid wrapper\n *\n * @public\n */\nexport const SelectElement = <\n  TOption extends Record<string, any> = Record<string, any>,\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  Multiple extends boolean | undefined = false,\n  DisableClearable extends boolean | undefined = false,\n  FreeSolo extends boolean | undefined = false,\n  ChipComponent extends React.ElementType = ChipTypeMap[\"defaultComponent\"]\n>({\n  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n  ...props\n}: SelectElementProps<\n  TOption,\n  TFieldValues,\n  TName,\n  Multiple,\n  DisableClearable,\n  FreeSolo,\n  ChipComponent\n>): React.ReactElement => {\n  if (gridProps) {\n    return (\n      <Grid\n        {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}\n      >\n        <Component {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component {...props} />;\n};\n\nSelectElement.displayName = \"SelectElement\";\n\nexport default SelectElement;\n","import CheckBoxIcon from '@mui/icons-material/CheckBox';\nimport CheckBoxOutlineBlankIcon from '@mui/icons-material/CheckBoxOutlineBlank';\nimport type {\n  SxProps,\n  GridProps,\n  ChipTypeMap,\n  AutocompleteProps,\n  TextFieldVariants,\n  AutocompleteChangeReason,\n} from '@mui/material';\nimport { Grid, Checkbox, TextField, Autocomplete, CircularProgress } from '@mui/material';\nimport type { JSX, SyntheticEvent } from 'react';\nimport { Fragment } from 'react';\nimport type { Path, Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';\n//@ts-nocheck\n\nimport { useController } from 'react-hook-form';\n\ntype BaseAutocompleteProps<\n  TOption,\n  Multiple extends boolean | undefined,\n  DisableClearable extends boolean | undefined,\n  FreeSolo extends boolean | undefined,\n  ChipComponent extends React.ElementType,\n> = Omit<\n  AutocompleteProps<TOption, Multiple, DisableClearable, FreeSolo, ChipComponent>,\n  'name' | 'renderInput' | 'multiple' | 'onChange' | 'value'\n>;\n\nexport type SelectMultiElementProps<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TOption extends Record<string, any> = Record<string, any>,\n  Multiple extends boolean | undefined = true,\n  DisableClearable extends boolean | undefined = false,\n  FreeSolo extends boolean | undefined = false,\n  ChipComponent extends React.ElementType = ChipTypeMap['defaultComponent'],\n> = BaseAutocompleteProps<TOption, Multiple, DisableClearable, FreeSolo, ChipComponent> & {\n  rules?: UseControllerProps<TFieldValues, TName>['rules'];\n  name: TName;\n  control?: Control<TFieldValues>;\n  gridProps?: GridProps;\n  placeholder?: string;\n  label?: string;\n  variant?: TextFieldVariants;\n  sx?: SxProps;\n  labelKey?: keyof TOption;\n  valueKey?: keyof TOption;\n};\n\ntype SelectMultiElementComponent = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = Path<TFieldValues>,\n  TOption extends Record<string, any> = Record<string, any>,\n  Multiple extends boolean | undefined = true,\n  DisableClearable extends boolean | undefined = false,\n  FreeSolo extends boolean | undefined = false,\n  ChipComponent extends React.ElementType = ChipTypeMap['defaultComponent'],\n>(\n  props: SelectMultiElementProps<\n    TFieldValues,\n    TName,\n    TOption,\n    Multiple,\n    DisableClearable,\n    FreeSolo,\n    ChipComponent\n  >\n) => React.JSX.Element;\n\nconst Component = function SelectMultiElement<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TOption extends Record<string, any> = Record<string, any>,\n>(props: SelectMultiElementProps<TFieldValues, TName, TOption>) {\n  const {\n    name,\n    control,\n    onBlur,\n    disabled,\n    options,\n    loading = false,\n    placeholder,\n    label,\n    variant,\n    sx,\n    labelKey = 'Label',\n    valueKey = 'Value',\n    ...rest\n  } = props;\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n  });\n\n  const getOptionValue = (option: TOption) => {\n    if (typeof option === 'string') return option;\n\n    return option ? option[valueKey] : null;\n  };\n\n  const getOptionLabel = (option: TOption) => {\n    if (typeof option === 'string') return option;\n\n    return option ? option[labelKey] : '';\n  };\n\n  const selectedValue =\n    field.value && Array.isArray(field.value)\n      ? options.filter((option) => field.value.includes(getOptionValue(option)))\n      : [];\n\n  const handleChange = (\n    _: SyntheticEvent,\n    selectedOptions: TOption[],\n    reason: AutocompleteChangeReason\n  ) => {\n    if (reason === 'clear') {\n      field.onChange([]);\n    } else if (reason === 'selectOption' || reason === 'removeOption') {\n      const newValues = selectedOptions.map((option) => getOptionValue(option));\n\n      field.onChange(newValues);\n    }\n  };\n\n  const icon = <CheckBoxOutlineBlankIcon fontSize=\"small\" />;\n  const checkedIcon = <CheckBoxIcon fontSize=\"small\" />;\n\n  return (\n    <Autocomplete\n      multiple\n      value={selectedValue}\n      loading={loading}\n      options={options}\n      getOptionLabel={getOptionLabel}\n      isOptionEqualToValue={(option, value) => getOptionValue(option) === getOptionValue(value)}\n      filterSelectedOptions\n      disableCloseOnSelect\n      ref={field.ref}\n      disabled={disabled ?? field.disabled}\n      onChange={handleChange}\n      onBlur={(event) => {\n        field.onBlur();\n        if (typeof onBlur === 'function') {\n          onBlur(event);\n        }\n      }}\n      fullWidth\n      renderOption={(props1, option, { selected }) => {\n        const { key, ...optionProps } = props1;\n\n        return (\n          <li key={key} {...optionProps}>\n            <Checkbox icon={icon} checkedIcon={checkedIcon} checked={selected} />\n            {getOptionLabel(option as TOption)}\n          </li>\n        );\n      }}\n      renderInput={(params) => (\n        <TextField\n          {...params}\n          label={label}\n          error={!!error}\n          helperText={error ? error.message : ''}\n          placeholder={placeholder}\n          slotProps={{\n            input: {\n              ...params.InputProps,\n              endAdornment: (\n                <Fragment>\n                  {loading ? <CircularProgress color=\"inherit\" size={20} /> : null}\n                  {params.InputProps.endAdornment}\n                </Fragment>\n              ),\n            },\n          }}\n          variant={variant ? variant : 'outlined'}\n          // @ts-ignore\n          sx={{\n            ...sx,\n          }}\n        />\n      )}\n      {...rest}\n    />\n  );\n};\n\nexport const SelectMultiElement = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TOption extends Record<string, any> = Record<string, any>,\n>({\n  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n  ...props\n}: SelectMultiElementProps<TFieldValues, TName, TOption>): React.ReactElement => {\n  if (gridProps) {\n    return (\n      <Grid {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}>\n        <Component {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component {...props} />;\n};\n\nSelectMultiElement.displayName = 'SelectMultiElement';\n\nexport default SelectMultiElement;\n","import type {\n  GridProps,\n  SxProps,\n  TextFieldProps,\n  TextFieldVariants\n} from \"@mui/material\";\nimport {\n  Grid,\n  TextField,\n  useForkRef,\n  useTheme,\n} from \"@mui/material\";\nimport type { ChangeEvent, ReactNode } from \"react\";\nimport React from \"react\";\nimport type {\n  Control,\n  FieldError,\n  FieldPath,\n  FieldValues,\n  PathValue,\n  UseControllerProps\n} from \"react-hook-form\";\nimport {\n  useController\n} from \"react-hook-form\";\n\nimport { useTransform } from \"../../hooks/useTransform\";\n\n/**\n * Props for the TextFieldElement component.\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n *\n * @public\n */\nexport interface TextFieldElementProps<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown\n> {\n  /**\n   * Validation rules for the field\n   * @example { required: 'This field is required', minLength: { value: 3, message: 'Minimum 3 characters' } }\n   */\n  rules?: UseControllerProps<TFieldValues, TName>[\"rules\"];\n  /**\n   * The field name in the form\n   * @example \"firstName\" | \"user.email\"\n   */\n  name: TName;\n  /**\n   * Custom error message parser\n   * @param error - The field error object\n   * @returns Custom error message or component\n   */\n  parseError?: (error: FieldError) => ReactNode;\n  /**\n   * The form control instance from react-hook-form\n   */\n  control?: Control<TFieldValues>;\n  /**\n   * Custom TextField component to use instead of default MUI TextField\n   */\n  component?: typeof TextField;\n  /**\n   * Value transformation functions for input/output\n   */\n  transform?: {\n    /** Transform value before displaying in input */\n    input?: (value: PathValue<TFieldValues, TName>) => TValue;\n    /** Transform input event to form value */\n    output?: (\n      eventOrValue: import(\"../../types/events\").EventOrValue<PathValue<TFieldValues, TName>>,\n      value?: PathValue<TFieldValues, TName>\n    ) => PathValue<TFieldValues, TName>;\n  };\n  /**\n   * The input label text\n   * @example \"Email Address\"\n   */\n  label?: string;\n  /**\n   * Placeholder text for the input\n   * @example \"Enter your email\"\n   */\n  placeholder?: string;\n  /**\n   * Additional props for the underlying TextField component\n   */\n  textFieldProps?: Omit<TextFieldProps, \"name\">;\n  /**\n   * Grid layout props for the wrapper Grid component\n   * @defaultValue { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } }\n   */\n  gridProps?: GridProps;\n  /**\n   * The TextField variant\n   * @defaultValue \"outlined\"\n   */\n  variant?: TextFieldVariants;\n  /**\n   * Custom styles for the TextField\n   */\n  sx?: SxProps;\n}\n\ntype TextFieldElementComponent = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown\n>(\n  props: TextFieldElementProps<TFieldValues, TName, TValue>\n) => React.JSX.Element;\n\nconst Component = function TextFieldElement<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown\n>(props: TextFieldElementProps<TFieldValues, TName, TValue>) {\n  const {\n    rules = {},\n    parseError,\n    name,\n    control,\n    component: TextFieldComponent = TextField,\n    gridProps,\n    transform,\n    label,\n    placeholder,\n    textFieldProps = {},\n    variant,\n    sx,\n    ...rest\n  } = props;\n\n  const {\n    type,\n    required,\n    helperText,\n    inputRef,\n    onBlur,\n    disabled,\n    ...restTextProps\n  } = textFieldProps;\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n  });\n\n  const theme = useTheme();\n\n  const { value, onChange } = useTransform<TFieldValues, TName, TValue>({\n    value: field.value,\n    onChange: field.onChange,\n    transform: {\n      input:\n        typeof transform?.input === \"function\"\n          ? transform.input\n          : (value) => {\n            return value ?? (\"\" as TValue);\n          },\n      output:\n        typeof transform?.output === \"function\"\n          ? transform.output\n          : (eventOrValue: import(\"../../types/events\").EventOrValue<PathValue<TFieldValues, TName>>, value?: PathValue<TFieldValues, TName>) => {\n            // Extract value from event or use direct value\n            const extractedValue = value !== undefined \n              ? value \n              : (typeof eventOrValue === 'object' && eventOrValue !== null && 'target' in eventOrValue && typeof eventOrValue.target === 'object' && eventOrValue.target !== null && 'value' in eventOrValue.target)\n                ? (eventOrValue.target as { value: unknown }).value\n                : eventOrValue;\n\n            if (type !== \"number\") {\n              return extractedValue as PathValue<TFieldValues, TName>;\n            }\n\n            if (extractedValue === \"\") {\n              return null as PathValue<TFieldValues, TName>;\n            }\n\n            if (extractedValue == null) {\n              return extractedValue as PathValue<TFieldValues, TName>;\n            }\n\n            return Number(extractedValue) as PathValue<TFieldValues, TName>;\n          },\n    },\n  });\n\n  const handleInputRef = useForkRef(field.ref, inputRef);\n\n  return (\n    <TextFieldComponent\n      {...rest}\n      {...restTextProps}\n      name={field.name}\n      value={value}\n      onChange={(event) => {\n        // this will be a breaking change for anyone using transform.output\n        // because now we are passing event instead of event.target.value or +event.target.value\n        field.onChange(event);\n        if (typeof onChange === \"function\") {\n          onChange(event);\n        }\n      }}\n      onBlur={(event) => {\n        field.onBlur();\n        if (typeof onBlur === \"function\") {\n          onBlur(event);\n        }\n      }}\n      disabled={disabled}\n      label={label}\n      placeholder={placeholder}\n      fullWidth\n      required={required}\n      type={type}\n      error={!!error}\n      helperText={error ? error.message : helperText}\n      inputRef={handleInputRef}\n      variant={variant ? variant : \"outlined\"}\n      size=\"small\"\n      sx={{\n        \"& .MuiInputLabel-asterisk\": { color: \"red\" },\n        \"& .MuiInputBase-input\": {\n          cursor: disabled ? \"not-allowed\" : \"default\",\n        },\n        bgcolor: disabled\n          ? theme.palette.action.disabledBackground\n          : \"transparent\",\n        ...sx,\n      }}\n    />\n  );\n};\n\n/**\n * A react-hook-form integrated TextField component with automatic validation and grid layout.\n *\n * This component provides a fully integrated TextField that works seamlessly with react-hook-form,\n * including automatic validation, error handling, and optional Grid wrapper for responsive layouts.\n *\n * Features:\n * - Full react-hook-form integration\n * - Automatic error display\n * - Value transformation support\n * - Grid layout wrapper\n * - TypeScript type safety\n * - Number input handling\n * - Disabled state styling\n *\n * @example\n * Basic usage:\n * ```tsx\n * <TextFieldElement\n *   control={control}\n *   name=\"firstName\"\n *   label=\"First Name\"\n *   rules={{ required: 'First name is required' }}\n * />\n * ```\n *\n * @example\n * With custom grid layout:\n * ```tsx\n * <TextFieldElement\n *   control={control}\n *   name=\"email\"\n *   label=\"Email\"\n *   type=\"email\"\n *   gridProps={{ size: { xs: 12, md: 6 } }}\n *   rules={{\n *     required: 'Email is required',\n *     pattern: { value: /\\S+@\\S+\\.\\S+/, message: 'Invalid email' }\n *   }}\n * />\n * ```\n *\n * @example\n * Number input with transformation:\n * ```tsx\n * <TextFieldElement\n *   control={control}\n *   name=\"age\"\n *   label=\"Age\"\n *   textFieldProps={{ type: 'number' }}\n *   transform={{\n *     input: (value) => value?.toString() || '',\n *     output: (event) => parseInt(event.target.value) || null\n *   }}\n * />\n * ```\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n *\n * @param props - Component props\n * @returns React element with optional Grid wrapper\n *\n * @public\n */\nexport const TextFieldElement = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown\n>({\n  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n  ...props\n}: TextFieldElementProps<TFieldValues, TName, TValue>): React.ReactElement => {\n  if (gridProps) {\n    return (\n      <Grid\n        {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}\n      >\n        <Component {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component {...props} />;\n};\n\nTextFieldElement.displayName = \"TextFieldElement\";\n\nexport default TextFieldElement;\n","import type {\n  GridProps,\n  SxProps,\n  TextFieldProps,\n  TextFieldVariants\n} from \"@mui/material\";\nimport {\n  Grid,\n  TextField,\n  useForkRef,\n  useTheme,\n} from \"@mui/material\";\nimport type { ChangeEvent, ReactNode } from \"react\";\nimport React from \"react\";\nimport type {\n  Control,\n  FieldError,\n  FieldPath,\n  FieldValues,\n  PathValue,\n  UseControllerProps\n} from \"react-hook-form\";\nimport {\n  useController\n} from \"react-hook-form\";\n\nimport { useEnhancedTransform, type FieldType } from \"../../hooks/useTransform/enhanced\";\n\n/**\n * Props for the EnhancedTextFieldElement component.\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n *\n * @public\n */\nexport interface EnhancedTextFieldElementProps<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = PathValue<TFieldValues, TName>\n> {\n  /**\n   * Validation rules for the field\n   * @example { required: 'This field is required', minLength: { value: 3, message: 'Minimum 3 characters' } }\n   */\n  rules?: UseControllerProps<TFieldValues, TName>[\"rules\"];\n  /**\n   * The field name in the form\n   * @example \"firstName\" | \"user.email\"\n   */\n  name: TName;\n  /**\n   * Custom error message parser\n   * @param error - The field error object\n   * @returns Custom error message or component\n   */\n  parseError?: (error: FieldError) => ReactNode;\n  /**\n   * The form control instance from react-hook-form\n   */\n  control?: Control<TFieldValues>;\n  /**\n   * Custom TextField component to use instead of default MUI TextField\n   */\n  component?: typeof TextField;\n  /**\n   * Value transformation functions for input/output\n   * @deprecated Use fieldType for common patterns or custom transforms for complex cases\n   */\n  transform?: {\n    /** Transform value before displaying in input */\n    input?: (value: PathValue<TFieldValues, TName>) => TValue;\n    /** Transform input event to form value */\n    output?: (\n      eventOrValue: import(\"../../types/events\").EventOrValue<PathValue<TFieldValues, TName>>,\n      value?: PathValue<TFieldValues, TName>\n    ) => PathValue<TFieldValues, TName>;\n  };\n  /**\n   * Built-in field type for automatic transformation\n   * @example 'text' | 'number' | 'date' | 'time' | 'select'\n   */\n  fieldType?: FieldType;\n  /**\n   * Default value to display when field value is null/undefined\n   * @example \"\"\n   */\n  defaultValue?: TValue;\n  /**\n   * The input label text\n   * @example \"Email Address\"\n   */\n  label?: string;\n  /**\n   * Placeholder text for the input\n   * @example \"Enter your email\"\n   */\n  placeholder?: string;\n  /**\n   * Additional props for the underlying TextField component\n   */\n  textFieldProps?: Omit<TextFieldProps, \"name\">;\n  /**\n   * Grid layout props for the wrapper Grid component\n   * @defaultValue { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } }\n   */\n  gridProps?: GridProps;\n  /**\n   * The TextField variant\n   * @defaultValue \"outlined\"\n   */\n  variant?: TextFieldVariants;\n  /**\n   * Custom styles for the TextField\n   */\n  sx?: SxProps;\n  /**\n   * Custom onChange handler called after transformation\n   */\n  onChange?: (event: ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;\n  /**\n   * Enable development warnings for debugging transformation issues\n   * @defaultValue process.env.NODE_ENV === 'development'\n   */\n  enableWarnings?: boolean;\n}\n\ntype EnhancedTextFieldElementComponent = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = PathValue<TFieldValues, TName>\n>(\n  props: EnhancedTextFieldElementProps<TFieldValues, TName, TValue>\n) => React.JSX.Element;\n\nconst Component = function EnhancedTextFieldElement<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = PathValue<TFieldValues, TName>\n>(props: EnhancedTextFieldElementProps<TFieldValues, TName, TValue>) {\n  const {\n    rules = {},\n    parseError,\n    name,\n    control,\n    component: TextFieldComponent = TextField,\n    gridProps,\n    transform,\n    fieldType = 'text', // Default to text type\n    defaultValue,\n    label,\n    placeholder,\n    textFieldProps = {},\n    variant,\n    sx,\n    onChange: customOnChange,\n    enableWarnings = process.env.NODE_ENV === 'development',\n    ...rest\n  } = props;\n\n  const {\n    type,\n    required,\n    helperText,\n    inputRef,\n    onBlur,\n    disabled,\n    ...restTextProps\n  } = textFieldProps;\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n    rules,\n  });\n\n  const theme = useTheme();\n\n  // Use the enhanced transform hook with performance optimizations\n  const { value, onChange } = useEnhancedTransform<TFieldValues, TName, TValue>({\n    value: field.value,\n    onChange: field.onChange,\n    transform: transform ? {\n      input: transform.input,\n      output: transform.output,\n    } : undefined,\n    fieldType: !transform ? (type === 'number' ? 'number' : fieldType) : undefined, // Auto-detect number type\n    defaultValue,\n    enableWarnings,\n  });\n\n  const handleInputRef = useForkRef(field.ref, inputRef);\n\n  return (\n    <TextFieldComponent\n      {...rest}\n      {...restTextProps}\n      name={field.name}\n      value={value}\n      onChange={(event) => {\n        onChange(event);\n        if (typeof customOnChange === \"function\") {\n          customOnChange(event);\n        }\n      }}\n      onBlur={(event) => {\n        field.onBlur();\n        if (typeof onBlur === \"function\") {\n          onBlur(event);\n        }\n      }}\n      disabled={disabled}\n      label={label}\n      placeholder={placeholder}\n      fullWidth\n      required={required}\n      type={type}\n      error={!!error}\n      helperText={error ? (parseError ? parseError(error) : error.message) : helperText}\n      inputRef={handleInputRef}\n      variant={variant ? variant : \"outlined\"}\n      size=\"small\"\n      sx={{\n        \"& .MuiInputLabel-asterisk\": { color: \"red\" },\n        \"& .MuiInputBase-input\": {\n          cursor: disabled ? \"not-allowed\" : \"default\",\n        },\n        bgcolor: disabled\n          ? theme.palette.action.disabledBackground\n          : \"transparent\",\n        ...sx,\n      }}\n    />\n  );\n};\n\n/**\n * An enhanced react-hook-form integrated TextField component with automatic validation,\n * performance optimizations, and built-in field type handling.\n *\n * This enhanced version provides all the functionality of the original TextFieldElement\n * plus additional features:\n * - Performance optimizations with memoized transformations\n * - Built-in field type handling (number, text, etc.)\n * - Better TypeScript inference and type safety\n * - Development warnings for debugging\n * - Stable references to prevent unnecessary re-renders\n * - Enhanced error handling with custom parseError support\n *\n * Features:\n * - Full react-hook-form integration\n * - Automatic error display with custom parsing\n * - Value transformation support (backward compatible)\n * - Built-in field types for common patterns\n * - Grid layout wrapper\n * - Enhanced TypeScript type safety\n * - Optimized number input handling\n * - Disabled state styling\n * - Performance optimizations\n *\n * @example\n * Basic usage with built-in number handling:\n * ```tsx\n * <EnhancedTextFieldElement\n *   control={control}\n *   name=\"age\"\n *   label=\"Age\"\n *   fieldType=\"number\"\n *   rules={{ required: 'Age is required', min: { value: 0, message: 'Age must be positive' } }}\n * />\n * ```\n *\n * @example\n * Advanced usage with custom grid layout:\n * ```tsx\n * <EnhancedTextFieldElement\n *   control={control}\n *   name=\"email\"\n *   label=\"Email\"\n *   fieldType=\"text\"\n *   placeholder=\"Enter your email address\"\n *   gridProps={{ size: { xs: 12, md: 6 } }}\n *   rules={{\n *     required: 'Email is required',\n *     pattern: { value: /\\S+@\\S+\\.\\S+/, message: 'Invalid email' }\n *   }}\n * />\n * ```\n *\n * @example\n * Custom transformation (backward compatible):\n * ```tsx\n * <EnhancedTextFieldElement\n *   control={control}\n *   name=\"price\"\n *   label=\"Price\"\n *   transform={{\n *     input: (value) => value ? `$${value}` : '',\n *     output: (event) => parseFloat(event.target.value.replace('$', '')) || null\n *   }}\n * />\n * ```\n *\n * @example\n * With custom error parsing:\n * ```tsx\n * <EnhancedTextFieldElement\n *   control={control}\n *   name=\"username\"\n *   label=\"Username\"\n *   fieldType=\"text\"\n *   parseError={(error) => (\n *     <span style={{ color: 'red' }}>\n *       ⚠️ {error.message}\n *     </span>\n *   )}\n * />\n * ```\n *\n * @template TFieldValues - The form values type\n * @template TName - The field name type\n * @template TValue - The transformed value type\n *\n * @param props - Component props\n * @returns React element with optional Grid wrapper\n *\n * @public\n */\nexport const EnhancedTextFieldElement = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = PathValue<TFieldValues, TName>\n>({\n  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n  ...props\n}: EnhancedTextFieldElementProps<TFieldValues, TName, TValue>): React.ReactElement => {\n  if (gridProps) {\n    return (\n      <Grid\n        {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}\n      >\n        <Component {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component {...props} />;\n};\n\nEnhancedTextFieldElement.displayName = \"EnhancedTextFieldElement\";\n\nexport default EnhancedTextFieldElement;\n","import type {\n  SxProps,\n  GridProps,\n  TextFieldProps,\n  TextFieldVariants,\n} from \"@mui/material\";\nimport { Grid, useForkRef, useTheme } from \"@mui/material\";\nimport type {\n  PickerValidDate,\n  TimePickerProps,\n  TimePickerSlotProps,\n  TimeValidationError,\n  PickerChangeHandlerContext,\n} from \"@mui/x-date-pickers\";\nimport { TimePicker } from \"@mui/x-date-pickers\";\nimport { useLocalizationContext } from \"@mui/x-date-pickers/internals\";\nimport React, { useCallback, type ReactNode } from \"react\";\nimport type {\n  Control,\n  FieldPath,\n  PathValue,\n  FieldError,\n  FieldValues,\n  UseControllerProps,\n} from \"react-hook-form\";\nimport { useController } from \"react-hook-form\";\n\nimport type { UseTransformOptions, UseTransformReturn } from \"@/hooks\";\n\nexport function readValueAsDate<TDate extends PickerValidDate>(\n  adapter: ReturnType<typeof useLocalizationContext>,\n  value: string | null | TDate\n): TDate | null {\n  if (typeof value === \"string\") {\n    if (value === \"\") {\n      return null;\n    }\n\n    return adapter.utils.date(value) as TDate;\n  }\n\n  return value;\n}\n\nexport function useTransform<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue = unknown\n>(\n  options: UseTransformOptions<TFieldValues, TName, TValue>\n): UseTransformReturn<TFieldValues, TName, TValue> {\n  const value =\n    typeof options.transform?.input === \"function\"\n      ? options.transform.input(options.value)\n      : options.value;\n\n  const onChange = useCallback(\n    (\n      eventOrValue: import(\"../../types/events\").EventOrValue<PathValue<TFieldValues, TName>>,\n      value?: PathValue<TFieldValues, TName>\n    ) => {\n      if (typeof options.transform?.output === \"function\") {\n        options.onChange(options.transform.output(eventOrValue, value));\n      } else {\n        options.onChange(eventOrValue as PathValue<TFieldValues, TName>);\n      }\n    },\n    [options]\n  );\n\n  return {\n    value,\n    onChange,\n  };\n}\n\nexport interface TimePickerElementProps<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends PickerValidDate = PickerValidDate,\n  TEnableAccessibleFieldDOMStructure extends boolean = false\n> {\n  name: TName;\n  required?: boolean;\n  isDate?: boolean;\n  parseError?: (error: FieldError | TimeValidationError) => ReactNode;\n  rules?: UseControllerProps<TFieldValues, TName>[\"rules\"];\n  control?: Control<TFieldValues>;\n  inputProps?: TextFieldProps;\n  helperText?: TextFieldProps[\"helperText\"];\n  label?: ReactNode;\n  placeholder?: string;\n  textReadOnly?: boolean;\n  slotProps?: Omit<\n    TimePickerSlotProps<TEnableAccessibleFieldDOMStructure>,\n    \"textField\"\n  >;\n  transform?: {\n    input?: (value: PathValue<TFieldValues, TName>) => TValue | null;\n    output?: (\n      eventOrValue: import(\"../../types/events\").EventOrValue<PathValue<TFieldValues, TName>>,\n      value?: PathValue<TFieldValues, TName>\n    ) => PathValue<TFieldValues, TName>;\n  };\n  gridProps?: GridProps;\n  timePickerProps?: Omit<\n    TimePickerProps<TEnableAccessibleFieldDOMStructure>,\n    \"value\" | \"slotProps\"\n  >;\n  variant?: TextFieldVariants;\n  sx?: SxProps;\n}\n\ntype TimePickerElementComponent = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends PickerValidDate = PickerValidDate\n>(\n  props: TimePickerElementProps<TFieldValues, TName, TValue>\n) => React.JSX.Element;\n\nconst Component = function TimePickerElement<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends PickerValidDate = PickerValidDate\n>(props: TimePickerElementProps<TFieldValues, TName, TValue>) {\n  const {\n    name,\n    required,\n    inputProps,\n    control,\n    textReadOnly,\n    label,\n    placeholder,\n    slotProps,\n    timePickerProps = {},\n    transform,\n    sx,\n    ...rest\n  } = props;\n\n  const adapter = useLocalizationContext();\n\n  const theme = useTheme();\n\n  const { disabled, inputRef, onClose, ...restTimePickerProps } =\n    timePickerProps;\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n    defaultValue: null as PathValue<TFieldValues, TName>,\n  });\n\n  const { value, onChange } = useTransform<TFieldValues, TName, TValue | null>({\n    value: field.value,\n    onChange: field.onChange,\n    transform: {\n      input:\n        typeof transform?.input === \"function\"\n          ? transform.input\n          : (newValue) => readValueAsDate(adapter, newValue),\n      output: (eventOrValue, value) => {\n        // MUI DatePicker passes (value, context), so we check the second param\n        const actualValue = value !== undefined ? value : eventOrValue;\n        if (actualValue === null) return null as PathValue<TFieldValues, TName>;\n        return actualValue as PathValue<TFieldValues, TName>;\n      },\n    },\n  });\n\n  const handleInputRef = useForkRef(field.ref, inputRef);\n\n  return (\n    <TimePicker\n      {...rest}\n      {...restTimePickerProps}\n      {...field}\n      value={value}\n      label={label}\n      disabled={disabled}\n      {...timePickerProps}\n      inputRef={handleInputRef}\n      onClose={(...args) => {\n        field.onBlur();\n        if (onClose) {\n          onClose(...args);\n        }\n      }}\n      onChange={(newValue, context) => {\n        onChange(newValue, context);\n        if (typeof timePickerProps.onChange === \"function\") {\n          timePickerProps.onChange(newValue, context);\n        }\n      }}\n      sx={{\n        \"& .MuiOutlinedInput-root\": {\n          bgcolor: disabled\n            ? theme.palette.action.disabledBackground\n            : \"transparent\",\n        },\n        \"& .MuiInputLabel-asterisk\": { color: \"red\" },\n        \"& .MuiInputBase-input\": {\n          cursor: disabled ? \"not-allowed\" : \"default\",\n        },\n        ...sx,\n      }}\n      slotProps={{\n        ...slotProps,\n        actionBar: {\n          actions: [\"clear\", \"cancel\", \"accept\"],\n        },\n        textField: {\n          ...inputProps,\n          required,\n          placeholder,\n          fullWidth: true,\n          onBlur: (event: React.FocusEvent<HTMLInputElement | HTMLTextAreaElement>) => {\n            field.onBlur();\n            if (typeof inputProps?.onBlur === \"function\") {\n              inputProps.onBlur(event);\n            }\n          },\n          error: !!error,\n          helperText: error\n            ? error.message\n            : inputProps?.helperText || rest.helperText,\n          inputProps: {\n            readOnly: !!textReadOnly,\n            ...inputProps?.inputProps,\n          },\n        },\n      }}\n    />\n  );\n};\n\nexport const TimePickerElement = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValue extends PickerValidDate = PickerValidDate\n>({\n  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n  ...props\n}: TimePickerElementProps<TFieldValues, TName, TValue>): React.ReactElement => {\n  if (gridProps) {\n    return (\n      <Grid\n        {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}\n      >\n        <Component {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component {...props} />;\n};\n\nTimePickerElement.displayName = \"TimePickerElement\";\n\nexport default TimePickerElement;\n","import { Autocomplete, CircularProgress, Grid, TextField, useTheme } from \"@mui/material\";\nimport type { AutocompleteChangeReason } from \"@mui/material/Autocomplete\";\nimport { debounce } from \"@mui/material/utils\";\nimport * as React from \"react\";\nimport {\n  Fragment,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport { useController, type FieldPath, type FieldValues } from \"react-hook-form\";\n\nimport type { AsyncSelectPayload } from \"../../types\";\n\nimport type { AsyncSelectElementProps, OptionObject } from \"./types\";\n\nconst Component = function AsyncSelectElement<\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValueKey extends string = \"Value\",\n  TLabelKey extends string = \"Label\",\n  TOption extends OptionObject<TValueKey, TLabelKey> = OptionObject<TValueKey, TLabelKey>\n>(props: AsyncSelectElementProps<TFieldValues, TName, TValueKey, TLabelKey, TOption>) {\n  const {\n    name,\n    disabled,\n    control,\n    placeholder,\n    initialValue,\n    label,\n    queryFn,\n    variant,\n    labelKey = \"Label\" as TLabelKey,\n    valueKey = \"Value\" as TValueKey,\n    sx,\n    ...rest\n  } = props;\n\n  const {\n    field,\n    fieldState: { error },\n  } = useController({\n    name,\n    control,\n  });\n\n  const theme = useTheme();\n\n  const [loading, setLoading] = useState<boolean>(false);\n  const [selectedOption, setSelectedOption] = useState<TOption | null>(null);\n  const [inputValue, setInputValue] = useState(\"\");\n  const inputValue2: string = useMemo(() => inputValue, [inputValue]);\n  const setInputValue2 = useCallback(\n    (newValue: string) => setInputValue(newValue),\n    []\n  );\n  const [options, setOptions] = useState<readonly TOption[]>([]);\n\n  const initialValueLoaded = useRef<boolean>(\n    !initialValue ? true : !(initialValue != null)\n  );\n\n  const fieldValue = useRef<TOption[TValueKey] | null>(field.value);\n\n  const fetchData = useMemo(\n    () =>\n      debounce(\n        (\n          payload: AsyncSelectPayload,\n          callback: (results?: readonly TOption[]) => void\n        ) => {\n          queryFn(payload).then((c) => callback(c));\n        },\n        400\n      ),\n    [queryFn]\n  );\n\n  const fillOptions = useCallback((results?: readonly TOption[]) => {\n    let newOptions: readonly TOption[] = [];\n\n    if (selectedOption) {\n      newOptions = [selectedOption];\n    }\n\n    if (results) {\n      newOptions = [...newOptions, ...results];\n    }\n\n    setOptions(newOptions);\n    setLoading(false);\n  }, [selectedOption]);\n\n  useEffect(() => {\n    if (initialValueLoaded.current) return undefined;\n\n    let active = true;\n\n    const payload: AsyncSelectPayload = {\n      query: null,\n      initialValue,\n    };\n\n    setLoading(true);\n\n    fetchData(payload, (results?: readonly TOption[]) => {\n      if (active) {\n        if (!!results && results.length > 0) {\n          fillOptions(results?.filter((c) => c[valueKey] == initialValue));\n          setSelectedOption(results[0]);\n          field.onChange(results[0][valueKey]);\n          fieldValue.current = results[0][valueKey];\n        }\n\n        initialValueLoaded.current = true;\n        setLoading(false);\n      }\n    });\n\n    return () => {\n      active = false;\n    };\n  }, [initialValue, fetchData, field, fillOptions, valueKey]);\n\n  React.useEffect(() => {\n    let active = true;\n\n    if (inputValue2 === \"\" || initialValueLoaded.current === false) {\n      setOptions(selectedOption ? [selectedOption] : []);\n      setLoading(false);\n\n      return undefined;\n    }\n\n    if (fieldValue.current) {\n      if (field.value === fieldValue.current) {\n        return undefined;\n      }\n    }\n\n    setLoading(true);\n\n    const payload: AsyncSelectPayload = {\n      query: inputValue2,\n      initialValue: null,\n    };\n\n    fetchData(payload, (results?: readonly TOption[]) => {\n      if (active) {\n        fillOptions(results);\n      }\n    });\n\n    return () => {\n      active = false;\n    };\n  }, [initialValue, inputValue2, fetchData, field.value, fillOptions, selectedOption]);\n\n  const selectRef = useRef(null);\n\n  const handleChange = (\n    _: React.SyntheticEvent,\n    newSelectedOption: TOption | null,\n    reason: AutocompleteChangeReason\n  ) => {\n    if (reason === \"clear\") {\n      setSelectedOption(null);\n      field.onChange(null);\n      setLoading(false);\n    } else if (reason === \"selectOption\" || reason === \"removeOption\") {\n      if (newSelectedOption) {\n        setSelectedOption(newSelectedOption);\n        field.onChange(newSelectedOption[valueKey]);\n        fieldValue.current = newSelectedOption[valueKey];\n        setLoading(false);\n      }\n    }\n\n    setOptions([]);\n    setLoading(false);\n  };\n\n  useEffect(() => {\n    if (!field.value) {\n      setInputValue(\"\");\n      setSelectedOption(null);\n      setLoading(false);\n    }\n  }, [field.value]);\n\n  const getOptionValue = (option: TOption): string | number => {\n    return option ? String(option[valueKey]) : \"\";\n  };\n\n  const getOptionLabel = (option: TOption): string => {\n    return option ? String(option[labelKey]) : \"\";\n  };\n\n  return (\n    <Autocomplete\n      {...rest}\n      ref={selectRef}\n      fullWidth\n      loading={loading}\n      getOptionLabel={getOptionLabel}\n      getOptionKey={getOptionValue}\n      isOptionEqualToValue={(option, value) =>\n        getOptionValue(option) === getOptionValue(value)\n      }\n      autoComplete\n      disabled={disabled}\n      includeInputInList\n      options={options}\n      filterOptions={(x) => x}\n      value={selectedOption}\n      filterSelectedOptions\n      onChange={handleChange}\n      onInputChange={(_, newInputValue) => {\n        setInputValue2(newInputValue);\n      }}\n      noOptionsText=\"Type Something...\"\n      renderInput={(params) => (\n        <TextField\n          {...params}\n          label={label}\n          error={!!error}\n          helperText={error ? error.message : \"\"}\n          placeholder={placeholder}\n          slotProps={{\n            input: {\n              ...params.InputProps,\n              endAdornment: (\n                <Fragment>\n                  {loading ? (\n                    <CircularProgress color=\"inherit\" size={20} />\n                  ) : null}\n                  {params.InputProps.endAdornment}\n                </Fragment>\n              ),\n            },\n          }}\n          variant={variant ? variant : \"outlined\"}\n          sx={{\n            \"& .MuiInputBase-input\": {\n              cursor: disabled ? \"not-allowed\" : \"default\",\n            },\n            bgcolor: disabled\n              ? theme.palette.action.disabledBackground\n              : \"transparent\",\n            ...sx,\n          }}\n        />\n      )}\n      renderOption={(renderProps, option) => {\n        const { key, ...optionProps } = renderProps;\n\n        return (\n          <li key={key} {...optionProps}>\n            {option[labelKey]}\n          </li>\n        );\n      }}\n    />\n  );\n};\n\nconst AsyncSelectElement = <\n  TFieldValues extends FieldValues = FieldValues,\n  TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>,\n  TValueKey extends string = \"Value\",\n  TLabelKey extends string = \"Label\",\n  TOption extends OptionObject<TValueKey, TLabelKey> = OptionObject<TValueKey, TLabelKey>\n>({\n  gridProps = { size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 } },\n  ...props\n}: AsyncSelectElementProps<\n  TFieldValues,\n  TName,\n  TValueKey,\n  TLabelKey,\n  TOption\n>): React.ReactElement => {\n  if (gridProps) {\n    return (\n      <Grid\n        {...{ size: { xs: 12, sm: 12, md: 12, lg: 12, xl: 12 }, ...gridProps }}\n      >\n        <Component<TFieldValues, TName, TValueKey, TLabelKey, TOption> {...props} />\n      </Grid>\n    );\n  }\n\n  return <Component<TFieldValues, TName, TValueKey, TLabelKey, TOption> {...props} />;\n};\n\nAsyncSelectElement.displayName = \"AsyncSelectElement\";\n\nexport { AsyncSelectElement };\n","import { AsyncMultiSelect2 } from \"../AsyncMultiSelect2\";\nimport { AsyncSelectElement } from \"../AsyncSelect\";\nimport { CheckboxElement } from \"../CheckboxElement\";\nimport { CheckboxGroup } from \"../CheckboxGroup\";\nimport { DatePickerElement } from \"../DatePickerElement\";\nimport { PasswordElement } from \"../PasswordElement\";\nimport { RadioButtonGroup } from \"../RadioButtonGroup\";\nimport { SelectCascadeElement } from \"../SelectCascadeElement\";\nimport { SelectElement } from \"../SelectElement\";\nimport { SelectMultiElement } from \"../SelectMultiElement\";\nimport { TextFieldElement } from \"../TextFieldElement\";\nimport { TimePickerElement } from \"../TimePickerElement\";\n\nconst Field = {\n  Text: TextFieldElement,\n  Checkbox: CheckboxElement,\n  Date: DatePickerElement,\n  RadioGroup: RadioButtonGroup,\n  Password: PasswordElement,\n  Time: TimePickerElement,\n  Select: SelectElement,\n  SelectMulti: SelectMultiElement,\n  SelectCascade: SelectCascadeElement,\n  AsyncSelect: AsyncSelectElement,\n  AsyncMultiSelect: AsyncMultiSelect2,\n  CheckboxGroup,\n};\n\nexport { Field };\n"]}