@lodashventure/medusa-campaign 0.0.8 → 1.1.0

package/.medusa/server/src/admin/index.js

@@ -4,13 +4,14 @@ const adminSdk = require("@medusajs/admin-sdk");
 const icons = require("@medusajs/icons");
 const ui = require("@medusajs/ui");
 const dayjs = require("dayjs");
-const react = require("react");
+const React = require("react");
 const reactRouterDom = require("react-router-dom");
 const reactQuery = require("@tanstack/react-query");
 const lodash = require("lodash");
 const Medusa = require("@medusajs/js-sdk");
-const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+const _interopDefault = (e2) => e2 && e2.__esModule ? e2 : { default: e2 };
 const dayjs__default = /* @__PURE__ */ _interopDefault(dayjs);
+const React__default = /* @__PURE__ */ _interopDefault(React);
 const Medusa__default = /* @__PURE__ */ _interopDefault(Medusa);
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
@@ -19,8 +20,8 @@ var axios$3 = { exports: {} };
 var bind$2 = function bind(fn, thisArg) {
   return function wrap() {
     var args = new Array(arguments.length);
-    for (var i = 0; i < args.length; i++) {
-      args[i] = arguments[i];
+    for (var i2 = 0; i2 < args.length; i2++) {
+      args[i2] = arguments[i2];
     }
     return fn.apply(thisArg, args);
   };
@@ -30,11 +31,11 @@ var toString = Object.prototype.toString;
 function isArray(val) {
   return toString.call(val) === "[object Array]";
 }
-function isUndefined(val) {
+function isUndefined$1(val) {
   return typeof val === "undefined";
 }
 function isBuffer(val) {
-  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
+  return val !== null && !isUndefined$1(val) && val.constructor !== null && !isUndefined$1(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
 }
 function isArrayBuffer(val) {
   return toString.call(val) === "[object ArrayBuffer]";
@@ -51,16 +52,16 @@ function isArrayBufferView(val) {
   }
   return result;
 }
-function isString(val) {
+function isString$1(val) {
   return typeof val === "string";
 }
 function isNumber(val) {
   return typeof val === "number";
 }
-function isObject(val) {
+function isObject$1(val) {
   return val !== null && typeof val === "object";
 }
-function isPlainObject(val) {
+function isPlainObject$1(val) {
   if (toString.call(val) !== "[object Object]") {
     return false;
   }
@@ -76,11 +77,11 @@ function isFile(val) {
 function isBlob(val) {
   return toString.call(val) === "[object Blob]";
 }
-function isFunction(val) {
+function isFunction$1(val) {
   return toString.call(val) === "[object Function]";
 }
 function isStream(val) {
-  return isObject(val) && isFunction(val.pipe);
+  return isObject$1(val) && isFunction$1(val.pipe);
 }
 function isURLSearchParams(val) {
   return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
@@ -102,8 +103,8 @@ function forEach(obj, fn) {
     obj = [obj];
   }
   if (isArray(obj)) {
-    for (var i = 0, l = obj.length; i < l; i++) {
-      fn.call(null, obj[i], i, obj);
+    for (var i2 = 0, l = obj.length; i2 < l; i2++) {
+      fn.call(null, obj[i2], i2, obj);
     }
   } else {
     for (var key in obj) {
@@ -116,9 +117,9 @@ function forEach(obj, fn) {
 function merge() {
   var result = {};
   function assignValue(val, key) {
-    if (isPlainObject(result[key]) && isPlainObject(val)) {
+    if (isPlainObject$1(result[key]) && isPlainObject$1(val)) {
       result[key] = merge(result[key], val);
-    } else if (isPlainObject(val)) {
+    } else if (isPlainObject$1(val)) {
       result[key] = merge({}, val);
     } else if (isArray(val)) {
       result[key] = val.slice();
@@ -126,20 +127,20 @@ function merge() {
       result[key] = val;
     }
   }
-  for (var i = 0, l = arguments.length; i < l; i++) {
-    forEach(arguments[i], assignValue);
+  for (var i2 = 0, l = arguments.length; i2 < l; i2++) {
+    forEach(arguments[i2], assignValue);
   }
   return result;
 }
-function extend(a, b, thisArg) {
+function extend(a2, b, thisArg) {
   forEach(b, function assignValue(val, key) {
     if (thisArg && typeof val === "function") {
-      a[key] = bind$1(val, thisArg);
+      a2[key] = bind$1(val, thisArg);
     } else {
-      a[key] = val;
+      a2[key] = val;
     }
   });
-  return a;
+  return a2;
 }
 function stripBOM(content) {
   if (content.charCodeAt(0) === 65279) {
@@ -153,15 +154,15 @@ var utils$9 = {
   isBuffer,
   isFormData,
   isArrayBufferView,
-  isString,
+  isString: isString$1,
   isNumber,
-  isObject,
-  isPlainObject,
-  isUndefined,
+  isObject: isObject$1,
+  isPlainObject: isPlainObject$1,
+  isUndefined: isUndefined$1,
   isDate,
   isFile,
   isBlob,
-  isFunction,
+  isFunction: isFunction$1,
   isStream,
   isURLSearchParams,
   isStandardBrowserEnv,
@@ -428,14 +429,14 @@ function requireParseHeaders() {
     var parsed = {};
     var key;
     var val;
-    var i;
+    var i2;
     if (!headers) {
       return parsed;
     }
     utils2.forEach(headers.split("\n"), function parser(line) {
-      i = line.indexOf(":");
-      key = utils2.trim(line.substr(0, i)).toLowerCase();
-      val = utils2.trim(line.substr(i + 1));
+      i2 = line.indexOf(":");
+      key = utils2.trim(line.substr(0, i2)).toLowerCase();
+      val = utils2.trim(line.substr(i2 + 1));
       if (key) {
         if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
           return;
@@ -652,9 +653,9 @@ function stringifySafely(rawValue, parser, encoder) {
     try {
       (parser || JSON.parse)(rawValue);
       return utils$5.trim(rawValue);
-    } catch (e) {
-      if (e.name !== "SyntaxError") {
-        throw e;
+    } catch (e2) {
+      if (e2.name !== "SyntaxError") {
+        throw e2;
       }
     }
   }
@@ -694,12 +695,12 @@ var defaults$3 = {
     if (strictJSONParsing || forcedJSONParsing && utils$5.isString(data) && data.length) {
       try {
         return JSON.parse(data);
-      } catch (e) {
+      } catch (e2) {
         if (strictJSONParsing) {
-          if (e.name === "SyntaxError") {
-            throw enhanceError2(e, this, "E_JSON_PARSE");
+          if (e2.name === "SyntaxError") {
+            throw enhanceError2(e2, this, "E_JSON_PARSE");
           }
-          throw e;
+          throw e2;
         }
       }
     }
@@ -885,9 +886,9 @@ const require$$0 = {
 };
 var pkg = require$$0;
 var validators$1 = {};
-["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
+["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i2) {
   validators$1[type] = function validator2(thing) {
-    return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+    return typeof thing === type || "a" + (i2 < 1 ? "n " : " ") + type;
   };
 });
 var deprecatedWarnings = {};
@@ -895,10 +896,10 @@ var currentVerArr = pkg.version.split(".");
 function isOlderVersion(version2, thanVersion) {
   var pkgVersionArr = thanVersion ? thanVersion.split(".") : currentVerArr;
   var destVer = version2.split(".");
-  for (var i = 0; i < 3; i++) {
-    if (pkgVersionArr[i] > destVer[i]) {
+  for (var i2 = 0; i2 < 3; i2++) {
+    if (pkgVersionArr[i2] > destVer[i2]) {
       return true;
-    } else if (pkgVersionArr[i] < destVer[i]) {
+    } else if (pkgVersionArr[i2] < destVer[i2]) {
       return false;
     }
   }
@@ -930,9 +931,9 @@ function assertOptions(options, schema, allowUnknown) {
     throw new TypeError("options must be an object");
   }
   var keys = Object.keys(options);
-  var i = keys.length;
-  while (i-- > 0) {
-    var opt = keys[i];
+  var i2 = keys.length;
+  while (i2-- > 0) {
+    var opt = keys[i2];
     var validator2 = schema[opt];
     if (validator2) {
       var value = options[opt];
@@ -1102,8 +1103,8 @@ function requireCancelToken() {
   };
   CancelToken.source = function source() {
     var cancel;
-    var token = new CancelToken(function executor(c) {
-      cancel = c;
+    var token = new CancelToken(function executor(c2) {
+      cancel = c2;
     });
     return {
       token,
@@ -1180,11 +1181,11 @@ const useFlashSales = (pagination) => {
 const FlashSalePage = () => {
   const navigate = reactRouterDom.useNavigate();
   const limit = 20;
-  const [pagination, setPagination] = react.useState({
+  const [pagination, setPagination] = React.useState({
     pageSize: limit,
     pageIndex: 0
   });
-  const offset = react.useMemo(() => {
+  const offset = React.useMemo(() => {
     return pagination.pageIndex * limit;
   }, [pagination]);
   const columnHelper2 = ui.createDataTableColumnHelper();
@@ -1229,7 +1230,7 @@ const FlashSalePage = () => {
   const table = ui.useDataTable({
     data: (data == null ? void 0 : data.campaigns) || [],
     columns: columns2,
-    getRowId: (campaign) => campaign.id,
+    getRowId: (campaign2) => campaign2.id,
     pagination: {
       state: pagination,
       onPaginationChange: setPagination
@@ -1257,6 +1258,1887 @@ const config$1 = adminSdk.defineRouteConfig({
   label: "Flash Sale",
   icon: icons.Sparkles
 });
+var isCheckBoxInput = (element) => element.type === "checkbox";
+var isDateObject = (value) => value instanceof Date;
+var isNullOrUndefined = (value) => value == null;
+const isObjectType = (value) => typeof value === "object";
+var isObject = (value) => !isNullOrUndefined(value) && !Array.isArray(value) && isObjectType(value) && !isDateObject(value);
+var getEventValue = (event) => isObject(event) && event.target ? isCheckBoxInput(event.target) ? event.target.checked : event.target.value : event;
+var getNodeParentName = (name) => name.substring(0, name.search(/\.\d+(\.|$)/)) || name;
+var isNameInFieldArray = (names, name) => names.has(getNodeParentName(name));
+var isPlainObject = (tempObject) => {
+  const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
+  return isObject(prototypeCopy) && prototypeCopy.hasOwnProperty("isPrototypeOf");
+};
+var isWeb = typeof window !== "undefined" && typeof window.HTMLElement !== "undefined" && typeof document !== "undefined";
+function cloneObject(data) {
+  let copy;
+  const isArray2 = Array.isArray(data);
+  if (data instanceof Date) {
+    copy = new Date(data);
+  } else if (data instanceof Set) {
+    copy = new Set(data);
+  } else if (!(isWeb && (data instanceof Blob || data instanceof FileList)) && (isArray2 || isObject(data))) {
+    copy = isArray2 ? [] : {};
+    if (!isArray2 && !isPlainObject(data)) {
+      copy = data;
+    } else {
+      for (const key in data) {
+        if (data.hasOwnProperty(key)) {
+          copy[key] = cloneObject(data[key]);
+        }
+      }
+    }
+  } else {
+    return data;
+  }
+  return copy;
+}
+var compact = (value) => Array.isArray(value) ? value.filter(Boolean) : [];
+var isUndefined = (val) => val === void 0;
+var get = (object, path, defaultValue) => {
+  if (!path || !isObject(object)) {
+    return defaultValue;
+  }
+  const result = compact(path.split(/[,[\].]+?/)).reduce((result2, key) => isNullOrUndefined(result2) ? result2 : result2[key], object);
+  return isUndefined(result) || result === object ? isUndefined(object[path]) ? defaultValue : object[path] : result;
+};
+var isBoolean = (value) => typeof value === "boolean";
+const EVENTS = {
+  BLUR: "blur",
+  FOCUS_OUT: "focusout",
+  CHANGE: "change"
+};
+const VALIDATION_MODE = {
+  onBlur: "onBlur",
+  onChange: "onChange",
+  onSubmit: "onSubmit",
+  onTouched: "onTouched",
+  all: "all"
+};
+const INPUT_VALIDATION_RULES = {
+  max: "max",
+  min: "min",
+  maxLength: "maxLength",
+  minLength: "minLength",
+  pattern: "pattern",
+  required: "required",
+  validate: "validate"
+};
+const HookFormContext = React__default.default.createContext(null);
+const useFormContext = () => React__default.default.useContext(HookFormContext);
+var getProxyFormState = (formState, control, localProxyFormState, isRoot = true) => {
+  const result = {
+    defaultValues: control._defaultValues
+  };
+  for (const key in formState) {
+    Object.defineProperty(result, key, {
+      get: () => {
+        const _key = key;
+        if (control._proxyFormState[_key] !== VALIDATION_MODE.all) {
+          control._proxyFormState[_key] = !isRoot || VALIDATION_MODE.all;
+        }
+        localProxyFormState && (localProxyFormState[_key] = true);
+        return formState[_key];
+      }
+    });
+  }
+  return result;
+};
+var isEmptyObject = (value) => isObject(value) && !Object.keys(value).length;
+var shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, isRoot) => {
+  updateFormState(formStateData);
+  const { name, ...formState } = formStateData;
+  return isEmptyObject(formState) || Object.keys(formState).length >= Object.keys(_proxyFormState).length || Object.keys(formState).find((key) => _proxyFormState[key] === (!isRoot || VALIDATION_MODE.all));
+};
+var convertToArrayPayload = (value) => Array.isArray(value) ? value : [value];
+var shouldSubscribeByName = (name, signalName, exact) => !name || !signalName || name === signalName || convertToArrayPayload(name).some((currentName) => currentName && (exact ? currentName === signalName : currentName.startsWith(signalName) || signalName.startsWith(currentName)));
+function useSubscribe(props) {
+  const _props = React__default.default.useRef(props);
+  _props.current = props;
+  React__default.default.useEffect(() => {
+    const subscription = !props.disabled && _props.current.subject && _props.current.subject.subscribe({
+      next: _props.current.next
+    });
+    return () => {
+      subscription && subscription.unsubscribe();
+    };
+  }, [props.disabled]);
+}
+function useFormState(props) {
+  const methods = useFormContext();
+  const { control = methods.control, disabled, name, exact } = props || {};
+  const [formState, updateFormState] = React__default.default.useState(control._formState);
+  const _mounted = React__default.default.useRef(true);
+  const _localProxyFormState = React__default.default.useRef({
+    isDirty: false,
+    isLoading: false,
+    dirtyFields: false,
+    touchedFields: false,
+    isValidating: false,
+    isValid: false,
+    errors: false
+  });
+  const _name = React__default.default.useRef(name);
+  _name.current = name;
+  useSubscribe({
+    disabled,
+    next: (value) => _mounted.current && shouldSubscribeByName(_name.current, value.name, exact) && shouldRenderFormState(value, _localProxyFormState.current, control._updateFormState) && updateFormState({
+      ...control._formState,
+      ...value
+    }),
+    subject: control._subjects.state
+  });
+  React__default.default.useEffect(() => {
+    _mounted.current = true;
+    _localProxyFormState.current.isValid && control._updateValid(true);
+    return () => {
+      _mounted.current = false;
+    };
+  }, [control]);
+  return getProxyFormState(formState, control, _localProxyFormState.current, false);
+}
+var isString = (value) => typeof value === "string";
+var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) => {
+  if (isString(names)) {
+    isGlobal && _names.watch.add(names);
+    return get(formValues, names, defaultValue);
+  }
+  if (Array.isArray(names)) {
+    return names.map((fieldName) => (isGlobal && _names.watch.add(fieldName), get(formValues, fieldName)));
+  }
+  isGlobal && (_names.watchAll = true);
+  return formValues;
+};
+function useWatch(props) {
+  const methods = useFormContext();
+  const { control = methods.control, name, defaultValue, disabled, exact } = props || {};
+  const _name = React__default.default.useRef(name);
+  _name.current = name;
+  useSubscribe({
+    disabled,
+    subject: control._subjects.values,
+    next: (formState) => {
+      if (shouldSubscribeByName(_name.current, formState.name, exact)) {
+        updateValue(cloneObject(generateWatchOutput(_name.current, control._names, formState.values || control._formValues, false, defaultValue)));
+      }
+    }
+  });
+  const [value, updateValue] = React__default.default.useState(control._getWatch(name, defaultValue));
+  React__default.default.useEffect(() => control._removeUnmounted());
+  return value;
+}
+var isKey = (value) => /^\w*$/.test(value);
+var stringToPath = (input) => compact(input.replace(/["|']|\]/g, "").split(/\.|\[/));
+var set = (object, path, value) => {
+  let index = -1;
+  const tempPath = isKey(path) ? [path] : stringToPath(path);
+  const length = tempPath.length;
+  const lastIndex = length - 1;
+  while (++index < length) {
+    const key = tempPath[index];
+    let newValue = value;
+    if (index !== lastIndex) {
+      const objValue = object[key];
+      newValue = isObject(objValue) || Array.isArray(objValue) ? objValue : !isNaN(+tempPath[index + 1]) ? [] : {};
+    }
+    object[key] = newValue;
+    object = object[key];
+  }
+  return object;
+};
+function useController(props) {
+  const methods = useFormContext();
+  const { name, disabled, control = methods.control, shouldUnregister } = props;
+  const isArrayField = isNameInFieldArray(control._names.array, name);
+  const value = useWatch({
+    control,
+    name,
+    defaultValue: get(control._formValues, name, get(control._defaultValues, name, props.defaultValue)),
+    exact: true
+  });
+  const formState = useFormState({
+    control,
+    name
+  });
+  const _registerProps = React__default.default.useRef(control.register(name, {
+    ...props.rules,
+    value,
+    ...isBoolean(props.disabled) ? { disabled: props.disabled } : {}
+  }));
+  React__default.default.useEffect(() => {
+    const _shouldUnregisterField = control._options.shouldUnregister || shouldUnregister;
+    const updateMounted = (name2, value2) => {
+      const field = get(control._fields, name2);
+      if (field) {
+        field._f.mount = value2;
+      }
+    };
+    updateMounted(name, true);
+    if (_shouldUnregisterField) {
+      const value2 = cloneObject(get(control._options.defaultValues, name));
+      set(control._defaultValues, name, value2);
+      if (isUndefined(get(control._formValues, name))) {
+        set(control._formValues, name, value2);
+      }
+    }
+    return () => {
+      (isArrayField ? _shouldUnregisterField && !control._state.action : _shouldUnregisterField) ? control.unregister(name) : updateMounted(name, false);
+    };
+  }, [name, control, isArrayField, shouldUnregister]);
+  React__default.default.useEffect(() => {
+    if (get(control._fields, name)) {
+      control._updateDisabledField({
+        disabled,
+        fields: control._fields,
+        name,
+        value: get(control._fields, name)._f.value
+      });
+    }
+  }, [disabled, name, control]);
+  return {
+    field: {
+      name,
+      value,
+      ...isBoolean(disabled) || isBoolean(formState.disabled) ? { disabled: formState.disabled || disabled } : {},
+      onChange: React__default.default.useCallback((event) => _registerProps.current.onChange({
+        target: {
+          value: getEventValue(event),
+          name
+        },
+        type: EVENTS.CHANGE
+      }), [name]),
+      onBlur: React__default.default.useCallback(() => _registerProps.current.onBlur({
+        target: {
+          value: get(control._formValues, name),
+          name
+        },
+        type: EVENTS.BLUR
+      }), [name, control]),
+      ref: (elm) => {
+        const field = get(control._fields, name);
+        if (field && elm) {
+          field._f.ref = {
+            focus: () => elm.focus(),
+            select: () => elm.select(),
+            setCustomValidity: (message) => elm.setCustomValidity(message),
+            reportValidity: () => elm.reportValidity()
+          };
+        }
+      }
+    },
+    formState,
+    fieldState: Object.defineProperties({}, {
+      invalid: {
+        enumerable: true,
+        get: () => !!get(formState.errors, name)
+      },
+      isDirty: {
+        enumerable: true,
+        get: () => !!get(formState.dirtyFields, name)
+      },
+      isTouched: {
+        enumerable: true,
+        get: () => !!get(formState.touchedFields, name)
+      },
+      error: {
+        enumerable: true,
+        get: () => get(formState.errors, name)
+      }
+    })
+  };
+}
+const Controller = (props) => props.render(useController(props));
+var appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria ? {
+  ...errors[name],
+  types: {
+    ...errors[name] && errors[name].types ? errors[name].types : {},
+    [type]: message || true
+  }
+} : {};
+var generateId = () => {
+  const d = typeof performance === "undefined" ? Date.now() : performance.now() * 1e3;
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c2) => {
+    const r = (Math.random() * 16 + d) % 16 | 0;
+    return (c2 == "x" ? r : r & 3 | 8).toString(16);
+  });
+};
+var getFocusFieldName = (name, index, options = {}) => options.shouldFocus || isUndefined(options.shouldFocus) ? options.focusName || `${name}.${isUndefined(options.focusIndex) ? index : options.focusIndex}.` : "";
+var getValidationModes = (mode) => ({
+  isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,
+  isOnBlur: mode === VALIDATION_MODE.onBlur,
+  isOnChange: mode === VALIDATION_MODE.onChange,
+  isOnAll: mode === VALIDATION_MODE.all,
+  isOnTouch: mode === VALIDATION_MODE.onTouched
+});
+var isWatched = (name, _names, isBlurEvent) => !isBlurEvent && (_names.watchAll || _names.watch.has(name) || [..._names.watch].some((watchName) => name.startsWith(watchName) && /^\.\w+/.test(name.slice(watchName.length))));
+const iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {
+  for (const key of fieldsNames || Object.keys(fields)) {
+    const field = get(fields, key);
+    if (field) {
+      const { _f, ...currentField } = field;
+      if (_f) {
+        if (_f.refs && _f.refs[0] && action(_f.refs[0], key) && !abortEarly) {
+          break;
+        } else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) {
+          break;
+        } else {
+          iterateFieldsByAction(currentField, action);
+        }
+      } else if (isObject(currentField)) {
+        iterateFieldsByAction(currentField, action);
+      }
+    }
+  }
+};
+var updateFieldArrayRootError = (errors, error, name) => {
+  const fieldArrayErrors = compact(get(errors, name));
+  set(fieldArrayErrors, "root", error[name]);
+  set(errors, name, fieldArrayErrors);
+  return errors;
+};
+var isFileInput = (element) => element.type === "file";
+var isFunction = (value) => typeof value === "function";
+var isHTMLElement = (value) => {
+  if (!isWeb) {
+    return false;
+  }
+  const owner = value ? value.ownerDocument : 0;
+  return value instanceof (owner && owner.defaultView ? owner.defaultView.HTMLElement : HTMLElement);
+};
+var isMessage = (value) => isString(value);
+var isRadioInput = (element) => element.type === "radio";
+var isRegex = (value) => value instanceof RegExp;
+const defaultResult = {
+  value: false,
+  isValid: false
+};
+const validResult = { value: true, isValid: true };
+var getCheckboxValue = (options) => {
+  if (Array.isArray(options)) {
+    if (options.length > 1) {
+      const values = options.filter((option) => option && option.checked && !option.disabled).map((option) => option.value);
+      return { value: values, isValid: !!values.length };
+    }
+    return options[0].checked && !options[0].disabled ? (
+      // @ts-expect-error expected to work in the browser
+      options[0].attributes && !isUndefined(options[0].attributes.value) ? isUndefined(options[0].value) || options[0].value === "" ? validResult : { value: options[0].value, isValid: true } : validResult
+    ) : defaultResult;
+  }
+  return defaultResult;
+};
+const defaultReturn = {
+  isValid: false,
+  value: null
+};
+var getRadioValue = (options) => Array.isArray(options) ? options.reduce((previous, option) => option && option.checked && !option.disabled ? {
+  isValid: true,
+  value: option.value
+} : previous, defaultReturn) : defaultReturn;
+function getValidateError(result, ref, type = "validate") {
+  if (isMessage(result) || Array.isArray(result) && result.every(isMessage) || isBoolean(result) && !result) {
+    return {
+      type,
+      message: isMessage(result) ? result : "",
+      ref
+    };
+  }
+}
+var getValueAndMessage = (validationData) => isObject(validationData) && !isRegex(validationData) ? validationData : {
+  value: validationData,
+  message: ""
+};
+var validateField = async (field, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {
+  const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, disabled } = field._f;
+  const inputValue = get(formValues, name);
+  if (!mount || disabled) {
+    return {};
+  }
+  const inputRef = refs ? refs[0] : ref;
+  const setCustomValidity = (message) => {
+    if (shouldUseNativeValidation && inputRef.reportValidity) {
+      inputRef.setCustomValidity(isBoolean(message) ? "" : message || "");
+      inputRef.reportValidity();
+    }
+  };
+  const error = {};
+  const isRadio = isRadioInput(ref);
+  const isCheckBox = isCheckBoxInput(ref);
+  const isRadioOrCheckbox2 = isRadio || isCheckBox;
+  const isEmpty = (valueAsNumber || isFileInput(ref)) && isUndefined(ref.value) && isUndefined(inputValue) || isHTMLElement(ref) && ref.value === "" || inputValue === "" || Array.isArray(inputValue) && !inputValue.length;
+  const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);
+  const getMinMaxMessage = (exceedMax, maxLengthMessage, minLengthMessage, maxType = INPUT_VALIDATION_RULES.maxLength, minType = INPUT_VALIDATION_RULES.minLength) => {
+    const message = exceedMax ? maxLengthMessage : minLengthMessage;
+    error[name] = {
+      type: exceedMax ? maxType : minType,
+      message,
+      ref,
+      ...appendErrorsCurry(exceedMax ? maxType : minType, message)
+    };
+  };
+  if (isFieldArray ? !Array.isArray(inputValue) || !inputValue.length : required && (!isRadioOrCheckbox2 && (isEmpty || isNullOrUndefined(inputValue)) || isBoolean(inputValue) && !inputValue || isCheckBox && !getCheckboxValue(refs).isValid || isRadio && !getRadioValue(refs).isValid)) {
+    const { value, message } = isMessage(required) ? { value: !!required, message: required } : getValueAndMessage(required);
+    if (value) {
+      error[name] = {
+        type: INPUT_VALIDATION_RULES.required,
+        message,
+        ref: inputRef,
+        ...appendErrorsCurry(INPUT_VALIDATION_RULES.required, message)
+      };
+      if (!validateAllFieldCriteria) {
+        setCustomValidity(message);
+        return error;
+      }
+    }
+  }
+  if (!isEmpty && (!isNullOrUndefined(min) || !isNullOrUndefined(max))) {
+    let exceedMax;
+    let exceedMin;
+    const maxOutput = getValueAndMessage(max);
+    const minOutput = getValueAndMessage(min);
+    if (!isNullOrUndefined(inputValue) && !isNaN(inputValue)) {
+      const valueNumber = ref.valueAsNumber || (inputValue ? +inputValue : inputValue);
+      if (!isNullOrUndefined(maxOutput.value)) {
+        exceedMax = valueNumber > maxOutput.value;
+      }
+      if (!isNullOrUndefined(minOutput.value)) {
+        exceedMin = valueNumber < minOutput.value;
+      }
+    } else {
+      const valueDate = ref.valueAsDate || new Date(inputValue);
+      const convertTimeToDate = (time) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + time);
+      const isTime = ref.type == "time";
+      const isWeek = ref.type == "week";
+      if (isString(maxOutput.value) && inputValue) {
+        exceedMax = isTime ? convertTimeToDate(inputValue) > convertTimeToDate(maxOutput.value) : isWeek ? inputValue > maxOutput.value : valueDate > new Date(maxOutput.value);
+      }
+      if (isString(minOutput.value) && inputValue) {
+        exceedMin = isTime ? convertTimeToDate(inputValue) < convertTimeToDate(minOutput.value) : isWeek ? inputValue < minOutput.value : valueDate < new Date(minOutput.value);
+      }
+    }
+    if (exceedMax || exceedMin) {
+      getMinMaxMessage(!!exceedMax, maxOutput.message, minOutput.message, INPUT_VALIDATION_RULES.max, INPUT_VALIDATION_RULES.min);
+      if (!validateAllFieldCriteria) {
+        setCustomValidity(error[name].message);
+        return error;
+      }
+    }
+  }
+  if ((maxLength || minLength) && !isEmpty && (isString(inputValue) || isFieldArray && Array.isArray(inputValue))) {
+    const maxLengthOutput = getValueAndMessage(maxLength);
+    const minLengthOutput = getValueAndMessage(minLength);
+    const exceedMax = !isNullOrUndefined(maxLengthOutput.value) && inputValue.length > +maxLengthOutput.value;
+    const exceedMin = !isNullOrUndefined(minLengthOutput.value) && inputValue.length < +minLengthOutput.value;
+    if (exceedMax || exceedMin) {
+      getMinMaxMessage(exceedMax, maxLengthOutput.message, minLengthOutput.message);
+      if (!validateAllFieldCriteria) {
+        setCustomValidity(error[name].message);
+        return error;
+      }
+    }
+  }
+  if (pattern && !isEmpty && isString(inputValue)) {
+    const { value: patternValue, message } = getValueAndMessage(pattern);
+    if (isRegex(patternValue) && !inputValue.match(patternValue)) {
+      error[name] = {
+        type: INPUT_VALIDATION_RULES.pattern,
+        message,
+        ref,
+        ...appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, message)
+      };
+      if (!validateAllFieldCriteria) {
+        setCustomValidity(message);
+        return error;
+      }
+    }
+  }
+  if (validate) {
+    if (isFunction(validate)) {
+      const result = await validate(inputValue, formValues);
+      const validateError = getValidateError(result, inputRef);
+      if (validateError) {
+        error[name] = {
+          ...validateError,
+          ...appendErrorsCurry(INPUT_VALIDATION_RULES.validate, validateError.message)
+        };
+        if (!validateAllFieldCriteria) {
+          setCustomValidity(validateError.message);
+          return error;
+        }
+      }
+    } else if (isObject(validate)) {
+      let validationResult = {};
+      for (const key in validate) {
+        if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) {
+          break;
+        }
+        const validateError = getValidateError(await validate[key](inputValue, formValues), inputRef, key);
+        if (validateError) {
+          validationResult = {
+            ...validateError,
+            ...appendErrorsCurry(key, validateError.message)
+          };
+          setCustomValidity(validateError.message);
+          if (validateAllFieldCriteria) {
+            error[name] = validationResult;
+          }
+        }
+      }
+      if (!isEmptyObject(validationResult)) {
+        error[name] = {
+          ref: inputRef,
+          ...validationResult
+        };
+        if (!validateAllFieldCriteria) {
+          return error;
+        }
+      }
+    }
+  }
+  setCustomValidity(true);
+  return error;
+};
+var appendAt = (data, value) => [
+  ...data,
+  ...convertToArrayPayload(value)
+];
+var fillEmptyArray = (value) => Array.isArray(value) ? value.map(() => void 0) : void 0;
+function insert(data, index, value) {
+  return [
+    ...data.slice(0, index),
+    ...convertToArrayPayload(value),
+    ...data.slice(index)
+  ];
+}
+var moveArrayAt = (data, from, to) => {
+  if (!Array.isArray(data)) {
+    return [];
+  }
+  if (isUndefined(data[to])) {
+    data[to] = void 0;
+  }
+  data.splice(to, 0, data.splice(from, 1)[0]);
+  return data;
+};
+var prependAt = (data, value) => [
+  ...convertToArrayPayload(value),
+  ...convertToArrayPayload(data)
+];
+function removeAtIndexes(data, indexes) {
+  let i2 = 0;
+  const temp = [...data];
+  for (const index of indexes) {
+    temp.splice(index - i2, 1);
+    i2++;
+  }
+  return compact(temp).length ? temp : [];
+}
+var removeArrayAt = (data, index) => isUndefined(index) ? [] : removeAtIndexes(data, convertToArrayPayload(index).sort((a2, b) => a2 - b));
+var swapArrayAt = (data, indexA, indexB) => {
+  [data[indexA], data[indexB]] = [data[indexB], data[indexA]];
+};
+function baseGet(object, updatePath) {
+  const length = updatePath.slice(0, -1).length;
+  let index = 0;
+  while (index < length) {
+    object = isUndefined(object) ? index++ : object[updatePath[index++]];
+  }
+  return object;
+}
+function isEmptyArray(obj) {
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key) && !isUndefined(obj[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function unset(object, path) {
+  const paths = Array.isArray(path) ? path : isKey(path) ? [path] : stringToPath(path);
+  const childObject = paths.length === 1 ? object : baseGet(object, paths);
+  const index = paths.length - 1;
+  const key = paths[index];
+  if (childObject) {
+    delete childObject[key];
+  }
+  if (index !== 0 && (isObject(childObject) && isEmptyObject(childObject) || Array.isArray(childObject) && isEmptyArray(childObject))) {
+    unset(object, paths.slice(0, -1));
+  }
+  return object;
+}
+var updateAt = (fieldValues, index, value) => {
+  fieldValues[index] = value;
+  return fieldValues;
+};
+function useFieldArray(props) {
+  const methods = useFormContext();
+  const { control = methods.control, name, keyName = "id", shouldUnregister } = props;
+  const [fields, setFields] = React__default.default.useState(control._getFieldArray(name));
+  const ids = React__default.default.useRef(control._getFieldArray(name).map(generateId));
+  const _fieldIds = React__default.default.useRef(fields);
+  const _name = React__default.default.useRef(name);
+  const _actioned = React__default.default.useRef(false);
+  _name.current = name;
+  _fieldIds.current = fields;
+  control._names.array.add(name);
+  props.rules && control.register(name, props.rules);
+  useSubscribe({
+    next: ({ values, name: fieldArrayName }) => {
+      if (fieldArrayName === _name.current || !fieldArrayName) {
+        const fieldValues = get(values, _name.current);
+        if (Array.isArray(fieldValues)) {
+          setFields(fieldValues);
+          ids.current = fieldValues.map(generateId);
+        }
+      }
+    },
+    subject: control._subjects.array
+  });
+  const updateValues = React__default.default.useCallback((updatedFieldArrayValues) => {
+    _actioned.current = true;
+    control._updateFieldArray(name, updatedFieldArrayValues);
+  }, [control, name]);
+  const append = (value, options) => {
+    const appendValue = convertToArrayPayload(cloneObject(value));
+    const updatedFieldArrayValues = appendAt(control._getFieldArray(name), appendValue);
+    control._names.focus = getFocusFieldName(name, updatedFieldArrayValues.length - 1, options);
+    ids.current = appendAt(ids.current, appendValue.map(generateId));
+    updateValues(updatedFieldArrayValues);
+    setFields(updatedFieldArrayValues);
+    control._updateFieldArray(name, updatedFieldArrayValues, appendAt, {
+      argA: fillEmptyArray(value)
+    });
+  };
+  const prepend = (value, options) => {
+    const prependValue = convertToArrayPayload(cloneObject(value));
+    const updatedFieldArrayValues = prependAt(control._getFieldArray(name), prependValue);
+    control._names.focus = getFocusFieldName(name, 0, options);
+    ids.current = prependAt(ids.current, prependValue.map(generateId));
+    updateValues(updatedFieldArrayValues);
+    setFields(updatedFieldArrayValues);
+    control._updateFieldArray(name, updatedFieldArrayValues, prependAt, {
+      argA: fillEmptyArray(value)
+    });
+  };
+  const remove = (index) => {
+    const updatedFieldArrayValues = removeArrayAt(control._getFieldArray(name), index);
+    ids.current = removeArrayAt(ids.current, index);
+    updateValues(updatedFieldArrayValues);
+    setFields(updatedFieldArrayValues);
+    control._updateFieldArray(name, updatedFieldArrayValues, removeArrayAt, {
+      argA: index
+    });
+  };
+  const insert$1 = (index, value, options) => {
+    const insertValue = convertToArrayPayload(cloneObject(value));
+    const updatedFieldArrayValues = insert(control._getFieldArray(name), index, insertValue);
+    control._names.focus = getFocusFieldName(name, index, options);
+    ids.current = insert(ids.current, index, insertValue.map(generateId));
+    updateValues(updatedFieldArrayValues);
+    setFields(updatedFieldArrayValues);
+    control._updateFieldArray(name, updatedFieldArrayValues, insert, {
+      argA: index,
+      argB: fillEmptyArray(value)
+    });
+  };
+  const swap = (indexA, indexB) => {
+    const updatedFieldArrayValues = control._getFieldArray(name);
+    swapArrayAt(updatedFieldArrayValues, indexA, indexB);
+    swapArrayAt(ids.current, indexA, indexB);
+    updateValues(updatedFieldArrayValues);
+    setFields(updatedFieldArrayValues);
+    control._updateFieldArray(name, updatedFieldArrayValues, swapArrayAt, {
+      argA: indexA,
+      argB: indexB
+    }, false);
+  };
+  const move = (from, to) => {
+    const updatedFieldArrayValues = control._getFieldArray(name);
+    moveArrayAt(updatedFieldArrayValues, from, to);
+    moveArrayAt(ids.current, from, to);
+    updateValues(updatedFieldArrayValues);
+    setFields(updatedFieldArrayValues);
+    control._updateFieldArray(name, updatedFieldArrayValues, moveArrayAt, {
+      argA: from,
+      argB: to
+    }, false);
+  };
+  const update = (index, value) => {
+    const updateValue = cloneObject(value);
+    const updatedFieldArrayValues = updateAt(control._getFieldArray(name), index, updateValue);
+    ids.current = [...updatedFieldArrayValues].map((item, i2) => !item || i2 === index ? generateId() : ids.current[i2]);
+    updateValues(updatedFieldArrayValues);
+    setFields([...updatedFieldArrayValues]);
+    control._updateFieldArray(name, updatedFieldArrayValues, updateAt, {
+      argA: index,
+      argB: updateValue
+    }, true, false);
+  };
+  const replace = (value) => {
+    const updatedFieldArrayValues = convertToArrayPayload(cloneObject(value));
+    ids.current = updatedFieldArrayValues.map(generateId);
+    updateValues([...updatedFieldArrayValues]);
+    setFields([...updatedFieldArrayValues]);
+    control._updateFieldArray(name, [...updatedFieldArrayValues], (data) => data, {}, true, false);
+  };
+  React__default.default.useEffect(() => {
+    control._state.action = false;
+    isWatched(name, control._names) && control._subjects.state.next({
+      ...control._formState
+    });
+    if (_actioned.current && (!getValidationModes(control._options.mode).isOnSubmit || control._formState.isSubmitted)) {
+      if (control._options.resolver) {
+        control._executeSchema([name]).then((result) => {
+          const error = get(result.errors, name);
+          const existingError = get(control._formState.errors, name);
+          if (existingError ? !error && existingError.type || error && (existingError.type !== error.type || existingError.message !== error.message) : error && error.type) {
+            error ? set(control._formState.errors, name, error) : unset(control._formState.errors, name);
+            control._subjects.state.next({
+              errors: control._formState.errors
+            });
+          }
+        });
+      } else {
+        const field = get(control._fields, name);
+        if (field && field._f) {
+          validateField(field, control._formValues, control._options.criteriaMode === VALIDATION_MODE.all, control._options.shouldUseNativeValidation, true).then((error) => !isEmptyObject(error) && control._subjects.state.next({
+            errors: updateFieldArrayRootError(control._formState.errors, error, name)
+          }));
+        }
+      }
+    }
+    control._subjects.values.next({
+      name,
+      values: { ...control._formValues }
+    });
+    control._names.focus && iterateFieldsByAction(control._fields, (ref, key) => {
+      if (control._names.focus && key.startsWith(control._names.focus) && ref.focus) {
+        ref.focus();
+        return 1;
+      }
+      return;
+    });
+    control._names.focus = "";
+    control._updateValid();
+    _actioned.current = false;
+  }, [fields, name, control]);
+  React__default.default.useEffect(() => {
+    !get(control._formValues, name) && control._updateFieldArray(name);
+    return () => {
+      (control._options.shouldUnregister || shouldUnregister) && control.unregister(name);
+    };
+  }, [name, control, keyName, shouldUnregister]);
+  return {
+    swap: React__default.default.useCallback(swap, [updateValues, name, control]),
+    move: React__default.default.useCallback(move, [updateValues, name, control]),
+    prepend: React__default.default.useCallback(prepend, [updateValues, name, control]),
+    append: React__default.default.useCallback(append, [updateValues, name, control]),
+    remove: React__default.default.useCallback(remove, [updateValues, name, control]),
+    insert: React__default.default.useCallback(insert$1, [updateValues, name, control]),
+    update: React__default.default.useCallback(update, [updateValues, name, control]),
+    replace: React__default.default.useCallback(replace, [updateValues, name, control]),
+    fields: React__default.default.useMemo(() => fields.map((field, index) => ({
+      ...field,
+      [keyName]: ids.current[index] || generateId()
+    })), [fields, keyName])
+  };
+}
+var createSubject = () => {
+  let _observers = [];
+  const next = (value) => {
+    for (const observer of _observers) {
+      observer.next && observer.next(value);
+    }
+  };
+  const subscribe = (observer) => {
+    _observers.push(observer);
+    return {
+      unsubscribe: () => {
+        _observers = _observers.filter((o2) => o2 !== observer);
+      }
+    };
+  };
+  const unsubscribe = () => {
+    _observers = [];
+  };
+  return {
+    get observers() {
+      return _observers;
+    },
+    next,
+    subscribe,
+    unsubscribe
+  };
+};
+var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);
+function deepEqual(object1, object2) {
+  if (isPrimitive(object1) || isPrimitive(object2)) {
+    return object1 === object2;
+  }
+  if (isDateObject(object1) && isDateObject(object2)) {
+    return object1.getTime() === object2.getTime();
+  }
+  const keys1 = Object.keys(object1);
+  const keys2 = Object.keys(object2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    const val1 = object1[key];
+    if (!keys2.includes(key)) {
+      return false;
+    }
+    if (key !== "ref") {
+      const val2 = object2[key];
+      if (isDateObject(val1) && isDateObject(val2) || isObject(val1) && isObject(val2) || Array.isArray(val1) && Array.isArray(val2) ? !deepEqual(val1, val2) : val1 !== val2) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var isMultipleSelect = (element) => element.type === `select-multiple`;
+var isRadioOrCheckbox = (ref) => isRadioInput(ref) || isCheckBoxInput(ref);
+var live = (ref) => isHTMLElement(ref) && ref.isConnected;
+var objectHasFunction = (data) => {
+  for (const key in data) {
+    if (isFunction(data[key])) {
+      return true;
+    }
+  }
+  return false;
+};
+function markFieldsDirty(data, fields = {}) {
+  const isParentNodeArray = Array.isArray(data);
+  if (isObject(data) || isParentNodeArray) {
+    for (const key in data) {
+      if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) {
+        fields[key] = Array.isArray(data[key]) ? [] : {};
+        markFieldsDirty(data[key], fields[key]);
+      } else if (!isNullOrUndefined(data[key])) {
+        fields[key] = true;
+      }
+    }
+  }
+  return fields;
+}
+function getDirtyFieldsFromDefaultValues(data, formValues, dirtyFieldsFromValues) {
+  const isParentNodeArray = Array.isArray(data);
+  if (isObject(data) || isParentNodeArray) {
+    for (const key in data) {
+      if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) {
+        if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) {
+          dirtyFieldsFromValues[key] = Array.isArray(data[key]) ? markFieldsDirty(data[key], []) : { ...markFieldsDirty(data[key]) };
+        } else {
+          getDirtyFieldsFromDefaultValues(data[key], isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
+        }
+      } else {
+        dirtyFieldsFromValues[key] = !deepEqual(data[key], formValues[key]);
+      }
+    }
+  }
+  return dirtyFieldsFromValues;
+}
+var getDirtyFields = (defaultValues, formValues) => getDirtyFieldsFromDefaultValues(defaultValues, formValues, markFieldsDirty(formValues));
+var getFieldValueAs = (value, { valueAsNumber, valueAsDate, setValueAs }) => isUndefined(value) ? value : valueAsNumber ? value === "" ? NaN : value ? +value : value : valueAsDate && isString(value) ? new Date(value) : setValueAs ? setValueAs(value) : value;
+function getFieldValue(_f) {
+  const ref = _f.ref;
+  if (_f.refs ? _f.refs.every((ref2) => ref2.disabled) : ref.disabled) {
+    return;
+  }
+  if (isFileInput(ref)) {
+    return ref.files;
+  }
+  if (isRadioInput(ref)) {
+    return getRadioValue(_f.refs).value;
+  }
+  if (isMultipleSelect(ref)) {
+    return [...ref.selectedOptions].map(({ value }) => value);
+  }
+  if (isCheckBoxInput(ref)) {
+    return getCheckboxValue(_f.refs).value;
+  }
+  return getFieldValueAs(isUndefined(ref.value) ? _f.ref.value : ref.value, _f);
+}
+var getResolverOptions = (fieldsNames, _fields, criteriaMode, shouldUseNativeValidation) => {
+  const fields = {};
+  for (const name of fieldsNames) {
+    const field = get(_fields, name);
+    field && set(fields, name, field._f);
+  }
+  return {
+    criteriaMode,
+    names: [...fieldsNames],
+    fields,
+    shouldUseNativeValidation
+  };
+};
+var getRuleValue = (rule) => isUndefined(rule) ? rule : isRegex(rule) ? rule.source : isObject(rule) ? isRegex(rule.value) ? rule.value.source : rule.value : rule;
+var hasValidation = (options) => options.mount && (options.required || options.min || options.max || options.maxLength || options.minLength || options.pattern || options.validate);
+function schemaErrorLookup(errors, _fields, name) {
+  const error = get(errors, name);
+  if (error || isKey(name)) {
+    return {
+      error,
+      name
+    };
+  }
+  const names = name.split(".");
+  while (names.length) {
+    const fieldName = names.join(".");
+    const field = get(_fields, fieldName);
+    const foundError = get(errors, fieldName);
+    if (field && !Array.isArray(field) && name !== fieldName) {
+      return { name };
+    }
+    if (foundError && foundError.type) {
+      return {
+        name: fieldName,
+        error: foundError
+      };
+    }
+    names.pop();
+  }
+  return {
+    name
+  };
+}
+var skipValidation = (isBlurEvent, isTouched, isSubmitted, reValidateMode, mode) => {
+  if (mode.isOnAll) {
+    return false;
+  } else if (!isSubmitted && mode.isOnTouch) {
+    return !(isTouched || isBlurEvent);
+  } else if (isSubmitted ? reValidateMode.isOnBlur : mode.isOnBlur) {
+    return !isBlurEvent;
+  } else if (isSubmitted ? reValidateMode.isOnChange : mode.isOnChange) {
+    return isBlurEvent;
+  }
+  return true;
+};
+var unsetEmptyArray = (ref, name) => !compact(get(ref, name)).length && unset(ref, name);
+const defaultOptions = {
+  mode: VALIDATION_MODE.onSubmit,
+  reValidateMode: VALIDATION_MODE.onChange,
+  shouldFocusError: true
+};
+function createFormControl(props = {}, flushRootRender) {
+  let _options = {
+    ...defaultOptions,
+    ...props
+  };
+  let _formState = {
+    submitCount: 0,
+    isDirty: false,
+    isLoading: isFunction(_options.defaultValues),
+    isValidating: false,
+    isSubmitted: false,
+    isSubmitting: false,
+    isSubmitSuccessful: false,
+    isValid: false,
+    touchedFields: {},
+    dirtyFields: {},
+    errors: _options.errors || {},
+    disabled: false
+  };
+  let _fields = {};
+  let _defaultValues = isObject(_options.defaultValues) || isObject(_options.values) ? cloneObject(_options.defaultValues || _options.values) || {} : {};
+  let _formValues = _options.shouldUnregister ? {} : cloneObject(_defaultValues);
+  let _state = {
+    action: false,
+    mount: false,
+    watch: false
+  };
+  let _names = {
+    mount: /* @__PURE__ */ new Set(),
+    unMount: /* @__PURE__ */ new Set(),
+    array: /* @__PURE__ */ new Set(),
+    watch: /* @__PURE__ */ new Set()
+  };
+  let delayErrorCallback;
+  let timer = 0;
+  const _proxyFormState = {
+    isDirty: false,
+    dirtyFields: false,
+    touchedFields: false,
+    isValidating: false,
+    isValid: false,
+    errors: false
+  };
+  const _subjects = {
+    values: createSubject(),
+    array: createSubject(),
+    state: createSubject()
+  };
+  const shouldCaptureDirtyFields = props.resetOptions && props.resetOptions.keepDirtyValues;
+  const validationModeBeforeSubmit = getValidationModes(_options.mode);
+  const validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
+  const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
+  const debounce = (callback) => (wait) => {
+    clearTimeout(timer);
+    timer = setTimeout(callback, wait);
+  };
+  const _updateValid = async (shouldUpdateValid) => {
+    if (_proxyFormState.isValid || shouldUpdateValid) {
+      const isValid2 = _options.resolver ? isEmptyObject((await _executeSchema()).errors) : await executeBuiltInValidation(_fields, true);
+      if (isValid2 !== _formState.isValid) {
+        _subjects.state.next({
+          isValid: isValid2
+        });
+      }
+    }
+  };
+  const _updateIsValidating = (value) => _proxyFormState.isValidating && _subjects.state.next({
+    isValidating: value
+  });
+  const _updateFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {
+    if (args && method) {
+      _state.action = true;
+      if (shouldUpdateFieldsAndState && Array.isArray(get(_fields, name))) {
+        const fieldValues = method(get(_fields, name), args.argA, args.argB);
+        shouldSetValues && set(_fields, name, fieldValues);
+      }
+      if (shouldUpdateFieldsAndState && Array.isArray(get(_formState.errors, name))) {
+        const errors = method(get(_formState.errors, name), args.argA, args.argB);
+        shouldSetValues && set(_formState.errors, name, errors);
+        unsetEmptyArray(_formState.errors, name);
+      }
+      if (_proxyFormState.touchedFields && shouldUpdateFieldsAndState && Array.isArray(get(_formState.touchedFields, name))) {
+        const touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB);
+        shouldSetValues && set(_formState.touchedFields, name, touchedFields);
+      }
+      if (_proxyFormState.dirtyFields) {
+        _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+      }
+      _subjects.state.next({
+        name,
+        isDirty: _getDirty(name, values),
+        dirtyFields: _formState.dirtyFields,
+        errors: _formState.errors,
+        isValid: _formState.isValid
+      });
+    } else {
+      set(_formValues, name, values);
+    }
+  };
+  const updateErrors = (name, error) => {
+    set(_formState.errors, name, error);
+    _subjects.state.next({
+      errors: _formState.errors
+    });
+  };
+  const _setErrors = (errors) => {
+    _formState.errors = errors;
+    _subjects.state.next({
+      errors: _formState.errors,
+      isValid: false
+    });
+  };
+  const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => {
+    const field = get(_fields, name);
+    if (field) {
+      const defaultValue = get(_formValues, name, isUndefined(value) ? get(_defaultValues, name) : value);
+      isUndefined(defaultValue) || ref && ref.defaultChecked || shouldSkipSetValueAs ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f)) : setFieldValue(name, defaultValue);
+      _state.mount && _updateValid();
+    }
+  };
+  const updateTouchAndDirty = (name, fieldValue, isBlurEvent, shouldDirty, shouldRender) => {
+    let shouldUpdateField = false;
+    let isPreviousDirty = false;
+    const output = {
+      name
+    };
+    const disabledField = get(_fields, name) && get(_fields, name)._f.disabled;
+    if (!isBlurEvent || shouldDirty) {
+      if (_proxyFormState.isDirty) {
+        isPreviousDirty = _formState.isDirty;
+        _formState.isDirty = output.isDirty = _getDirty();
+        shouldUpdateField = isPreviousDirty !== output.isDirty;
+      }
+      const isCurrentFieldPristine = disabledField || deepEqual(get(_defaultValues, name), fieldValue);
+      isPreviousDirty = !disabledField && get(_formState.dirtyFields, name);
+      isCurrentFieldPristine || disabledField ? unset(_formState.dirtyFields, name) : set(_formState.dirtyFields, name, true);
+      output.dirtyFields = _formState.dirtyFields;
+      shouldUpdateField = shouldUpdateField || _proxyFormState.dirtyFields && isPreviousDirty !== !isCurrentFieldPristine;
+    }
+    if (isBlurEvent) {
+      const isPreviousFieldTouched = get(_formState.touchedFields, name);
+      if (!isPreviousFieldTouched) {
+        set(_formState.touchedFields, name, isBlurEvent);
+        output.touchedFields = _formState.touchedFields;
+        shouldUpdateField = shouldUpdateField || _proxyFormState.touchedFields && isPreviousFieldTouched !== isBlurEvent;
+      }
+    }
+    shouldUpdateField && shouldRender && _subjects.state.next(output);
+    return shouldUpdateField ? output : {};
+  };
+  const shouldRenderByError = (name, isValid2, error, fieldState) => {
+    const previousFieldError = get(_formState.errors, name);
+    const shouldUpdateValid = _proxyFormState.isValid && isBoolean(isValid2) && _formState.isValid !== isValid2;
+    if (props.delayError && error) {
+      delayErrorCallback = debounce(() => updateErrors(name, error));
+      delayErrorCallback(props.delayError);
+    } else {
+      clearTimeout(timer);
+      delayErrorCallback = null;
+      error ? set(_formState.errors, name, error) : unset(_formState.errors, name);
+    }
+    if ((error ? !deepEqual(previousFieldError, error) : previousFieldError) || !isEmptyObject(fieldState) || shouldUpdateValid) {
+      const updatedFormState = {
+        ...fieldState,
+        ...shouldUpdateValid && isBoolean(isValid2) ? { isValid: isValid2 } : {},
+        errors: _formState.errors,
+        name
+      };
+      _formState = {
+        ..._formState,
+        ...updatedFormState
+      };
+      _subjects.state.next(updatedFormState);
+    }
+    _updateIsValidating(false);
+  };
+  const _executeSchema = async (name) => _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));
+  const executeSchemaAndUpdateState = async (names) => {
+    const { errors } = await _executeSchema(names);
+    if (names) {
+      for (const name of names) {
+        const error = get(errors, name);
+        error ? set(_formState.errors, name, error) : unset(_formState.errors, name);
+      }
+    } else {
+      _formState.errors = errors;
+    }
+    return errors;
+  };
+  const executeBuiltInValidation = async (fields, shouldOnlyCheckValid, context = {
+    valid: true
+  }) => {
+    for (const name in fields) {
+      const field = fields[name];
+      if (field) {
+        const { _f, ...fieldValue } = field;
+        if (_f) {
+          const isFieldArrayRoot = _names.array.has(_f.name);
+          const fieldError = await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);
+          if (fieldError[_f.name]) {
+            context.valid = false;
+            if (shouldOnlyCheckValid) {
+              break;
+            }
+          }
+          !shouldOnlyCheckValid && (get(fieldError, _f.name) ? isFieldArrayRoot ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name) : set(_formState.errors, _f.name, fieldError[_f.name]) : unset(_formState.errors, _f.name));
+        }
+        fieldValue && await executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context);
+      }
+    }
+    return context.valid;
+  };
+  const _removeUnmounted = () => {
+    for (const name of _names.unMount) {
+      const field = get(_fields, name);
+      field && (field._f.refs ? field._f.refs.every((ref) => !live(ref)) : !live(field._f.ref)) && unregister(name);
+    }
+    _names.unMount = /* @__PURE__ */ new Set();
+  };
+  const _getDirty = (name, data) => (name && data && set(_formValues, name, data), !deepEqual(getValues(), _defaultValues));
+  const _getWatch = (names, defaultValue, isGlobal) => generateWatchOutput(names, _names, {
+    ..._state.mount ? _formValues : isUndefined(defaultValue) ? _defaultValues : isString(names) ? { [names]: defaultValue } : defaultValue
+  }, isGlobal, defaultValue);
+  const _getFieldArray = (name) => compact(get(_state.mount ? _formValues : _defaultValues, name, props.shouldUnregister ? get(_defaultValues, name, []) : []));
+  const setFieldValue = (name, value, options = {}) => {
+    const field = get(_fields, name);
+    let fieldValue = value;
+    if (field) {
+      const fieldReference = field._f;
+      if (fieldReference) {
+        !fieldReference.disabled && set(_formValues, name, getFieldValueAs(value, fieldReference));
+        fieldValue = isHTMLElement(fieldReference.ref) && isNullOrUndefined(value) ? "" : value;
+        if (isMultipleSelect(fieldReference.ref)) {
+          [...fieldReference.ref.options].forEach((optionRef) => optionRef.selected = fieldValue.includes(optionRef.value));
+        } else if (fieldReference.refs) {
+          if (isCheckBoxInput(fieldReference.ref)) {
+            fieldReference.refs.length > 1 ? fieldReference.refs.forEach((checkboxRef) => (!checkboxRef.defaultChecked || !checkboxRef.disabled) && (checkboxRef.checked = Array.isArray(fieldValue) ? !!fieldValue.find((data) => data === checkboxRef.value) : fieldValue === checkboxRef.value)) : fieldReference.refs[0] && (fieldReference.refs[0].checked = !!fieldValue);
+          } else {
+            fieldReference.refs.forEach((radioRef) => radioRef.checked = radioRef.value === fieldValue);
+          }
+        } else if (isFileInput(fieldReference.ref)) {
+          fieldReference.ref.value = "";
+        } else {
+          fieldReference.ref.value = fieldValue;
+          if (!fieldReference.ref.type) {
+            _subjects.values.next({
+              name,
+              values: { ..._formValues }
+            });
+          }
+        }
+      }
+    }
+    (options.shouldDirty || options.shouldTouch) && updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, true);
+    options.shouldValidate && trigger(name);
+  };
+  const setValues = (name, value, options) => {
+    for (const fieldKey in value) {
+      const fieldValue = value[fieldKey];
+      const fieldName = `${name}.${fieldKey}`;
+      const field = get(_fields, fieldName);
+      (_names.array.has(name) || !isPrimitive(fieldValue) || field && !field._f) && !isDateObject(fieldValue) ? setValues(fieldName, fieldValue, options) : setFieldValue(fieldName, fieldValue, options);
+    }
+  };
+  const setValue = (name, value, options = {}) => {
+    const field = get(_fields, name);
+    const isFieldArray = _names.array.has(name);
+    const cloneValue = cloneObject(value);
+    set(_formValues, name, cloneValue);
+    if (isFieldArray) {
+      _subjects.array.next({
+        name,
+        values: { ..._formValues }
+      });
+      if ((_proxyFormState.isDirty || _proxyFormState.dirtyFields) && options.shouldDirty) {
+        _subjects.state.next({
+          name,
+          dirtyFields: getDirtyFields(_defaultValues, _formValues),
+          isDirty: _getDirty(name, cloneValue)
+        });
+      }
+    } else {
+      field && !field._f && !isNullOrUndefined(cloneValue) ? setValues(name, cloneValue, options) : setFieldValue(name, cloneValue, options);
+    }
+    isWatched(name, _names) && _subjects.state.next({ ..._formState });
+    _subjects.values.next({
+      name,
+      values: { ..._formValues }
+    });
+    !_state.mount && flushRootRender();
+  };
+  const onChange = async (event) => {
+    const target = event.target;
+    let name = target.name;
+    let isFieldValueUpdated = true;
+    const field = get(_fields, name);
+    const getCurrentFieldValue = () => target.type ? getFieldValue(field._f) : getEventValue(event);
+    const _updateIsFieldValueUpdated = (fieldValue) => {
+      isFieldValueUpdated = Number.isNaN(fieldValue) || fieldValue === get(_formValues, name, fieldValue);
+    };
+    if (field) {
+      let error;
+      let isValid2;
+      const fieldValue = getCurrentFieldValue();
+      const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
+      const shouldSkipValidation = !hasValidation(field._f) && !_options.resolver && !get(_formState.errors, name) && !field._f.deps || skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);
+      const watched = isWatched(name, _names, isBlurEvent);
+      set(_formValues, name, fieldValue);
+      if (isBlurEvent) {
+        field._f.onBlur && field._f.onBlur(event);
+        delayErrorCallback && delayErrorCallback(0);
+      } else if (field._f.onChange) {
+        field._f.onChange(event);
+      }
+      const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent, false);
+      const shouldRender = !isEmptyObject(fieldState) || watched;
+      !isBlurEvent && _subjects.values.next({
+        name,
+        type: event.type,
+        values: { ..._formValues }
+      });
+      if (shouldSkipValidation) {
+        _proxyFormState.isValid && _updateValid();
+        return shouldRender && _subjects.state.next({ name, ...watched ? {} : fieldState });
+      }
+      !isBlurEvent && watched && _subjects.state.next({ ..._formState });
+      _updateIsValidating(true);
+      if (_options.resolver) {
+        const { errors } = await _executeSchema([name]);
+        _updateIsFieldValueUpdated(fieldValue);
+        if (isFieldValueUpdated) {
+          const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
+          const errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name);
+          error = errorLookupResult.error;
+          name = errorLookupResult.name;
+          isValid2 = isEmptyObject(errors);
+        }
+      } else {
+        error = (await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
+        _updateIsFieldValueUpdated(fieldValue);
+        if (isFieldValueUpdated) {
+          if (error) {
+            isValid2 = false;
+          } else if (_proxyFormState.isValid) {
+            isValid2 = await executeBuiltInValidation(_fields, true);
+          }
+        }
+      }
+      if (isFieldValueUpdated) {
+        field._f.deps && trigger(field._f.deps);
+        shouldRenderByError(name, isValid2, error, fieldState);
+      }
+    }
+  };
+  const _focusInput = (ref, key) => {
+    if (get(_formState.errors, key) && ref.focus) {
+      ref.focus();
+      return 1;
+    }
+    return;
+  };
+  const trigger = async (name, options = {}) => {
+    let isValid2;
+    let validationResult;
+    const fieldNames = convertToArrayPayload(name);
+    _updateIsValidating(true);
+    if (_options.resolver) {
+      const errors = await executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames);
+      isValid2 = isEmptyObject(errors);
+      validationResult = name ? !fieldNames.some((name2) => get(errors, name2)) : isValid2;
+    } else if (name) {
+      validationResult = (await Promise.all(fieldNames.map(async (fieldName) => {
+        const field = get(_fields, fieldName);
+        return await executeBuiltInValidation(field && field._f ? { [fieldName]: field } : field);
+      }))).every(Boolean);
+      !(!validationResult && !_formState.isValid) && _updateValid();
+    } else {
+      validationResult = isValid2 = await executeBuiltInValidation(_fields);
+    }
+    _subjects.state.next({
+      ...!isString(name) || _proxyFormState.isValid && isValid2 !== _formState.isValid ? {} : { name },
+      ..._options.resolver || !name ? { isValid: isValid2 } : {},
+      errors: _formState.errors,
+      isValidating: false
+    });
+    options.shouldFocus && !validationResult && iterateFieldsByAction(_fields, _focusInput, name ? fieldNames : _names.mount);
+    return validationResult;
+  };
+  const getValues = (fieldNames) => {
+    const values = {
+      ..._defaultValues,
+      ..._state.mount ? _formValues : {}
+    };
+    return isUndefined(fieldNames) ? values : isString(fieldNames) ? get(values, fieldNames) : fieldNames.map((name) => get(values, name));
+  };
+  const getFieldState = (name, formState) => ({
+    invalid: !!get((formState || _formState).errors, name),
+    isDirty: !!get((formState || _formState).dirtyFields, name),
+    isTouched: !!get((formState || _formState).touchedFields, name),
+    error: get((formState || _formState).errors, name)
+  });
+  const clearErrors = (name) => {
+    name && convertToArrayPayload(name).forEach((inputName) => unset(_formState.errors, inputName));
+    _subjects.state.next({
+      errors: name ? _formState.errors : {}
+    });
+  };
+  const setError = (name, error, options) => {
+    const ref = (get(_fields, name, { _f: {} })._f || {}).ref;
+    set(_formState.errors, name, {
+      ...error,
+      ref
+    });
+    _subjects.state.next({
+      name,
+      errors: _formState.errors,
+      isValid: false
+    });
+    options && options.shouldFocus && ref && ref.focus && ref.focus();
+  };
+  const watch = (name, defaultValue) => isFunction(name) ? _subjects.values.subscribe({
+    next: (payload) => name(_getWatch(void 0, defaultValue), payload)
+  }) : _getWatch(name, defaultValue, true);
+  const unregister = (name, options = {}) => {
+    for (const fieldName of name ? convertToArrayPayload(name) : _names.mount) {
+      _names.mount.delete(fieldName);
+      _names.array.delete(fieldName);
+      if (!options.keepValue) {
+        unset(_fields, fieldName);
+        unset(_formValues, fieldName);
+      }
+      !options.keepError && unset(_formState.errors, fieldName);
+      !options.keepDirty && unset(_formState.dirtyFields, fieldName);
+      !options.keepTouched && unset(_formState.touchedFields, fieldName);
+      !_options.shouldUnregister && !options.keepDefaultValue && unset(_defaultValues, fieldName);
+    }
+    _subjects.values.next({
+      values: { ..._formValues }
+    });
+    _subjects.state.next({
+      ..._formState,
+      ...!options.keepDirty ? {} : { isDirty: _getDirty() }
+    });
+    !options.keepIsValid && _updateValid();
+  };
+  const _updateDisabledField = ({ disabled, name, field, fields, value }) => {
+    if (isBoolean(disabled)) {
+      const inputValue = disabled ? void 0 : isUndefined(value) ? getFieldValue(field ? field._f : get(fields, name)._f) : value;
+      set(_formValues, name, inputValue);
+      updateTouchAndDirty(name, inputValue, false, false, true);
+    }
+  };
+  const register = (name, options = {}) => {
+    let field = get(_fields, name);
+    const disabledIsDefined = isBoolean(options.disabled);
+    set(_fields, name, {
+      ...field || {},
+      _f: {
+        ...field && field._f ? field._f : { ref: { name } },
+        name,
+        mount: true,
+        ...options
+      }
+    });
+    _names.mount.add(name);
+    if (field) {
+      _updateDisabledField({
+        field,
+        disabled: options.disabled,
+        name
+      });
+    } else {
+      updateValidAndValue(name, true, options.value);
+    }
+    return {
+      ...disabledIsDefined ? { disabled: options.disabled } : {},
+      ..._options.progressive ? {
+        required: !!options.required,
+        min: getRuleValue(options.min),
+        max: getRuleValue(options.max),
+        minLength: getRuleValue(options.minLength),
+        maxLength: getRuleValue(options.maxLength),
+        pattern: getRuleValue(options.pattern)
+      } : {},
+      name,
+      onChange,
+      onBlur: onChange,
+      ref: (ref) => {
+        if (ref) {
+          register(name, options);
+          field = get(_fields, name);
+          const fieldRef = isUndefined(ref.value) ? ref.querySelectorAll ? ref.querySelectorAll("input,select,textarea")[0] || ref : ref : ref;
+          const radioOrCheckbox = isRadioOrCheckbox(fieldRef);
+          const refs = field._f.refs || [];
+          if (radioOrCheckbox ? refs.find((option) => option === fieldRef) : fieldRef === field._f.ref) {
+            return;
+          }
+          set(_fields, name, {
+            _f: {
+              ...field._f,
+              ...radioOrCheckbox ? {
+                refs: [
+                  ...refs.filter(live),
+                  fieldRef,
+                  ...Array.isArray(get(_defaultValues, name)) ? [{}] : []
+                ],
+                ref: { type: fieldRef.type, name }
+              } : { ref: fieldRef }
+            }
+          });
+          updateValidAndValue(name, false, void 0, fieldRef);
+        } else {
+          field = get(_fields, name, {});
+          if (field._f) {
+            field._f.mount = false;
+          }
+          (_options.shouldUnregister || options.shouldUnregister) && !(isNameInFieldArray(_names.array, name) && _state.action) && _names.unMount.add(name);
+        }
+      }
+    };
+  };
+  const _focusError = () => _options.shouldFocusError && iterateFieldsByAction(_fields, _focusInput, _names.mount);
+  const _disableForm = (disabled) => {
+    if (isBoolean(disabled)) {
+      _subjects.state.next({ disabled });
+      iterateFieldsByAction(_fields, (ref, name) => {
+        let requiredDisabledState = disabled;
+        const currentField = get(_fields, name);
+        if (currentField && isBoolean(currentField._f.disabled)) {
+          requiredDisabledState || (requiredDisabledState = currentField._f.disabled);
+        }
+        ref.disabled = requiredDisabledState;
+      }, 0, false);
+    }
+  };
+  const handleSubmit = (onValid, onInvalid) => async (e2) => {
+    if (e2) {
+      e2.preventDefault && e2.preventDefault();
+      e2.persist && e2.persist();
+    }
+    let fieldValues = cloneObject(_formValues);
+    _subjects.state.next({
+      isSubmitting: true
+    });
+    if (_options.resolver) {
+      const { errors, values } = await _executeSchema();
+      _formState.errors = errors;
+      fieldValues = values;
+    } else {
+      await executeBuiltInValidation(_fields);
+    }
+    unset(_formState.errors, "root");
+    if (isEmptyObject(_formState.errors)) {
+      _subjects.state.next({
+        errors: {}
+      });
+      await onValid(fieldValues, e2);
+    } else {
+      if (onInvalid) {
+        await onInvalid({ ..._formState.errors }, e2);
+      }
+      _focusError();
+      setTimeout(_focusError);
+    }
+    _subjects.state.next({
+      isSubmitted: true,
+      isSubmitting: false,
+      isSubmitSuccessful: isEmptyObject(_formState.errors),
+      submitCount: _formState.submitCount + 1,
+      errors: _formState.errors
+    });
+  };
+  const resetField = (name, options = {}) => {
+    if (get(_fields, name)) {
+      if (isUndefined(options.defaultValue)) {
+        setValue(name, get(_defaultValues, name));
+      } else {
+        setValue(name, options.defaultValue);
+        set(_defaultValues, name, options.defaultValue);
+      }
+      if (!options.keepTouched) {
+        unset(_formState.touchedFields, name);
+      }
+      if (!options.keepDirty) {
+        unset(_formState.dirtyFields, name);
+        _formState.isDirty = options.defaultValue ? _getDirty(name, get(_defaultValues, name)) : _getDirty();
+      }
+      if (!options.keepError) {
+        unset(_formState.errors, name);
+        _proxyFormState.isValid && _updateValid();
+      }
+      _subjects.state.next({ ..._formState });
+    }
+  };
+  const _reset = (formValues, keepStateOptions = {}) => {
+    const updatedValues = formValues ? cloneObject(formValues) : _defaultValues;
+    const cloneUpdatedValues = cloneObject(updatedValues);
+    const values = formValues && !isEmptyObject(formValues) ? cloneUpdatedValues : _defaultValues;
+    if (!keepStateOptions.keepDefaultValues) {
+      _defaultValues = updatedValues;
+    }
+    if (!keepStateOptions.keepValues) {
+      if (keepStateOptions.keepDirtyValues || shouldCaptureDirtyFields) {
+        for (const fieldName of _names.mount) {
+          get(_formState.dirtyFields, fieldName) ? set(values, fieldName, get(_formValues, fieldName)) : setValue(fieldName, get(values, fieldName));
+        }
+      } else {
+        if (isWeb && isUndefined(formValues)) {
+          for (const name of _names.mount) {
+            const field = get(_fields, name);
+            if (field && field._f) {
+              const fieldReference = Array.isArray(field._f.refs) ? field._f.refs[0] : field._f.ref;
+              if (isHTMLElement(fieldReference)) {
+                const form = fieldReference.closest("form");
+                if (form) {
+                  form.reset();
+                  break;
+                }
+              }
+            }
+          }
+        }
+        _fields = {};
+      }
+      _formValues = props.shouldUnregister ? keepStateOptions.keepDefaultValues ? cloneObject(_defaultValues) : {} : cloneObject(values);
+      _subjects.array.next({
+        values: { ...values }
+      });
+      _subjects.values.next({
+        values: { ...values }
+      });
+    }
+    _names = {
+      mount: /* @__PURE__ */ new Set(),
+      unMount: /* @__PURE__ */ new Set(),
+      array: /* @__PURE__ */ new Set(),
+      watch: /* @__PURE__ */ new Set(),
+      watchAll: false,
+      focus: ""
+    };
+    !_state.mount && flushRootRender();
+    _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid;
+    _state.watch = !!props.shouldUnregister;
+    _subjects.state.next({
+      submitCount: keepStateOptions.keepSubmitCount ? _formState.submitCount : 0,
+      isDirty: keepStateOptions.keepDirty ? _formState.isDirty : !!(keepStateOptions.keepDefaultValues && !deepEqual(formValues, _defaultValues)),
+      isSubmitted: keepStateOptions.keepIsSubmitted ? _formState.isSubmitted : false,
+      dirtyFields: keepStateOptions.keepDirtyValues ? _formState.dirtyFields : keepStateOptions.keepDefaultValues && formValues ? getDirtyFields(_defaultValues, formValues) : {},
+      touchedFields: keepStateOptions.keepTouched ? _formState.touchedFields : {},
+      errors: keepStateOptions.keepErrors ? _formState.errors : {},
+      isSubmitSuccessful: keepStateOptions.keepIsSubmitSuccessful ? _formState.isSubmitSuccessful : false,
+      isSubmitting: false
+    });
+  };
+  const reset = (formValues, keepStateOptions) => _reset(isFunction(formValues) ? formValues(_formValues) : formValues, keepStateOptions);
+  const setFocus = (name, options = {}) => {
+    const field = get(_fields, name);
+    const fieldReference = field && field._f;
+    if (fieldReference) {
+      const fieldRef = fieldReference.refs ? fieldReference.refs[0] : fieldReference.ref;
+      if (fieldRef.focus) {
+        fieldRef.focus();
+        options.shouldSelect && fieldRef.select();
+      }
+    }
+  };
+  const _updateFormState = (updatedFormState) => {
+    _formState = {
+      ..._formState,
+      ...updatedFormState
+    };
+  };
+  const _resetDefaultValues = () => isFunction(_options.defaultValues) && _options.defaultValues().then((values) => {
+    reset(values, _options.resetOptions);
+    _subjects.state.next({
+      isLoading: false
+    });
+  });
+  return {
+    control: {
+      register,
+      unregister,
+      getFieldState,
+      handleSubmit,
+      setError,
+      _executeSchema,
+      _getWatch,
+      _getDirty,
+      _updateValid,
+      _removeUnmounted,
+      _updateFieldArray,
+      _updateDisabledField,
+      _getFieldArray,
+      _reset,
+      _resetDefaultValues,
+      _updateFormState,
+      _disableForm,
+      _subjects,
+      _proxyFormState,
+      _setErrors,
+      get _fields() {
+        return _fields;
+      },
+      get _formValues() {
+        return _formValues;
+      },
+      get _state() {
+        return _state;
+      },
+      set _state(value) {
+        _state = value;
+      },
+      get _defaultValues() {
+        return _defaultValues;
+      },
+      get _names() {
+        return _names;
+      },
+      set _names(value) {
+        _names = value;
+      },
+      get _formState() {
+        return _formState;
+      },
+      set _formState(value) {
+        _formState = value;
+      },
+      get _options() {
+        return _options;
+      },
+      set _options(value) {
+        _options = {
+          ..._options,
+          ...value
+        };
+      }
+    },
+    trigger,
+    register,
+    handleSubmit,
+    watch,
+    setValue,
+    getValues,
+    reset,
+    resetField,
+    clearErrors,
+    unregister,
+    setError,
+    setFocus,
+    getFieldState
+  };
+}
+function useForm(props = {}) {
+  const _formControl = React__default.default.useRef();
+  const _values = React__default.default.useRef();
+  const [formState, updateFormState] = React__default.default.useState({
+    isDirty: false,
+    isValidating: false,
+    isLoading: isFunction(props.defaultValues),
+    isSubmitted: false,
+    isSubmitting: false,
+    isSubmitSuccessful: false,
+    isValid: false,
+    submitCount: 0,
+    dirtyFields: {},
+    touchedFields: {},
+    errors: props.errors || {},
+    disabled: false,
+    defaultValues: isFunction(props.defaultValues) ? void 0 : props.defaultValues
+  });
+  if (!_formControl.current) {
+    _formControl.current = {
+      ...createFormControl(props, () => updateFormState((formState2) => ({ ...formState2 }))),
+      formState
+    };
+  }
+  const control = _formControl.current.control;
+  control._options = props;
+  useSubscribe({
+    subject: control._subjects.state,
+    next: (value) => {
+      if (shouldRenderFormState(value, control._proxyFormState, control._updateFormState, true)) {
+        updateFormState({ ...control._formState });
+      }
+    }
+  });
+  React__default.default.useEffect(() => control._disableForm(props.disabled), [control, props.disabled]);
+  React__default.default.useEffect(() => {
+    if (control._proxyFormState.isDirty) {
+      const isDirty2 = control._getDirty();
+      if (isDirty2 !== formState.isDirty) {
+        control._subjects.state.next({
+          isDirty: isDirty2
+        });
+      }
+    }
+  }, [control, formState.isDirty]);
+  React__default.default.useEffect(() => {
+    if (props.values && !deepEqual(props.values, _values.current)) {
+      control._reset(props.values, control._options.resetOptions);
+      _values.current = props.values;
+      updateFormState((state) => ({ ...state }));
+    } else {
+      control._resetDefaultValues();
+    }
+  }, [props.values, control]);
+  React__default.default.useEffect(() => {
+    if (props.errors) {
+      control._setErrors(props.errors);
+    }
+  }, [props.errors, control]);
+  React__default.default.useEffect(() => {
+    if (!control._state.mount) {
+      control._updateValid();
+      control._state.mount = true;
+    }
+    if (control._state.watch) {
+      control._state.watch = false;
+      control._subjects.state.next({ ...control._formState });
+    }
+    control._removeUnmounted();
+  });
+  _formControl.current.formState = getProxyFormState(formState, control);
+  return _formControl.current;
+}
+var t$1 = function(t2, n2, e2) {
+  if (t2 && "reportValidity" in t2) {
+    var i2 = get(e2, n2);
+    t2.setCustomValidity(i2 && i2.message || ""), t2.reportValidity();
+  }
+}, n$1 = function(r, n2) {
+  var e2 = function(e3) {
+    var i3 = n2.fields[e3];
+    i3 && i3.ref && "reportValidity" in i3.ref ? t$1(i3.ref, e3, r) : i3.refs && i3.refs.forEach(function(n3) {
+      return t$1(n3, e3, r);
+    });
+  };
+  for (var i2 in n2.fields) e2(i2);
+}, e = function(r) {
+  return r instanceof Date;
+}, i = function(r) {
+  return null == r;
+}, a = function(r) {
+  return "object" == typeof r;
+}, o = function(r) {
+  return !i(r) && !Array.isArray(r) && a(r) && !e(r);
+}, f = function(r) {
+  return /^\w*$/.test(r);
+}, s = function(r, t2, n2) {
+  for (var e2 = -1, i2 = f(t2) ? [t2] : function(r2) {
+    return t3 = r2.replace(/["|']|\]/g, "").split(/\.|\[/), Array.isArray(t3) ? t3.filter(Boolean) : [];
+    var t3;
+  }(t2), a2 = i2.length, s2 = a2 - 1; ++e2 < a2; ) {
+    var u2 = i2[e2], c2 = n2;
+    if (e2 !== s2) {
+      var l = r[u2];
+      c2 = o(l) || Array.isArray(l) ? l : isNaN(+i2[e2 + 1]) ? {} : [];
+    }
+    r[u2] = c2, r = r[u2];
+  }
+  return r;
+}, u = function(t2, e2) {
+  e2.shouldUseNativeValidation && n$1(t2, e2);
+  var i2 = {};
+  for (var a2 in t2) {
+    var o2 = get(e2.fields, a2), f2 = Object.assign(t2[a2] || {}, { ref: o2 && o2.ref });
+    if (c(e2.names || Object.keys(t2), a2)) {
+      var u2 = Object.assign({}, get(i2, a2));
+      s(u2, "root", f2), s(i2, a2, u2);
+    } else s(i2, a2, f2);
+  }
+  return i2;
+}, c = function(r, t2) {
+  return r.some(function(r2) {
+    return r2.startsWith(t2 + ".");
+  });
+};
+var n = function(e2, o2) {
+  for (var n2 = {}; e2.length; ) {
+    var t2 = e2[0], s2 = t2.code, i2 = t2.message, a2 = t2.path.join(".");
+    if (!n2[a2]) if ("unionErrors" in t2) {
+      var u2 = t2.unionErrors[0].errors[0];
+      n2[a2] = { message: u2.message, type: u2.code };
+    } else n2[a2] = { message: i2, type: s2 };
+    if ("unionErrors" in t2 && t2.unionErrors.forEach(function(r) {
+      return r.errors.forEach(function(r2) {
+        return e2.push(r2);
+      });
+    }), o2) {
+      var c2 = n2[a2].types, f2 = c2 && c2[t2.code];
+      n2[a2] = appendErrors(a2, o2, n2, s2, f2 ? [].concat(f2, t2.message) : t2.message);
+    }
+    e2.shift();
+  }
+  return n2;
+}, t = function(r, t2, s2) {
+  return void 0 === s2 && (s2 = {}), function(i2, a2, u$1) {
+    try {
+      return Promise.resolve(function(o2, n2) {
+        try {
+          var a3 = Promise.resolve(r["sync" === s2.mode ? "parse" : "parseAsync"](i2, t2)).then(function(r2) {
+            return u$1.shouldUseNativeValidation && n$1({}, u$1), { errors: {}, values: s2.raw ? i2 : r2 };
+          });
+        } catch (r2) {
+          return n2(r2);
+        }
+        return a3 && a3.then ? a3.then(void 0, n2) : a3;
+      }(0, function(r2) {
+        if (function(r3) {
+          return null != r3.errors;
+        }(r2)) return { values: {}, errors: u(n(r2.errors, !u$1.shouldUseNativeValidation && "all" === u$1.criteriaMode), u$1) };
+        throw r2;
+      }));
+    } catch (r2) {
+      return Promise.reject(r2);
+    }
+  };
+};
 var util;
 (function(util2) {
   util2.assertEqual = (_) => {
@@ -1284,8 +3166,8 @@ var util;
     return util2.objectValues(filtered);
   };
   util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e) {
-      return obj[e];
+    return util2.objectKeys(obj).map(function(e2) {
+      return obj[e2];
     });
   };
   util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
@@ -1349,8 +3231,8 @@ const ZodParsedType = util.arrayToEnum([
   "set"
 ]);
 const getParsedType = (data) => {
-  const t = typeof data;
-  switch (t) {
+  const t2 = typeof data;
+  switch (t2) {
     case "undefined":
       return ZodParsedType.undefined;
     case "string":
@@ -1450,10 +3332,10 @@ class ZodError extends Error {
           fieldErrors._errors.push(mapper(issue));
         } else {
           let curr = fieldErrors;
-          let i = 0;
-          while (i < issue.path.length) {
-            const el = issue.path[i];
-            const terminal = i === issue.path.length - 1;
+          let i2 = 0;
+          while (i2 < issue.path.length) {
+            const el = issue.path[i2];
+            const terminal = i2 === issue.path.length - 1;
             if (!terminal) {
               curr[el] = curr[el] || { _errors: [] };
             } else {
@@ -1461,7 +3343,7 @@ class ZodError extends Error {
               curr[el]._errors.push(mapper(issue));
             }
             curr = curr[el];
-            i++;
+            i2++;
           }
         }
       }
@@ -1671,12 +3553,12 @@ class ParseStatus {
   }
   static mergeArray(status, results) {
     const arrayValue = [];
-    for (const s of results) {
-      if (s.status === "aborted")
+    for (const s2 of results) {
+      if (s2.status === "aborted")
         return INVALID;
-      if (s.status === "dirty")
+      if (s2.status === "dirty")
         status.dirty();
-      arrayValue.push(s.value);
+      arrayValue.push(s2.value);
     }
     return { status: status.value, value: arrayValue };
   }
@@ -3428,14 +5310,14 @@ class ZodArray extends ZodType {
       }
     }
     if (ctx.common.async) {
-      return Promise.all([...ctx.data].map((item, i) => {
-        return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+      return Promise.all([...ctx.data].map((item, i2) => {
+        return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i2));
       })).then((result2) => {
         return ParseStatus.mergeArray(status, result2);
       });
     }
-    const result = [...ctx.data].map((item, i) => {
-      return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
+    const result = [...ctx.data].map((item, i2) => {
+      return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i2));
     });
     return ParseStatus.mergeArray(status, result);
   }
@@ -4037,17 +5919,17 @@ class ZodDiscriminatedUnion extends ZodType {
     });
   }
 }
-function mergeValues(a, b) {
-  const aType = getParsedType(a);
+function mergeValues(a2, b) {
+  const aType = getParsedType(a2);
   const bType = getParsedType(b);
-  if (a === b) {
-    return { valid: true, data: a };
+  if (a2 === b) {
+    return { valid: true, data: a2 };
   } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
     const bKeys = util.objectKeys(b);
-    const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
-    const newObj = { ...a, ...b };
+    const sharedKeys = util.objectKeys(a2).filter((key) => bKeys.indexOf(key) !== -1);
+    const newObj = { ...a2, ...b };
     for (const key of sharedKeys) {
-      const sharedValue = mergeValues(a[key], b[key]);
+      const sharedValue = mergeValues(a2[key], b[key]);
       if (!sharedValue.valid) {
         return { valid: false };
       }
@@ -4055,12 +5937,12 @@ function mergeValues(a, b) {
     }
     return { valid: true, data: newObj };
   } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
-    if (a.length !== b.length) {
+    if (a2.length !== b.length) {
       return { valid: false };
     }
     const newArray = [];
-    for (let index = 0; index < a.length; index++) {
-      const itemA = a[index];
+    for (let index = 0; index < a2.length; index++) {
+      const itemA = a2[index];
       const itemB = b[index];
       const sharedValue = mergeValues(itemA, itemB);
       if (!sharedValue.valid) {
@@ -4069,8 +5951,8 @@ function mergeValues(a, b) {
       newArray.push(sharedValue.data);
     }
     return { valid: true, data: newArray };
-  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
-    return { valid: true, data: a };
+  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a2 === +b) {
+    return { valid: true, data: a2 };
   } else {
     return { valid: false };
   }
@@ -4364,7 +6246,7 @@ class ZodSet extends ZodType {
       }
       return { status: status.value, value: parsedSet };
     }
-    const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
+    const elements = [...ctx.data.values()].map((item, i2) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i2)));
     if (ctx.common.async) {
       return Promise.all(elements).then((elements2) => finalizeSet(elements2));
     } else {
@@ -4442,13 +6324,13 @@ class ZodFunction extends ZodType {
       const me = this;
       return OK(async function(...args) {
         const error = new ZodError([]);
-        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
-          error.addIssue(makeArgsIssue(args, e));
+        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e2) => {
+          error.addIssue(makeArgsIssue(args, e2));
           throw error;
         });
         const result = await Reflect.apply(fn, this, parsedArgs);
-        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
-          error.addIssue(makeReturnsIssue(result, e));
+        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e2) => {
+          error.addIssue(makeReturnsIssue(result, e2));
           throw error;
         });
         return parsedReturns;
@@ -5023,9 +6905,9 @@ class ZodPipeline extends ZodType {
       }
     }
   }
-  static create(a, b) {
+  static create(a2, b) {
     return new ZodPipeline({
-      in: a,
+      in: a2,
       out: b,
       typeName: ZodFirstPartyTypeKind.ZodPipeline
     });
@@ -5311,7 +7193,7 @@ const ProductSelector = ({
   selectedProductIds,
   onSelectProduct
 }) => {
-  const [search, setSearch] = react.useState("");
+  const [search, setSearch] = React.useState("");
   const debouncedSearchHandler = lodash.debounce((value) => {
     setSearch(value);
   }, 500);
@@ -5322,7 +7204,7 @@ const ProductSelector = ({
       limit: 100
     })
   });
-  const selectableProducts = react.useMemo(() => {
+  const selectableProducts = React.useMemo(() => {
     var _a;
     return (_a = products == null ? void 0 : products.products) == null ? void 0 : _a.filter(
       (product) => !selectedProductIds.includes(product.id)
@@ -5342,7 +7224,7 @@ const ProductSelector = ({
       {
         className: "text-lg py-2",
         placeholder: "Search products...",
-        onChange: (e) => debouncedSearchHandler(e.target.value)
+        onChange: (e2) => debouncedSearchHandler(e2.target.value)
       }
     ),
     /* @__PURE__ */ jsxRuntime.jsx(ui.DataTable, { instance: table, children: /* @__PURE__ */ jsxRuntime.jsx(ui.DataTable.Table, {}) })
@@ -5381,207 +7263,321 @@ const FlashSaleForm = ({
   onCancel,
   disabled = false
 }) => {
-  const [campaign, setCampaign] = react.useState(
-    initialData || {
-      name: "",
-      description: "",
+  var _a;
+  const {
+    control,
+    register,
+    handleSubmit,
+    watch,
+    setValue,
+    formState: { errors }
+  } = useForm({
+    resolver: t(campaignDataSchema),
+    defaultValues: {
+      name: (initialData == null ? void 0 : initialData.name) || "",
+      description: (initialData == null ? void 0 : initialData.description) || "",
       type: "flash-sale",
-      starts_at: "",
-      ends_at: ""
+      starts_at: (initialData == null ? void 0 : initialData.starts_at) || "",
+      ends_at: (initialData == null ? void 0 : initialData.ends_at) || "",
+      products: initialProducts ? Array.from(initialProducts.values()) : []
+    }
+  });
+  const { fields, append, remove } = useFieldArray({
+    control,
+    name: "products"
+  });
+  const [openProductModal, setOpenProductModal] = React.useState(false);
+  const startsAt = watch("starts_at");
+  const endsAt = watch("ends_at");
+  const handleDateTimeChange = (field, type, value) => {
+    const currentValue = watch(field);
+    if (type === "date") {
+      const time = currentValue ? dayjs__default.default(currentValue).format("HH:mm") : field === "starts_at" ? "00:00" : "23:59";
+      setValue(field, `${value}T${time}`);
+    } else {
+      const date = currentValue ? dayjs__default.default(currentValue).format("YYYY-MM-DD") : dayjs__default.default().format("YYYY-MM-DD");
+      setValue(field, `${date}T${value}`);
     }
-  );
-  const handleCampaignChange = (name, value) => {
-    setCampaign((prev) => ({ ...prev, [name]: value }));
   };
-  const [products, setProducts] = react.useState(
-    initialProducts || /* @__PURE__ */ new Map()
-  );
-  const handleProductChange = (product) => {
-    setProducts((prev) => {
-      const newProducts = new Map(prev);
-      newProducts.set(product.product.id, product);
-      return newProducts;
-    });
+  const onFormSubmit = (data) => {
+    onSubmit(data);
   };
-  const [openProductModal, setOpenProductModal] = react.useState(false);
-  const handleSave = (event) => {
-    event.preventDefault();
-    const campaignData = campaignDataSchema.safeParse({
-      ...campaign,
-      products: Array.from(products.values())
+  const onFormError = () => {
+    const errorMessages = Object.entries(errors).map(([key, value]) => {
+      var _a2;
+      if (key === "products" && Array.isArray(value)) {
+        return value.map(
+          (item, index) => item ? `Product ${index + 1}: ${Object.values(item).join(", ")}` : ""
+        ).filter(Boolean).join(", ");
+      }
+      return (value == null ? void 0 : value.message) || ((_a2 = value == null ? void 0 : value.root) == null ? void 0 : _a2.message);
+    }).filter(Boolean).join(", ");
+    ui.toast.error("Invalid data", {
+      description: errorMessages
     });
-    if (!campaignData.success) {
-      ui.toast.error("Invalid data", {
-        description: campaignData.error.issues.map((error) => error.message).join(", ")
-      });
-      return;
-    }
-    onSubmit(campaignData.data);
   };
   return /* @__PURE__ */ jsxRuntime.jsxs(ui.Container, { children: [
     /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between", children: [
       /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "text-xl font-semibold", children: "Flash sale campaign" }),
       /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { variant: "transparent", onClick: onCancel, children: "Cancel" })
     ] }),
-    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-4 my-8", children: [
-      /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { children: "Name" }),
-      /* @__PURE__ */ jsxRuntime.jsx(
-        ui.Input,
-        {
-          name: "name",
-          value: campaign.name,
-          onChange: (e) => handleCampaignChange("name", e.target.value),
-          disabled
-        }
-      ),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { children: "Description" }),
-      /* @__PURE__ */ jsxRuntime.jsx(
-        ui.Textarea,
-        {
-          name: "description",
-          value: campaign.description,
-          onChange: (e) => handleCampaignChange("description", e.target.value),
-          disabled
-        }
-      ),
-      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid grid-cols-2 gap-4", children: [
-        /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { children: "Start Date" }),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            ui.Input,
-            {
-              type: "datetime-local",
-              name: "start_date",
-              value: dayjs__default.default(campaign.starts_at).format("YYYY-MM-DDTHH:mm"),
-              onChange: (e) => handleCampaignChange("starts_at", e.target.value),
-              disabled
-            }
-          )
-        ] }),
-        /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { children: "End Date" }),
-          /* @__PURE__ */ jsxRuntime.jsx(
-            ui.Input,
-            {
-              type: "datetime-local",
-              name: "end_date",
-              value: dayjs__default.default(campaign.ends_at).format("YYYY-MM-DDTHH:mm"),
-              onChange: (e) => handleCampaignChange("ends_at", e.target.value),
-              disabled
-            }
-          )
-        ] })
-      ] }),
-      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between items-center", children: [
-        /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { children: "Products" }),
-        /* @__PURE__ */ jsxRuntime.jsx(
-          ui.Button,
-          {
-            variant: "secondary",
-            onClick: () => setOpenProductModal(true),
-            disabled,
-            children: "Add Product"
-          }
-        )
-      ] }),
-      /* @__PURE__ */ jsxRuntime.jsxs(ui.Table, { children: [
-        /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Header, { children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Table.Row, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Product" }),
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Discount Type" }),
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Discount Value" }),
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Limit" }),
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Max Qty per Order" }),
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Actions" })
-        ] }) }),
-        /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Body, { children: Array.from(products.values()).map((product) => /* @__PURE__ */ jsxRuntime.jsxs(ui.Table.Row, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: product.product.title }),
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: /* @__PURE__ */ jsxRuntime.jsxs(
-            ui.Select,
-            {
-              value: product.discountType,
-              onValueChange: (value) => handleProductChange({
-                ...product,
-                discountType: value
-              }),
-              disabled,
-              children: [
-                /* @__PURE__ */ jsxRuntime.jsx(ui.Select.Trigger, { children: /* @__PURE__ */ jsxRuntime.jsx(ui.Select.Value, { placeholder: "Select discount type" }) }),
-                /* @__PURE__ */ jsxRuntime.jsx(ui.Select.Content, { children: /* @__PURE__ */ jsxRuntime.jsx(ui.Select.Item, { value: "percentage", children: "Percentage" }) })
-              ]
-            }
-          ) }),
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: /* @__PURE__ */ jsxRuntime.jsx(
-            ui.Input,
-            {
-              type: "number",
-              value: product.discountValue,
-              onChange: (e) => handleProductChange({
-                ...product,
-                discountValue: Number(e.target.value)
-              }),
-              disabled
-            }
-          ) }),
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: /* @__PURE__ */ jsxRuntime.jsx(
-            ui.Input,
-            {
-              type: "number",
-              value: product.limit,
-              onChange: (e) => handleProductChange({
-                ...product,
-                limit: Number(e.target.value)
-              }),
-              disabled
-            }
-          ) }),
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: /* @__PURE__ */ jsxRuntime.jsx(
-            ui.Input,
-            {
-              type: "number",
-              value: product.maxQty,
-              onChange: (e) => handleProductChange({
-                ...product,
-                maxQty: Number(e.target.value)
-              }),
-              disabled
-            }
-          ) }),
-          /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: /* @__PURE__ */ jsxRuntime.jsx(
-            ui.Button,
-            {
-              variant: "danger",
-              onClick: () => {
-                setProducts((prev) => {
-                  const newProducts = new Map(prev);
-                  newProducts.delete(product.product.id);
-                  return newProducts;
-                });
-              },
-              disabled,
-              children: /* @__PURE__ */ jsxRuntime.jsx(icons.Trash, {})
-            }
-          ) })
-        ] }, product.product.id)) })
-      ] }),
-      /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { onClick: handleSave, disabled, children: "Save" })
-    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "form",
+      {
+        onSubmit: handleSubmit(onFormSubmit, onFormError),
+        className: "space-y-4 my-8",
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { children: "Name" }),
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Input, { ...register("name"), disabled }),
+            errors.name && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-red-500 text-sm mt-1", children: errors.name.message })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { children: "Description" }),
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Textarea, { ...register("description"), disabled }),
+            errors.description && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-red-500 text-sm mt-1", children: errors.description.message })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid grid-cols-2 gap-4", children: [
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { children: "Start Date" }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  ui.Input,
+                  {
+                    type: "date",
+                    name: "start_date",
+                    value: campaign.starts_at ? dayjs__default.default(campaign.starts_at).format("YYYY-MM-DD") : "",
+                    onChange: (e2) => {
+                      const time = campaign.starts_at ? dayjs__default.default(campaign.starts_at).format("HH:mm") : "00:00";
+                      handleCampaignChange(
+                        "starts_at",
+                        `${e2.target.value}T${time}`
+                      );
+                    },
+                    disabled,
+                    className: "flex-1"
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  ui.Input,
+                  {
+                    type: "time",
+                    name: "start_time",
+                    value: campaign.starts_at ? dayjs__default.default(campaign.starts_at).format("HH:mm") : "",
+                    onChange: (e2) => {
+                      const date = campaign.starts_at ? dayjs__default.default(campaign.starts_at).format("YYYY-MM-DD") : dayjs__default.default().format("YYYY-MM-DD");
+                      handleCampaignChange(
+                        "starts_at",
+                        `${date}T${e2.target.value}`
+                      );
+                    },
+                    disabled,
+                    className: "w-32"
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  ui.Input,
+                  {
+                    type: "date",
+                    value: startsAt ? dayjs__default.default(startsAt).format("YYYY-MM-DD") : "",
+                    onChange: (e2) => handleDateTimeChange("starts_at", "date", e2.target.value),
+                    disabled,
+                    className: "flex-1"
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  ui.Input,
+                  {
+                    type: "time",
+                    value: startsAt ? dayjs__default.default(startsAt).format("HH:mm") : "",
+                    onChange: (e2) => handleDateTimeChange("starts_at", "time", e2.target.value),
+                    disabled,
+                    className: "w-32"
+                  }
+                )
+              ] }),
+              errors.starts_at && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-red-500 text-sm mt-1", children: errors.starts_at.message })
+            ] }),
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { children: "End Date" }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  ui.Input,
+                  {
+                    type: "date",
+                    name: "end_date",
+                    value: campaign.ends_at ? dayjs__default.default(campaign.ends_at).format("YYYY-MM-DD") : "",
+                    onChange: (e2) => {
+                      const time = campaign.ends_at ? dayjs__default.default(campaign.ends_at).format("HH:mm") : "23:59";
+                      handleCampaignChange("ends_at", `${e2.target.value}T${time}`);
+                    },
+                    disabled,
+                    className: "flex-1"
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  ui.Input,
+                  {
+                    type: "time",
+                    name: "end_time",
+                    value: campaign.ends_at ? dayjs__default.default(campaign.ends_at).format("HH:mm") : "",
+                    onChange: (e2) => {
+                      const date = campaign.ends_at ? dayjs__default.default(campaign.ends_at).format("YYYY-MM-DD") : dayjs__default.default().format("YYYY-MM-DD");
+                      handleCampaignChange("ends_at", `${date}T${e2.target.value}`);
+                    },
+                    disabled,
+                    className: "w-32"
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  ui.Input,
+                  {
+                    type: "date",
+                    value: endsAt ? dayjs__default.default(endsAt).format("YYYY-MM-DD") : "",
+                    onChange: (e2) => handleDateTimeChange("ends_at", "date", e2.target.value),
+                    disabled,
+                    className: "flex-1"
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  ui.Input,
+                  {
+                    type: "time",
+                    value: endsAt ? dayjs__default.default(endsAt).format("HH:mm") : "",
+                    onChange: (e2) => handleDateTimeChange("ends_at", "time", e2.target.value),
+                    disabled,
+                    className: "w-32"
+                  }
+                )
+              ] }),
+              errors.ends_at && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-red-500 text-sm mt-1", children: errors.ends_at.message })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-between items-center", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Label, { children: "Products" }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              ui.Button,
+              {
+                type: "button",
+                variant: "secondary",
+                onClick: () => setOpenProductModal(true),
+                disabled,
+                children: "Add Product"
+              }
+            )
+          ] }),
+          ((_a = errors.products) == null ? void 0 : _a.root) && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-red-500 text-sm", children: errors.products.root.message }),
+          /* @__PURE__ */ jsxRuntime.jsxs(ui.Table, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Header, { children: /* @__PURE__ */ jsxRuntime.jsxs(ui.Table.Row, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Product" }),
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Discount Type" }),
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Discount Value" }),
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Limit" }),
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Max Qty per Order" }),
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.HeaderCell, { children: "Actions" })
+            ] }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Body, { children: fields.map((field, index) => /* @__PURE__ */ jsxRuntime.jsxs(ui.Table.Row, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: field.product.title }),
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: /* @__PURE__ */ jsxRuntime.jsx(
+                Controller,
+                {
+                  name: `products.${index}.discountType`,
+                  control,
+                  render: ({ field: field2 }) => /* @__PURE__ */ jsxRuntime.jsxs(
+                    ui.Select,
+                    {
+                      value: field2.value,
+                      onValueChange: field2.onChange,
+                      disabled,
+                      children: [
+                        /* @__PURE__ */ jsxRuntime.jsx(ui.Select.Trigger, { children: /* @__PURE__ */ jsxRuntime.jsx(ui.Select.Value, { placeholder: "Select discount type" }) }),
+                        /* @__PURE__ */ jsxRuntime.jsx(ui.Select.Content, { children: /* @__PURE__ */ jsxRuntime.jsx(ui.Select.Item, { value: "percentage", children: "Percentage" }) })
+                      ]
+                    }
+                  )
+                }
+              ) }),
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: /* @__PURE__ */ jsxRuntime.jsx(
+                Controller,
+                {
+                  name: `products.${index}.discountValue`,
+                  control,
+                  render: ({ field: field2 }) => /* @__PURE__ */ jsxRuntime.jsx(
+                    ui.Input,
+                    {
+                      type: "number",
+                      value: field2.value,
+                      onChange: (e2) => field2.onChange(Number(e2.target.value)),
+                      disabled
+                    }
+                  )
+                }
+              ) }),
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: /* @__PURE__ */ jsxRuntime.jsx(
+                Controller,
+                {
+                  name: `products.${index}.limit`,
+                  control,
+                  render: ({ field: field2 }) => /* @__PURE__ */ jsxRuntime.jsx(
+                    ui.Input,
+                    {
+                      type: "number",
+                      value: field2.value,
+                      onChange: (e2) => field2.onChange(Number(e2.target.value)),
+                      disabled
+                    }
+                  )
+                }
+              ) }),
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: /* @__PURE__ */ jsxRuntime.jsx(
+                Controller,
+                {
+                  name: `products.${index}.maxQty`,
+                  control,
+                  render: ({ field: field2 }) => /* @__PURE__ */ jsxRuntime.jsx(
+                    ui.Input,
+                    {
+                      type: "number",
+                      value: field2.value,
+                      onChange: (e2) => field2.onChange(Number(e2.target.value)),
+                      disabled
+                    }
+                  )
+                }
+              ) }),
+              /* @__PURE__ */ jsxRuntime.jsx(ui.Table.Cell, { children: /* @__PURE__ */ jsxRuntime.jsx(
+                ui.Button,
+                {
+                  type: "button",
+                  variant: "danger",
+                  onClick: () => remove(index),
+                  disabled,
+                  children: /* @__PURE__ */ jsxRuntime.jsx(icons.Trash, {})
+                }
+              ) })
+            ] }, field.id)) })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx(ui.Button, { type: "submit", disabled, children: "Save" })
+        ]
+      }
+    ),
     /* @__PURE__ */ jsxRuntime.jsx(ui.FocusModal, { open: openProductModal, onOpenChange: setOpenProductModal, children: /* @__PURE__ */ jsxRuntime.jsxs(ui.FocusModal.Content, { children: [
       /* @__PURE__ */ jsxRuntime.jsx(ui.FocusModal.Header, { title: "Add Product" }),
       /* @__PURE__ */ jsxRuntime.jsx(ui.FocusModal.Body, { children: /* @__PURE__ */ jsxRuntime.jsx(
         ProductSelector,
         {
-          selectedProductIds: Array.from(products.keys()),
+          selectedProductIds: fields.map((f2) => f2.product.id),
           onSelectProduct: (product) => {
-            setProducts((prev) => {
-              const newProducts = new Map(prev);
-              newProducts.set(product.id, {
-                product,
-                discountType: "percentage",
-                discountValue: 10,
-                limit: 10,
-                maxQty: 1
-              });
-              return newProducts;
+            append({
+              product,
+              discountType: "percentage",
+              discountValue: 10,
+              limit: 10,
+              maxQty: 1
             });
             setOpenProductModal(false);
           }
@@ -5606,7 +7602,7 @@ const FlashSaleDetail = () => {
   const navigate = reactRouterDom.useNavigate();
   const queryClient = reactQuery.useQueryClient();
   const { data, isLoading } = useFlashSaleById(id || "");
-  const [isEditing, setIsEditing] = react.useState(false);
+  const [isEditing, setIsEditing] = React.useState(false);
   async function handleSubmit(campaignData2) {
     var _a;
     try {