@timardex/cluemart-shared 1.0.15 → 1.0.17

package/dist/hooks/index.cjs

@@ -0,0 +1,1167 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  defaultMarketFormValues: () => defaultMarketFormValues,
+  defaultMarketInfoFormValues: () => defaultMarketInfoFormValues,
+  defaultStallholderApplyFormValues: () => defaultStallholderApplyFormValues,
+  defaultStallholderFormValues: () => defaultStallholderFormValues,
+  globalDefaultValues: () => globalDefaultValues,
+  useLocationSearch: () => useLocationSearch,
+  useLoginForm: () => useLoginForm,
+  useMarketForm: () => useMarketForm,
+  useMarketInfoForm: () => useMarketInfoForm,
+  useRegisterForm: () => useRegisterForm,
+  useRequestPasswordResetForm: () => useRequestPasswordResetForm,
+  useResetPasswordForm: () => useResetPasswordForm,
+  useStallholderApplyForm: () => useStallholderApplyForm,
+  useStallholderForm: () => useStallholderForm,
+  useUserForm: () => useUserForm,
+  useValidateTokenForm: () => useValidateTokenForm
+});
+module.exports = __toCommonJS(hooks_exports);
+
+// src/hooks/useLocationSearch.ts
+var handleApiError = (error, message) => {
+  console.error(message, error);
+};
+var useLocationSearch = (googleApi) => {
+  const getPredictions = async (text) => {
+    try {
+      const response = await fetch(
+        `https://maps.googleapis.com/maps/api/place/autocomplete/json?input=${text}&components=country:nz&key=${googleApi}`
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP error! Status: ${response.status}`);
+      }
+      const data = await response.json();
+      return data.predictions;
+    } catch (error) {
+      console.error("Error fetching predictions:", error);
+      handleApiError(error, "Failed to fetch address predictions.");
+    }
+  };
+  const getPlaceDetails = async (placeId) => {
+    try {
+      const response = await fetch(
+        `https://maps.googleapis.com/maps/api/place/details/json?place_id=${placeId}&key=${googleApi}`
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP error! Status: ${response.status}`);
+      }
+      const data = await response.json();
+      const { result } = data;
+      const { lat, lng } = result.geometry.location;
+      const { address_components, formatted_address } = result;
+      const address = address_components.reduce((acc, item) => {
+        if (item.types.includes("street_number")) {
+          return { ...acc, streetNumber: item.long_name };
+        }
+        if (item.types.includes("route")) {
+          return { ...acc, streetName: item.long_name };
+        }
+        if (item.types.includes("locality")) {
+          return { ...acc, city: item.long_name };
+        }
+        if (item.types.includes("administrative_area_level_1")) {
+          return { ...acc, region: item.long_name };
+        }
+        if (item.types.includes("country")) {
+          return { ...acc, country: item.long_name };
+        }
+        return acc;
+      }, {});
+      const newLocation = {
+        city: address.city.toLowerCase(),
+        coordinates: [lng, lat],
+        // [longitude, latitude]
+        country: address.country,
+        fullAddress: formatted_address,
+        latitude: lat,
+        longitude: lng,
+        region: address.region.replace(/ Region$/, ""),
+        // Remove " Region" suffix
+        type: "Point"
+        // Mongoose GeoJSON type
+      };
+      return newLocation;
+    } catch (error) {
+      handleApiError(error, "Failed to fetch place details.");
+    }
+  };
+  return {
+    getPlaceDetails,
+    getPredictions
+  };
+};
+
+// src/hooks/stallholder/useStallholderForm.ts
+var import_yup = require("@hookform/resolvers/yup");
+var React = __toESM(require("react"));
+var import_react_hook_form = require("react-hook-form");
+
+// src/yupSchema/global.ts
+var import_dayjs2 = __toESM(require("dayjs"));
+var import_customParseFormat2 = __toESM(require("dayjs/plugin/customParseFormat"));
+var import_isSameOrAfter2 = __toESM(require("dayjs/plugin/isSameOrAfter"));
+var yup = __toESM(require("yup"));
+
+// src/utils/index.ts
+var import_dayjs = __toESM(require("dayjs"));
+var import_customParseFormat = __toESM(require("dayjs/plugin/customParseFormat"));
+var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter"));
+var import_timezone = __toESM(require("dayjs/plugin/timezone"));
+var import_utc = __toESM(require("dayjs/plugin/utc"));
+
+// src/enums/index.ts
+var EnumInviteStatus = /* @__PURE__ */ ((EnumInviteStatus2) => {
+  EnumInviteStatus2["ACCEPTED"] = "Accepted";
+  EnumInviteStatus2["COMPLETED"] = "Completed";
+  EnumInviteStatus2["EXPIRED"] = "Expired";
+  EnumInviteStatus2["NO_STATUS"] = "No_Status";
+  EnumInviteStatus2["PENDING"] = "Pending";
+  EnumInviteStatus2["REJECTED"] = "Rejected";
+  EnumInviteStatus2["WAITING"] = "Waiting";
+  return EnumInviteStatus2;
+})(EnumInviteStatus || {});
+var EnumRejectionPolicy = /* @__PURE__ */ ((EnumRejectionPolicy2) => {
+  EnumRejectionPolicy2["SINGLE_DATE_ALLOWED"] = "single_date_allowed";
+  EnumRejectionPolicy2["MULTI_DATE_ALLOWED"] = "multi_date_allowed";
+  return EnumRejectionPolicy2;
+})(EnumRejectionPolicy || {});
+var EnumPaymentMethod = /* @__PURE__ */ ((EnumPaymentMethod3) => {
+  EnumPaymentMethod3["CASH"] = "cash";
+  EnumPaymentMethod3["EFTPOS"] = "eftpos";
+  EnumPaymentMethod3["BANK_TRANSFER"] = "bank_transfer";
+  EnumPaymentMethod3["PAYPAL"] = "paypal";
+  EnumPaymentMethod3["STRIPE"] = "stripe";
+  return EnumPaymentMethod3;
+})(EnumPaymentMethod || {});
+var EnumRegions = /* @__PURE__ */ ((EnumRegions3) => {
+  EnumRegions3["Auckland"] = "Auckland";
+  EnumRegions3["BayOfPlenty"] = "Bay of Plenty";
+  EnumRegions3["Canterbury"] = "Canterbury";
+  EnumRegions3["Gisborne"] = "Gisborne";
+  EnumRegions3["HawkesBay"] = "Hawke's Bay";
+  EnumRegions3["ManawatuWanganui"] = "Manawatu-Wanganui";
+  EnumRegions3["Marlborough"] = "Marlborough";
+  EnumRegions3["Nelson"] = "Nelson";
+  EnumRegions3["Northland"] = "Northland";
+  EnumRegions3["Otago"] = "Otago";
+  EnumRegions3["Southland"] = "Southland";
+  EnumRegions3["Taranaki"] = "Taranaki";
+  EnumRegions3["Waikato"] = "Waikato";
+  EnumRegions3["Wellington"] = "Wellington";
+  return EnumRegions3;
+})(EnumRegions || {});
+var EnumUserRole = /* @__PURE__ */ ((EnumUserRole2) => {
+  EnumUserRole2["ADMIN"] = "admin";
+  EnumUserRole2["CUSTOMER"] = "customer";
+  return EnumUserRole2;
+})(EnumUserRole || {});
+
+// src/utils/index.ts
+var dateFormat = "DD-MM-YYYY";
+var timeFormat = "HH:mm";
+(0, import_dayjs.extend)(import_customParseFormat.default);
+(0, import_dayjs.extend)(import_utc.default);
+(0, import_dayjs.extend)(import_timezone.default);
+(0, import_dayjs.extend)(import_isSameOrAfter.default);
+var mapArrayToOptions = (items) => items.map((item) => ({
+  label: item.replace(/_/g, " "),
+  value: item.replace(/\s+/g, "_").toLowerCase()
+}));
+var statusOptions = [
+  ...Object.values(EnumInviteStatus).map((status) => ({
+    label: status,
+    value: status
+  })).sort((a, b) => a.label.localeCompare(b.label))
+  // Sort the options alphabetically
+];
+var availableRegionTypes = Object.values(EnumRegions);
+var availableRegionOptions = mapArrayToOptions(availableRegionTypes);
+var paymentMethodOptions = mapArrayToOptions(
+  Object.values(EnumPaymentMethod)
+);
+
+// src/yupSchema/global.ts
+var noLeadingZeros = (fieldName, options = {}) => {
+  return function(value, context) {
+    const original = context.originalValue?.toString() ?? "";
+    const regex = options.allowDecimal ? /^0\d+(\.\d+)?$/ : /^0\d+$/;
+    if (regex.test(original)) {
+      return context.createError({
+        message: `${fieldName} must not have leading zeros`
+      });
+    }
+    return true;
+  };
+};
+(0, import_dayjs2.extend)(import_isSameOrAfter2.default);
+(0, import_dayjs2.extend)(import_customParseFormat2.default);
+var now = (0, import_dayjs2.default)();
+var endDateNotInPastTest = yup.string().test("not-in-past", "End date cannot be in the past", (value) => {
+  return value ? (0, import_dayjs2.default)(value, dateFormat, true).isSameOrAfter(now, "day") : false;
+});
+var startDateNotInPastTest = yup.string().test("not-in-past", "Start date cannot be in the past", (value) => {
+  return value ? (0, import_dayjs2.default)(value, dateFormat, true).isSameOrAfter(now, "day") : false;
+});
+var endDateAfterStartDateTest = yup.string().test(
+  "end-after-start",
+  "End date cannot be before start date",
+  function(value) {
+    const { startDate } = this.parent;
+    if (!startDate || !value) return false;
+    return (0, import_dayjs2.default)(value, dateFormat, true).isSameOrAfter(
+      (0, import_dayjs2.default)(startDate, dateFormat, true),
+      "day"
+    );
+  }
+);
+var endTimeMustBeAfterStartTimeTest = yup.string().test(
+  "valid-end-time",
+  "End time must be after start time",
+  function(value) {
+    const { startDate, endDate, startTime } = this.parent;
+    if (!startDate || !endDate || !startTime || !value) return false;
+    const startDateTime = (0, import_dayjs2.default)(
+      `${startDate} ${startTime}`,
+      `${dateFormat} ${timeFormat}`,
+      true
+    );
+    const endDateTime = (0, import_dayjs2.default)(
+      `${endDate} ${value}`,
+      `${dateFormat} ${timeFormat}`,
+      true
+    );
+    return endDateTime.isAfter(startDateTime);
+  }
+);
+var startTimeCannotBeInPastTest = yup.string().test(
+  "valid-start-time",
+  "Start time cannot be in the past",
+  function(value) {
+    const { startDate } = this.parent;
+    if (!startDate || !value) return false;
+    const startDateTime = (0, import_dayjs2.default)(
+      `${startDate} ${value}`,
+      `${dateFormat} ${timeFormat}`,
+      true
+    );
+    return startDateTime.isSameOrAfter(now);
+  }
+);
+var dateTimeSchema = yup.object().shape({
+  endDate: yup.string().concat(endDateNotInPastTest).concat(endDateAfterStartDateTest).required("End date is required"),
+  endTime: yup.string().concat(endTimeMustBeAfterStartTimeTest).required("End time is required"),
+  startDate: yup.string().concat(startDateNotInPastTest).required("Start date is required"),
+  startTime: yup.string().concat(startTimeCannotBeInPastTest).required("Start time is required")
+});
+var dateTimeWithPriceSchema = dateTimeSchema.shape({
+  marketPrice: yup.number().typeError("Market price must be a number").min(0.1, "Market price must be at least 0.1").required("Market price is required").test(
+    "no-leading-zeros",
+    "",
+    noLeadingZeros("Market price", { allowDecimal: true })
+  )
+});
+var locationSchema = yup.object().shape({
+  city: yup.string().required("City is required"),
+  coordinates: yup.array().of(yup.number().required("Coordinates must be numbers")).length(
+    2,
+    "Coordinates must contain exactly two numbers (longitude, latitude)"
+  ).required("Coordinates are required"),
+  country: yup.string().required("Country is required"),
+  fullAddress: yup.string().required("Address is required"),
+  latitude: yup.number().required("Latitude is required"),
+  longitude: yup.number().required("Longitude is required"),
+  region: yup.string().required("Region is required"),
+  type: yup.string().oneOf(["Point"], "Type must be 'Point'").default("Point").required("Type is required")
+});
+var emailSchema = yup.string().email("Invalid email address").required("Email is required").transform(
+  (value) => typeof value === "string" ? value.toLowerCase() : value
+);
+var passwordSchema = yup.string().trim().min(8, "Password must be at least 8 characters long").required("Password is required");
+var globalResourceSchema = yup.object().shape({
+  active: yup.boolean().required("Active is required"),
+  cover: yup.object({
+    source: yup.string().required("Cover is required"),
+    title: yup.string().required("Cover is required")
+  }),
+  description: yup.string().trim().min(3).required("Description is required"),
+  name: yup.string().trim().min(3).required("Name is required"),
+  region: yup.string().required("Region is required")
+});
+
+// src/yupSchema/market.ts
+var yup2 = __toESM(require("yup"));
+var nzBankAccountRegex = /^\d{2}-\d{4}-\d{7}-\d{2}$/;
+var marketSchema = globalResourceSchema.shape({
+  dateTime: yup2.array().of(dateTimeSchema).required("DateTime is required"),
+  location: locationSchema,
+  provider: yup2.string().trim().min(3).required("Provider is required"),
+  tags: yup2.array().of(yup2.string().defined()).nullable()
+});
+var marketInfoSchema = yup2.object().shape({
+  applicationDeadlineHours: yup2.number().typeError("Application deadline hours must be a number").min(1, "Application deadline hours must be at least 1").required("Application deadline hours is required").test("no-leading-zeros", "", noLeadingZeros("Application deadline hours")),
+  dateTime: yup2.array().of(dateTimeWithPriceSchema).required("DateTime is required"),
+  paymentDueHours: yup2.number().typeError("Payment due hours must be a number").min(1, "Payment due hours must be at least 1").required("Payment due hours is required").test("no-leading-zeros", "", noLeadingZeros("Payment due hours")),
+  paymentMethod: yup2.mixed().oneOf(Object.values(EnumPaymentMethod)).required("Please select a Payment method"),
+  paymentTarget: yup2.object().when("paymentMethod", (paymentMethod, schema) => {
+    const isBankTransfer = paymentMethod.includes(
+      "bank_transfer" /* BANK_TRANSFER */
+    );
+    if (!isBankTransfer) {
+      return schema.shape({
+        accountHolderName: yup2.string().notRequired(),
+        accountNumber: yup2.string().notRequired(),
+        link: yup2.string().trim().required("Link is required for PayPal/Stripe")
+      });
+    } else if (isBankTransfer) {
+      return schema.shape({
+        accountHolderName: yup2.string().trim().required("Account holder name is required for bank transfer"),
+        accountNumber: yup2.string().trim().required("Account number is required for bank transfer").matches(
+          nzBankAccountRegex,
+          "Account number must be in format: XX-XXXX-XXXXXXX-XX"
+        ),
+        link: yup2.string().notRequired()
+      });
+    } else {
+      return schema.shape({
+        accountHolderName: yup2.string().notRequired(),
+        accountNumber: yup2.string().notRequired(),
+        link: yup2.string().notRequired()
+      });
+    }
+  }),
+  rejectionPolicy: yup2.mixed().oneOf(Object.values(EnumRejectionPolicy)).required("Rejection policy is required"),
+  stallCapacity: yup2.number().typeError("Stall capacity must be a number").min(1, "Stall capacity must be at least 1").integer("Stall capacity must be a whole number").required("Stall capacity is required").test("no-leading-zeros", "", noLeadingZeros("Stall capacity"))
+});
+
+// src/yupSchema/stallholder.ts
+var yup3 = __toESM(require("yup"));
+var stallHolderSchema = globalResourceSchema.shape({
+  categories: yup3.array().of(
+    yup3.object().shape({
+      id: yup3.string().required("Category id is required"),
+      name: yup3.string().required("Category name is required"),
+      subcategories: yup3.array().of(
+        yup3.object().shape({
+          id: yup3.string().defined(),
+          items: yup3.array().of(yup3.string().defined()).nullable(),
+          name: yup3.string().defined()
+        })
+      ).nullable()
+    })
+  ).min(1, "Category list must contain at least one item").required("Categories are required"),
+  multiLocation: yup3.boolean().required("Multi location is required"),
+  products: yup3.array().of(yup3.string().defined()).min(1, "Product list must contain at least one item").required("Products are required")
+});
+var stallholderApplyFormSchema = yup3.object().shape({
+  active: yup3.boolean().required("Active is required"),
+  electricity: yup3.object().shape({
+    details: yup3.string().trim().test("details-required", "Please add details", function(value) {
+      return !this.parent?.isRequired || (value?.trim().length ?? 0) > 0;
+    }).nullable(),
+    isRequired: yup3.boolean().required("Electricity requirement is required")
+  }),
+  foodSafetyGradeFiles: yup3.array().of(yup3.string().defined()).nullable(),
+  foodSafetyGradeFilesUpload: yup3.array().of(yup3.string().defined()).nullable(),
+  gazebo: yup3.object().shape({
+    details: yup3.string().trim().test("details-required", "Please add details", function(value) {
+      return !this.parent?.isRequired || (value?.trim().length ?? 0) > 0;
+    }).nullable(),
+    isRequired: yup3.boolean().required("Gazebo requirement is required")
+  }),
+  packaging: yup3.array().of(yup3.string().defined()).min(1, "Packaging list must contain at least one item").required("Packaging is required"),
+  paymentMethod: yup3.mixed().oneOf(Object.values(EnumPaymentMethod)).required("Please select a Payment method"),
+  priceRange: yup3.object().shape({
+    max: yup3.number().min(1).required("Max price is required").test(
+      "is-greater",
+      "Max price must be greater than or equal to Min price",
+      function(max) {
+        const { min } = this.parent;
+        return max >= min;
+      }
+    ),
+    min: yup3.number().min(1).required("Min price is required")
+  }),
+  producedIn: yup3.array().of(yup3.string().defined()).min(1, "Produced in list must contain at least one item").required("Produced in is required"),
+  stallSize: yup3.object().shape({
+    depth: yup3.number().min(1).required("Depth is required"),
+    width: yup3.number().min(1).required("Width is required")
+  }),
+  table: yup3.object().shape({
+    details: yup3.string().trim().test("details-required", "Please add details", function(value) {
+      return !this.parent?.isRequired || (value?.trim().length ?? 0) > 0;
+    }).nullable(),
+    isRequired: yup3.boolean().required("Table requirement is required")
+  })
+});
+
+// src/yupSchema/user.ts
+var yup4 = __toESM(require("yup"));
+var userSchema = yup4.object().shape({
+  active: yup4.boolean().required("Active is required"),
+  email: emailSchema,
+  firstName: yup4.string().required("First name is required"),
+  lastName: yup4.string().required("Last name is required"),
+  password: passwordSchema,
+  preferredRegion: yup4.string().required("Preferred region is required"),
+  // eslint-disable-next-line sort-keys
+  confirmPassword: yup4.string().oneOf([yup4.ref("password")], "Passwords must match").required("Confirm Password is required"),
+  role: yup4.mixed().oneOf(Object.values(EnumUserRole)).required("Role is required")
+});
+
+// src/yupSchema/auth.ts
+var yup5 = __toESM(require("yup"));
+var loginSchema = yup5.object().shape({
+  email: emailSchema,
+  password: passwordSchema
+});
+var registerSchema = yup5.object().shape({
+  email: emailSchema,
+  firstName: yup5.string().required("First Name is required"),
+  lastName: yup5.string().required("Last Name is required"),
+  password: passwordSchema,
+  preferredRegion: yup5.string().required("Preferred Region is required"),
+  role: yup5.mixed().oneOf(Object.values(EnumUserRole)).required("Role is required")
+});
+var requestPasswordResetSchema = yup5.object().shape({
+  email: emailSchema
+});
+var resetPasswordSchema = yup5.object().shape({
+  email: emailSchema,
+  password: passwordSchema,
+  // eslint-disable-next-line sort-keys
+  confirmPassword: yup5.string().oneOf([yup5.ref("password")], "Passwords must match").required("Confirm Password is required")
+});
+var validateTokenSchema = yup5.object().shape({
+  email: emailSchema,
+  token: yup5.string().required("Verification code is required").matches(/^\d{5}$/, "Verification code must be exactly 5 digits")
+});
+
+// src/hooks/utils.ts
+var globalDefaultValues = {
+  active: false,
+  cover: {
+    source: "",
+    title: ""
+  },
+  coverUpload: {
+    source: "",
+    title: ""
+  },
+  description: "Lorem Ipsum is a placeholder text commonly used in design and publishing to represent the visual form of a document without relying on meaningful content. It's a jumbled Latin text, not intended to be read or understood, and is used to show the layout and typography before actual content is added.",
+  images: null,
+  imagesUpload: null,
+  logo: null,
+  logoUpload: null,
+  name: "Resource name",
+  promoCode: "",
+  region: ""
+};
+var defaultMarketFormValues = {
+  ...globalDefaultValues,
+  dateTime: [
+    {
+      endDate: "04-05-2025",
+      endTime: "15:00",
+      startDate: "04-05-2025",
+      startTime: "09:00"
+    },
+    {
+      endDate: "05-05-2025",
+      endTime: "15:00",
+      startDate: "05-05-2025",
+      startTime: "09:00"
+    }
+  ],
+  location: {
+    city: "",
+    coordinates: [0, 0],
+    // [longitude, latitude]
+    country: "",
+    fullAddress: "",
+    latitude: 0,
+    longitude: 0,
+    region: "",
+    type: "Point"
+    // Default type for GeoJSON
+  },
+  provider: "Provider name",
+  tags: null
+};
+var defaultMarketInfoFormValues = {
+  applicationDeadlineHours: 0,
+  dateTime: [
+    {
+      endDate: "04-05-2025",
+      endTime: "15:00",
+      marketPrice: 0,
+      startDate: "04-05-2025",
+      startTime: "09:00"
+    },
+    {
+      endDate: "05-05-2025",
+      endTime: "15:00",
+      marketPrice: 0,
+      startDate: "05-05-2025",
+      startTime: "09:00"
+    }
+  ],
+  paymentDueHours: 0,
+  paymentMethod: "",
+  paymentTarget: {
+    accountHolderName: "",
+    accountNumber: "",
+    link: ""
+  },
+  rejectionPolicy: "multi_date_allowed" /* MULTI_DATE_ALLOWED */,
+  stallCapacity: 0
+};
+var defaultStallholderFormValues = {
+  ...globalDefaultValues,
+  categories: [],
+  locations: null,
+  multiLocation: false,
+  products: ["Prod uct 1", "Product 2"],
+  specialities: null
+};
+var defaultStallholderApplyFormValues = {
+  active: false,
+  electricity: { details: null, isRequired: false },
+  foodSafetyGradeFiles: null,
+  foodSafetyGradeFilesUpload: null,
+  gazebo: { details: null, isRequired: false },
+  packaging: [],
+  paymentMethod: "",
+  priceRange: { max: 0, min: 0 },
+  producedIn: [],
+  stallSize: { depth: 0, width: 0 },
+  table: { details: null, isRequired: false }
+};
+
+// src/hooks/stallholder/useStallholderForm.ts
+function useStallholderForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form.useForm)({
+    defaultValues: defaultStallholderFormValues,
+    resolver: (0, import_yup.yupResolver)(stallHolderSchema)
+  });
+  React.useEffect(() => {
+    if (data) {
+      reset({
+        _id: data._id,
+        active: data.active,
+        categories: data.categories,
+        cover: data.cover,
+        coverUpload: data.coverUpload,
+        description: data.description,
+        images: data.images,
+        imagesUpload: data.imagesUpload,
+        locations: data.locations,
+        logo: data.logo,
+        logoUpload: data.logoUpload,
+        multiLocation: data.multiLocation,
+        name: data.name,
+        products: data.products,
+        promoCode: data.promoCode,
+        region: data.region,
+        specialities: data.specialities
+      });
+    } else {
+      reset(defaultStallholderFormValues);
+    }
+  }, [data]);
+  const {
+    _id,
+    active,
+    categories,
+    cover,
+    coverUpload,
+    description,
+    images,
+    imagesUpload,
+    locations,
+    logo,
+    logoUpload,
+    multiLocation,
+    name,
+    products,
+    promoCode,
+    region,
+    specialities
+  } = getValues();
+  return {
+    control,
+    fields: {
+      _id,
+      active,
+      categories,
+      cover,
+      coverUpload,
+      description,
+      images,
+      imagesUpload,
+      locations,
+      logo,
+      logoUpload,
+      multiLocation,
+      name,
+      products,
+      promoCode,
+      region,
+      specialities
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/stallholder/useStallholderApplyForm.ts
+var import_yup2 = require("@hookform/resolvers/yup");
+var React2 = __toESM(require("react"));
+var import_react_hook_form2 = require("react-hook-form");
+function useStallholderApplyForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form2.useForm)({
+    defaultValues: defaultStallholderApplyFormValues,
+    resolver: (0, import_yup2.yupResolver)(stallholderApplyFormSchema)
+  });
+  React2.useEffect(() => {
+    if (data) {
+      reset({
+        _id: data._id,
+        active: data.active,
+        electricity: data.electricity,
+        foodSafetyGradeFiles: data.foodSafetyGradeFiles,
+        foodSafetyGradeFilesUpload: data.foodSafetyGradeFilesUpload,
+        gazebo: data.gazebo,
+        packaging: data.packaging,
+        paymentMethod: data.paymentMethod,
+        priceRange: data.priceRange,
+        producedIn: data.producedIn,
+        stallSize: data.stallSize,
+        table: data.table
+      });
+    } else {
+      reset(defaultStallholderApplyFormValues);
+    }
+  }, [data]);
+  const {
+    _id,
+    active,
+    electricity,
+    foodSafetyGradeFiles,
+    foodSafetyGradeFilesUpload,
+    gazebo,
+    packaging,
+    paymentMethod,
+    priceRange,
+    producedIn,
+    stallSize,
+    table
+  } = getValues();
+  return {
+    control,
+    fields: {
+      _id,
+      active,
+      electricity,
+      foodSafetyGradeFiles,
+      foodSafetyGradeFilesUpload,
+      gazebo,
+      packaging,
+      paymentMethod,
+      priceRange,
+      producedIn,
+      stallSize,
+      table
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/market/useMarketForm.ts
+var import_yup3 = require("@hookform/resolvers/yup");
+var React3 = __toESM(require("react"));
+var import_react_hook_form3 = require("react-hook-form");
+function useMarketForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form3.useForm)({
+    defaultValues: defaultMarketFormValues,
+    resolver: (0, import_yup3.yupResolver)(marketSchema)
+  });
+  React3.useEffect(() => {
+    if (data) {
+      reset({
+        _id: data._id,
+        active: data.active,
+        cover: data.cover,
+        coverUpload: data.coverUpload,
+        dateTime: data.dateTime,
+        description: data.description,
+        images: data.images,
+        imagesUpload: data.imagesUpload,
+        location: data.location,
+        logo: data.logo,
+        logoUpload: data.logoUpload,
+        name: data.name,
+        promoCode: data.promoCode,
+        provider: data.provider,
+        region: data.region,
+        tags: data.tags
+      });
+    } else {
+      reset(defaultMarketFormValues);
+    }
+  }, [data]);
+  const {
+    _id,
+    active,
+    cover,
+    coverUpload,
+    dateTime,
+    description,
+    images,
+    imagesUpload,
+    location,
+    logo,
+    logoUpload,
+    name,
+    provider,
+    region,
+    tags
+  } = getValues();
+  return {
+    control,
+    fields: {
+      _id,
+      active,
+      cover,
+      coverUpload,
+      dateTime,
+      description,
+      images,
+      imagesUpload,
+      location,
+      logo,
+      logoUpload,
+      name,
+      provider,
+      region,
+      tags
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/market/useMarketInfoForm.ts
+var import_yup4 = require("@hookform/resolvers/yup");
+var React4 = __toESM(require("react"));
+var import_react_hook_form4 = require("react-hook-form");
+function useMarketInfoForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form4.useForm)({
+    defaultValues: defaultMarketInfoFormValues,
+    resolver: (0, import_yup4.yupResolver)(marketInfoSchema)
+  });
+  React4.useEffect(() => {
+    if (data) {
+      reset({
+        _id: data._id,
+        applicationDeadlineHours: data.applicationDeadlineHours,
+        dateTime: data.dateTime,
+        paymentDueHours: data.paymentDueHours,
+        paymentMethod: data.paymentMethod,
+        paymentTarget: data.paymentTarget,
+        rejectionPolicy: data.rejectionPolicy,
+        stallCapacity: data.stallCapacity
+      });
+    } else {
+      reset(defaultMarketInfoFormValues);
+    }
+  }, [data]);
+  const {
+    _id,
+    applicationDeadlineHours,
+    dateTime,
+    paymentDueHours,
+    paymentMethod,
+    paymentTarget,
+    rejectionPolicy,
+    stallCapacity
+  } = getValues();
+  return {
+    control,
+    fields: {
+      _id,
+      applicationDeadlineHours,
+      dateTime,
+      paymentDueHours,
+      paymentMethod,
+      paymentTarget,
+      rejectionPolicy,
+      stallCapacity
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/useUserForm.ts
+var import_yup5 = require("@hookform/resolvers/yup");
+var React5 = __toESM(require("react"));
+var import_react_hook_form5 = require("react-hook-form");
+var defaultValues = {
+  active: false,
+  avatar: null,
+  avatarUpload: null,
+  confirmPassword: "",
+  email: "",
+  firstName: "",
+  lastName: "",
+  password: "",
+  preferredRegion: "",
+  role: "customer" /* CUSTOMER */
+};
+function useUserForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form5.useForm)({
+    defaultValues,
+    resolver: (0, import_yup5.yupResolver)(userSchema)
+  });
+  React5.useEffect(() => {
+    if (data) {
+      reset({
+        _id: data._id,
+        active: data.active,
+        avatar: data.avatar,
+        avatarUpload: data.avatarUpload,
+        confirmPassword: data.confirmPassword,
+        email: data.email,
+        firstName: data.firstName,
+        lastName: data.lastName,
+        password: data.password,
+        preferredRegion: data.preferredRegion,
+        role: data.role
+      });
+    } else {
+      reset(defaultValues);
+    }
+  }, [data]);
+  const {
+    _id,
+    active,
+    avatar,
+    avatarUpload,
+    confirmPassword,
+    email,
+    firstName,
+    lastName,
+    password,
+    preferredRegion,
+    role
+  } = getValues();
+  return {
+    control,
+    fields: {
+      _id,
+      active,
+      avatar,
+      avatarUpload,
+      confirmPassword,
+      email,
+      firstName,
+      lastName,
+      password,
+      preferredRegion,
+      role
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/auth/useLoginForm.ts
+var import_yup6 = require("@hookform/resolvers/yup");
+var import_react_hook_form6 = require("react-hook-form");
+var defaultValues2 = {
+  email: "",
+  password: ""
+};
+function useLoginForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form6.useForm)({
+    defaultValues: defaultValues2,
+    resolver: (0, import_yup6.yupResolver)(loginSchema)
+  });
+  const { email, password } = getValues();
+  return {
+    control,
+    fields: {
+      email,
+      password
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/auth/useRegisterForm.ts
+var import_yup7 = require("@hookform/resolvers/yup");
+var import_react_hook_form7 = require("react-hook-form");
+var defaultValues3 = {
+  email: "",
+  firstName: "",
+  lastName: "",
+  password: "",
+  preferredRegion: "",
+  role: "customer" /* CUSTOMER */
+};
+function useRegisterForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form7.useForm)({
+    defaultValues: defaultValues3,
+    resolver: (0, import_yup7.yupResolver)(registerSchema)
+  });
+  const { email, firstName, lastName, password, preferredRegion, role } = getValues();
+  return {
+    control,
+    fields: {
+      email,
+      firstName,
+      lastName,
+      password,
+      preferredRegion,
+      role
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/auth/useRequestPasswordResetForm.ts
+var import_yup8 = require("@hookform/resolvers/yup");
+var import_react_hook_form8 = require("react-hook-form");
+var defaultValues4 = {
+  email: ""
+};
+function useRequestPasswordResetForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form8.useForm)({
+    defaultValues: defaultValues4,
+    resolver: (0, import_yup8.yupResolver)(requestPasswordResetSchema)
+  });
+  const { email } = getValues();
+  return {
+    control,
+    fields: {
+      email
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/auth/useValidateTokenForm.ts
+var import_yup9 = require("@hookform/resolvers/yup");
+var import_react_hook_form9 = require("react-hook-form");
+var defaultValues5 = {
+  email: "",
+  token: ""
+};
+function useValidateTokenForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form9.useForm)({
+    defaultValues: defaultValues5,
+    resolver: (0, import_yup9.yupResolver)(validateTokenSchema)
+  });
+  const { email, token } = getValues();
+  return {
+    control,
+    fields: {
+      email,
+      token
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/auth/useResetPasswordForm.ts
+var import_yup10 = require("@hookform/resolvers/yup");
+var import_react_hook_form10 = require("react-hook-form");
+var defaultValues6 = {
+  confirmPassword: "",
+  email: "",
+  password: ""
+};
+function useResetPasswordForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = (0, import_react_hook_form10.useForm)({
+    defaultValues: defaultValues6,
+    resolver: (0, import_yup10.yupResolver)(resetPasswordSchema)
+  });
+  const { confirmPassword, email, password } = getValues();
+  return {
+    control,
+    fields: {
+      confirmPassword,
+      email,
+      password
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultMarketFormValues,
+  defaultMarketInfoFormValues,
+  defaultStallholderApplyFormValues,
+  defaultStallholderFormValues,
+  globalDefaultValues,
+  useLocationSearch,
+  useLoginForm,
+  useMarketForm,
+  useMarketInfoForm,
+  useRegisterForm,
+  useRequestPasswordResetForm,
+  useResetPasswordForm,
+  useStallholderApplyForm,
+  useStallholderForm,
+  useUserForm,
+  useValidateTokenForm
+});
+//# sourceMappingURL=index.cjs.map