@timardex/cluemart-shared 1.0.14 → 1.0.16

package/dist/hooks/index.mjs

@@ -0,0 +1,970 @@
+import {
+  dateFormat,
+  timeFormat
+} from "../chunk-K5NK2CK5.mjs";
+import {
+  EnumPaymentMethod,
+  EnumRejectionPolicy,
+  EnumUserRole
+} from "../chunk-L2H5WFGC.mjs";
+
+// 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
+import { yupResolver } from "@hookform/resolvers/yup";
+import * as React from "react";
+import { useForm } from "react-hook-form";
+
+// src/yupSchema/global.ts
+import dayjs, { extend } from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat";
+import isSameOrAfter from "dayjs/plugin/isSameOrAfter";
+import * as yup from "yup";
+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;
+  };
+};
+extend(isSameOrAfter);
+extend(customParseFormat);
+var now = dayjs();
+var endDateNotInPastTest = yup.string().test("not-in-past", "End date cannot be in the past", (value) => {
+  return value ? dayjs(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 ? dayjs(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 dayjs(value, dateFormat, true).isSameOrAfter(
+      dayjs(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 = dayjs(
+      `${startDate} ${startTime}`,
+      `${dateFormat} ${timeFormat}`,
+      true
+    );
+    const endDateTime = dayjs(
+      `${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 = dayjs(
+      `${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"),
+  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 })
+  ),
+  startDate: yup.string().concat(startDateNotInPastTest).required("Start date is required"),
+  startTime: yup.string().concat(startTimeCannotBeInPastTest).required("Start time is required")
+});
+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
+import * as yup2 from "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"),
+  stallApplicationInfo: 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")
+    ),
+    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"))
+  }),
+  tags: yup2.array().of(yup2.string().defined()).nullable()
+});
+
+// src/yupSchema/stallholder.ts
+import * as yup3 from "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
+import * as yup4 from "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
+import * as yup5 from "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",
+      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"
+    }
+  ],
+  location: {
+    city: "",
+    coordinates: [0, 0],
+    // [longitude, latitude]
+    country: "",
+    fullAddress: "",
+    latitude: 0,
+    longitude: 0,
+    region: "",
+    type: "Point"
+    // Default type for GeoJSON
+  },
+  provider: "Provider name",
+  stallApplicationInfo: {
+    applicationDeadlineHours: 0,
+    paymentDueHours: 0,
+    paymentMethod: "",
+    paymentTarget: {
+      accountHolderName: "",
+      accountNumber: "",
+      link: ""
+    },
+    rejectionPolicy: "multi_date_allowed" /* MULTI_DATE_ALLOWED */,
+    stallCapacity: 0
+  },
+  tags: null
+};
+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
+  } = useForm({
+    defaultValues: defaultStallholderFormValues,
+    resolver: 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
+import { yupResolver as yupResolver2 } from "@hookform/resolvers/yup";
+import * as React2 from "react";
+import { useForm as useForm2 } from "react-hook-form";
+function useStallholderApplyForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = useForm2({
+    defaultValues: defaultStallholderApplyFormValues,
+    resolver: yupResolver2(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/useMarketForm.ts
+import { yupResolver as yupResolver3 } from "@hookform/resolvers/yup";
+import * as React3 from "react";
+import { useForm as useForm3 } from "react-hook-form";
+function useMarketForm(data) {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = useForm3({
+    defaultValues: defaultMarketFormValues,
+    resolver: yupResolver3(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,
+        stallApplicationInfo: data.stallApplicationInfo,
+        tags: data.tags
+      });
+    } else {
+      reset(defaultMarketFormValues);
+    }
+  }, [data]);
+  const {
+    _id,
+    active,
+    cover,
+    coverUpload,
+    dateTime,
+    description,
+    images,
+    imagesUpload,
+    location,
+    logo,
+    logoUpload,
+    name,
+    provider,
+    region,
+    stallApplicationInfo,
+    tags
+  } = getValues();
+  return {
+    control,
+    fields: {
+      _id,
+      active,
+      cover,
+      coverUpload,
+      dateTime,
+      description,
+      images,
+      imagesUpload,
+      location,
+      logo,
+      logoUpload,
+      name,
+      provider,
+      region,
+      stallApplicationInfo,
+      tags
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/useUserForm.ts
+import { yupResolver as yupResolver4 } from "@hookform/resolvers/yup";
+import * as React4 from "react";
+import { useForm as useForm4 } from "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
+  } = useForm4({
+    defaultValues,
+    resolver: yupResolver4(userSchema)
+  });
+  React4.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
+import { yupResolver as yupResolver5 } from "@hookform/resolvers/yup";
+import { useForm as useForm5 } from "react-hook-form";
+var defaultValues2 = {
+  email: "",
+  password: ""
+};
+function useLoginForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = useForm5({
+    defaultValues: defaultValues2,
+    resolver: yupResolver5(loginSchema)
+  });
+  const { email, password } = getValues();
+  return {
+    control,
+    fields: {
+      email,
+      password
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/auth/useRegisterForm.ts
+import { yupResolver as yupResolver6 } from "@hookform/resolvers/yup";
+import { useForm as useForm6 } from "react-hook-form";
+var defaultValues3 = {
+  email: "",
+  firstName: "",
+  lastName: "",
+  password: "",
+  preferredRegion: "",
+  role: "customer" /* CUSTOMER */
+};
+function useRegisterForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = useForm6({
+    defaultValues: defaultValues3,
+    resolver: yupResolver6(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
+import { yupResolver as yupResolver7 } from "@hookform/resolvers/yup";
+import { useForm as useForm7 } from "react-hook-form";
+var defaultValues4 = {
+  email: ""
+};
+function useRequestPasswordResetForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = useForm7({
+    defaultValues: defaultValues4,
+    resolver: yupResolver7(requestPasswordResetSchema)
+  });
+  const { email } = getValues();
+  return {
+    control,
+    fields: {
+      email
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/auth/useValidateTokenForm.ts
+import { yupResolver as yupResolver8 } from "@hookform/resolvers/yup";
+import { useForm as useForm8 } from "react-hook-form";
+var defaultValues5 = {
+  email: "",
+  token: ""
+};
+function useValidateTokenForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = useForm8({
+    defaultValues: defaultValues5,
+    resolver: yupResolver8(validateTokenSchema)
+  });
+  const { email, token } = getValues();
+  return {
+    control,
+    fields: {
+      email,
+      token
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+
+// src/hooks/auth/useResetPasswordForm.ts
+import { yupResolver as yupResolver9 } from "@hookform/resolvers/yup";
+import { useForm as useForm9 } from "react-hook-form";
+var defaultValues6 = {
+  confirmPassword: "",
+  email: "",
+  password: ""
+};
+function useResetPasswordForm() {
+  const {
+    control,
+    formState: { errors },
+    getValues,
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  } = useForm9({
+    defaultValues: defaultValues6,
+    resolver: yupResolver9(resetPasswordSchema)
+  });
+  const { confirmPassword, email, password } = getValues();
+  return {
+    control,
+    fields: {
+      confirmPassword,
+      email,
+      password
+    },
+    formState: { errors },
+    handleSubmit,
+    reset,
+    setValue,
+    watch
+  };
+}
+export {
+  defaultMarketFormValues,
+  defaultStallholderApplyFormValues,
+  defaultStallholderFormValues,
+  globalDefaultValues,
+  useLocationSearch,
+  useLoginForm,
+  useMarketForm,
+  useRegisterForm,
+  useRequestPasswordResetForm,
+  useResetPasswordForm,
+  useStallholderApplyForm,
+  useStallholderForm,
+  useUserForm,
+  useValidateTokenForm
+};
+//# sourceMappingURL=index.mjs.map