@hirely/hooks 0.1.0

package/dist/index.js

@@ -0,0 +1,535 @@
+"use client";
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/useFormHandler.ts
+import { useState, useRef, useCallback, useMemo as useMemo2 } from "react";
+import { useForm } from "react-hook-form";
+
+// node_modules/@hookform/resolvers/dist/resolvers.mjs
+import { get as e, set as r } from "react-hook-form";
+var t = (r2, t2, s) => {
+  if (r2 && "reportValidity" in r2) {
+    const o = e(s, t2);
+    r2.setCustomValidity(o && o.message || ""), r2.reportValidity();
+  }
+};
+var s = (e2, r2) => {
+  for (const s2 in r2.fields) {
+    const o = r2.fields[s2];
+    o && o.ref && "reportValidity" in o.ref ? t(o.ref, s2, e2) : o && o.refs && o.refs.forEach((r3) => t(r3, s2, e2));
+  }
+};
+var o = (t2, o2) => {
+  o2.shouldUseNativeValidation && s(t2, o2);
+  const n = {};
+  for (const s2 in t2) {
+    const f = e(o2.fields, s2), c = Object.assign(t2[s2] || {}, { ref: f && f.refs ? f.refs[0] : f && f.ref });
+    if (i(o2.names || Object.keys(t2), s2)) {
+      const t3 = Object.assign({}, e(n, s2));
+      r(t3, "root", c), r(n, s2, t3);
+    } else
+      r(n, s2, c);
+  }
+  return n;
+};
+var i = (e2, r2) => {
+  const t2 = n(r2).replace(/[.*+?^${}()|\\]/g, "\\$&");
+  return e2.some((e3) => n(e3).match(`^${t2}\\.\\d+`));
+};
+function n(e2) {
+  return e2.replace(/\[(\d+)]/g, ".$1").replace(/[[\]]/g, "");
+}
+
+// node_modules/@hookform/resolvers/zod/dist/zod.mjs
+import { appendErrors as n2 } from "react-hook-form";
+function o2() {
+  return o2 = Object.assign ? Object.assign.bind() : function(r2) {
+    for (var e2 = 1;e2 < arguments.length; e2++) {
+      var n3 = arguments[e2];
+      for (var o3 in n3)
+        ({}).hasOwnProperty.call(n3, o3) && (r2[o3] = n3[o3]);
+    }
+    return r2;
+  }, o2.apply(null, arguments);
+}
+function t2(r2, e2) {
+  try {
+    var n3 = r2();
+  } catch (r3) {
+    return e2(r3);
+  }
+  return n3 && n3.then ? n3.then(undefined, e2) : n3;
+}
+function s2(r2, e2) {
+  for (var o3 = Object.create(null);r2.length; ) {
+    var t3 = r2[0], s3 = t3.code, i2 = t3.message, u = t3.path.join(".");
+    if (!o3[u])
+      if ("unionErrors" in t3) {
+        var a, c, l = t3.unionErrors.reduce(function(r3, e3) {
+          return e3.errors.length < r3.errors.length ? e3 : r3;
+        }).errors[0];
+        o3[u] = { message: (a = l == null ? undefined : l.message) != null ? a : i2, type: (c = l == null ? undefined : l.code) != null ? c : s3 };
+      } else
+        o3[u] = { message: i2, type: s3 };
+    if ("unionErrors" in t3 && t3.unionErrors.forEach(function(e3) {
+      return e3.errors.forEach(function(e4) {
+        return r2.push(e4);
+      });
+    }), e2) {
+      var f = o3[u].types, d = f && f[t3.code];
+      o3[u] = n2(u, e2, o3, s3, d ? [].concat(d, t3.message) : t3.message);
+    }
+    r2.shift();
+  }
+  return o3;
+}
+function i2(r2, e2) {
+  for (var t3 = Object.create(null), s3 = function() {
+    var s4 = r2[0], i3 = s4.code, u = s4.message, a = s4.path.join(".");
+    if (!t3[a])
+      if (s4.code === "invalid_union" && s4.errors.length > 0) {
+        var c, l, f = s4.errors.reduce(function(r3, e3) {
+          return e3.length < r3.length ? e3 : r3;
+        })[0];
+        t3[a] = { message: (c = f == null ? undefined : f.message) != null ? c : u, type: (l = f == null ? undefined : f.code) != null ? l : i3 };
+      } else
+        t3[a] = { message: u, type: i3 };
+    if (s4.code === "invalid_union" && s4.errors.forEach(function(e3) {
+      return e3.forEach(function(e4) {
+        return r2.push(o2({}, e4, { path: [].concat(s4.path, e4.path) }));
+      });
+    }), e2) {
+      var d = t3[a].types, h = d && d[s4.code];
+      t3[a] = n2(a, e2, t3, i3, h ? [].concat(h, s4.message) : s4.message);
+    }
+    r2.shift();
+  };r2.length; )
+    s3();
+  return t3;
+}
+function u(n3, o3, u2) {
+  if (u2 === undefined && (u2 = {}), function(r2) {
+    return "_zod" in r2 && typeof r2._zod == "object";
+  }(n3))
+    return function(s3, a, c) {
+      try {
+        return Promise.resolve(t2(function() {
+          function e2(e3) {
+            return c.shouldUseNativeValidation && s({}, c), { errors: {}, values: u2.raw ? Object.assign({}, s3) : e3 };
+          }
+          var t3 = n3;
+          return u2.mode === "sync" ? e2(t3.parse(s3, o3)) : Promise.resolve(t3.parseAsync(s3, o3)).then(e2);
+        }, function(r2) {
+          if (function(r3) {
+            var e2;
+            return !(r3 == null || (e2 = r3._zod) == null || (e2 = e2.traits) == null || !e2.has("$ZodError"));
+          }(r2))
+            return { values: {}, errors: o(i2(r2.issues, !c.shouldUseNativeValidation && c.criteriaMode === "all"), c) };
+          throw r2;
+        }));
+      } catch (r2) {
+        return Promise.reject(r2);
+      }
+    };
+  if (function(r2) {
+    return "_def" in r2 && typeof r2._def == "object";
+  }(n3))
+    return function(i3, a, c) {
+      try {
+        return Promise.resolve(t2(function() {
+          return Promise.resolve(n3[u2.mode === "sync" ? "parse" : "parseAsync"](i3, o3)).then(function(e2) {
+            return c.shouldUseNativeValidation && s({}, c), { errors: {}, values: u2.raw ? Object.assign({}, i3) : e2 };
+          });
+        }, function(r2) {
+          if (function(r3) {
+            return Array.isArray(r3 == null ? undefined : r3.issues);
+          }(r2))
+            return { values: {}, errors: o(s2(r2.errors, !c.shouldUseNativeValidation && c.criteriaMode === "all"), c) };
+          throw r2;
+        }));
+      } catch (r2) {
+        return Promise.reject(r2);
+      }
+    };
+  throw new Error("Invalid input: not a Zod schema");
+}
+
+// src/context.tsx
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+"use client";
+var FormHandlerContext = createContext({});
+var FormHandlerProvider = ({
+  children,
+  defaultOptions
+}) => {
+  const value = useMemo(() => defaultOptions, [defaultOptions]);
+  return /* @__PURE__ */ jsx(FormHandlerContext.Provider, {
+    value,
+    children
+  });
+};
+var useFormHandlerContext = () => useContext(FormHandlerContext);
+
+// src/useFormHandler.ts
+"use client";
+var defaultParseResponse = (res) => ({
+  success: res?.success !== undefined ? Boolean(res.success) : true,
+  message: res?.message,
+  data: res
+});
+var defaultParseError = (err) => {
+  let message = "Request failed";
+  if (err?.isAxiosError) {
+    message = err?.response?.data?.message || err.message || message;
+    if (err.code === "ERR_CANCELED") {
+      message = "Request was cancelled";
+    }
+  } else if (err instanceof Error) {
+    message = err.message;
+  }
+  return { message };
+};
+var cachedAxios = null;
+var axiosLoadPromise = null;
+var getAxios = async () => {
+  if (cachedAxios)
+    return cachedAxios;
+  if (!axiosLoadPromise) {
+    axiosLoadPromise = import("axios").then((m) => {
+      cachedAxios = m.default || m;
+      return cachedAxios;
+    }).catch(() => {
+      axiosLoadPromise = null;
+      return null;
+    });
+  }
+  return axiosLoadPromise;
+};
+var cachedSonnerToast = null;
+var sonnerLoadPromise = null;
+var getSonnerToast = async () => {
+  if (cachedSonnerToast)
+    return cachedSonnerToast;
+  if (!sonnerLoadPromise) {
+    sonnerLoadPromise = import("sonner").then((m) => {
+      cachedSonnerToast = m.toast || m;
+      return cachedSonnerToast;
+    }).catch(() => {
+      sonnerLoadPromise = null;
+      return null;
+    });
+  }
+  return sonnerLoadPromise;
+};
+function useFormHandlerInternal(options) {
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const {
+    schema,
+    defaultValues,
+    values,
+    mode = "onSubmit",
+    reValidateMode = "onChange"
+  } = options;
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const abortControllerRef = useRef(null);
+  const form = useForm({
+    resolver: u(schema),
+    defaultValues,
+    values,
+    mode,
+    reValidateMode
+  });
+  const abort = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+  }, []);
+  const submitHandler = useCallback(async (data) => {
+    const currentOptions = optionsRef.current;
+    const {
+      endpoint,
+      method = "post",
+      service,
+      transformData,
+      onMutate,
+      onSuccess,
+      onError,
+      onSubmitStart,
+      onSubmitEnd,
+      notify,
+      resetOptions = { resetAfterSuccess: true, keepDefaultValues: true },
+      useFormData = false,
+      enableAbort = false,
+      axiosConfig = {},
+      parseResponse = defaultParseResponse,
+      parseError = defaultParseError
+    } = currentOptions;
+    let context;
+    const transformedData = transformData ? transformData(data) : data;
+    let notifyFn;
+    if (notify) {
+      notifyFn = notify;
+    } else {
+      const toast = await getSonnerToast();
+      if (toast) {
+        notifyFn = (message, type) => {
+          if (type === "success") {
+            toast.success(message);
+          } else {
+            toast.error(message);
+          }
+        };
+      } else {
+        notifyFn = () => {};
+      }
+    }
+    if (enableAbort) {
+      abortControllerRef.current = new AbortController;
+    }
+    try {
+      setLoading(true);
+      setError(null);
+      onSubmitStart?.();
+      if (onMutate) {
+        context = await onMutate(data);
+      }
+      let responseData;
+      let payload = transformedData;
+      if (useFormData) {
+        const formData = new FormData;
+        if (transformedData && typeof transformedData === "object") {
+          for (const [key, value] of Object.entries(transformedData)) {
+            if (value instanceof File || value instanceof Blob) {
+              formData.append(key, value);
+            } else if (Array.isArray(value)) {
+              for (const item of value) {
+                if (item instanceof File || item instanceof Blob) {
+                  formData.append(key, item);
+                } else if (item !== undefined && item !== null) {
+                  formData.append(key, String(item));
+                }
+              }
+            } else if (value !== undefined && value !== null) {
+              formData.append(key, String(value));
+            }
+          }
+        }
+        payload = formData;
+      }
+      if (service) {
+        responseData = await service(payload);
+      } else {
+        if (!endpoint) {
+          throw new Error("No endpoint or service provided");
+        }
+        const axiosInstance = await getAxios();
+        if (!axiosInstance) {
+          throw new Error("axios is not installed. Please install axios or provide a custom `service` function.");
+        }
+        const config = {
+          method,
+          url: endpoint,
+          data: payload,
+          ...axiosConfig,
+          signal: enableAbort ? abortControllerRef.current?.signal : undefined,
+          headers: useFormData ? {
+            ...axiosConfig.headers,
+            "Content-Type": "multipart/form-data"
+          } : axiosConfig.headers
+        };
+        const res = await axiosInstance(config);
+        responseData = res.data;
+      }
+      const parsed = parseResponse(responseData);
+      const isSuccess = parsed.success;
+      const message = parsed.message || (isSuccess ? "Success" : "Something went wrong");
+      if (isSuccess) {
+        notifyFn(message, "success");
+        onSuccess?.(responseData, context);
+        if (resetOptions.resetAfterSuccess !== false) {
+          form.reset(undefined, {
+            keepDefaultValues: resetOptions.keepDefaultValues !== false,
+            keepDirty: resetOptions.keepDirty || false,
+            keepTouched: false,
+            keepErrors: false,
+            keepValues: false
+          });
+        }
+      } else {
+        notifyFn(message, "error");
+        onError?.(responseData, context);
+        setError(new Error(message));
+      }
+    } catch (err) {
+      const parsedError = parseError(err);
+      const errorMsg = parsedError.message;
+      setError(new Error(errorMsg));
+      notifyFn(errorMsg, "error");
+      onError?.(err, context);
+    } finally {
+      setLoading(false);
+      onSubmitEnd?.();
+      abortControllerRef.current = null;
+    }
+  }, [form]);
+  const onSubmit = useMemo2(() => form.handleSubmit(submitHandler), [form, submitHandler]);
+  return useMemo2(() => ({
+    ...form,
+    onSubmit,
+    loading,
+    error,
+    setError,
+    abort: options.enableAbort ? abort : undefined
+  }), [form, onSubmit, loading, error, setError, abort, options.enableAbort]);
+}
+function useFormHandler(options) {
+  const contextOptions = useFormHandlerContext();
+  const mergedOptions = useMemo2(() => {
+    return {
+      ...contextOptions,
+      ...options,
+      axiosConfig: {
+        ...contextOptions.axiosConfig || {},
+        ...options.axiosConfig || {}
+      },
+      resetOptions: {
+        ...contextOptions.resetOptions || {},
+        ...options.resetOptions || {}
+      }
+    };
+  }, [contextOptions, options]);
+  return useFormHandlerInternal(mergedOptions);
+}
+function createFormHandler(defaultOptions) {
+  return function useCreatedFormHandler(options) {
+    const mergedOptions = useMemo2(() => {
+      return {
+        ...defaultOptions,
+        ...options,
+        axiosConfig: {
+          ...defaultOptions.axiosConfig || {},
+          ...options.axiosConfig || {}
+        },
+        resetOptions: {
+          ...defaultOptions.resetOptions || {},
+          ...options.resetOptions || {}
+        }
+      };
+    }, [options]);
+    return useFormHandlerInternal(mergedOptions);
+  };
+}
+// src/withFormHandler.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+"use client";
+function withFormHandler(WrappedComponent, options) {
+  const WithFormHandler = (props) => {
+    const formHandler = useFormHandler(options);
+    return /* @__PURE__ */ jsx2(WrappedComponent, {
+      ...props,
+      formHandler
+    });
+  };
+  WithFormHandler.displayName = `WithFormHandler(${WrappedComponent.displayName || WrappedComponent.name || "Component"})`;
+  return WithFormHandler;
+}
+// src/useFormMutation.ts
+import { useMutation } from "@tanstack/react-query";
+import { useMemo as useMemo3, useRef as useRef2 } from "react";
+"use client";
+var cachedAxios2 = null;
+var axiosLoadPromise2 = null;
+var getAxios2 = async () => {
+  if (cachedAxios2)
+    return cachedAxios2;
+  if (!axiosLoadPromise2) {
+    axiosLoadPromise2 = import("axios").then((m) => {
+      cachedAxios2 = m.default || m;
+      return cachedAxios2;
+    }).catch(() => {
+      axiosLoadPromise2 = null;
+      return null;
+    });
+  }
+  return axiosLoadPromise2;
+};
+function useFormMutation(options) {
+  const { mutationOptions, ...formOptions } = options;
+  const optionsRef = useRef2(options);
+  optionsRef.current = options;
+  const form = useFormHandler(formOptions);
+  const mutationFn = useMemo3(() => {
+    return async (data) => {
+      const currentOpts = optionsRef.current;
+      if (currentOpts.service) {
+        return await currentOpts.service(data);
+      }
+      if (currentOpts.endpoint) {
+        const axiosInstance = await getAxios2();
+        if (!axiosInstance) {
+          throw new Error("axios is not installed. Please install axios or provide a custom `service` function.");
+        }
+        const res = await axiosInstance({
+          method: currentOpts.method || "post",
+          url: currentOpts.endpoint,
+          data,
+          ...currentOpts.axiosConfig
+        });
+        return res.data;
+      }
+      throw new Error("No service or endpoint provided");
+    };
+  }, []);
+  const mutation = useMutation({
+    mutationFn,
+    ...mutationOptions,
+    onSuccess: (data, variables, context) => {
+      optionsRef.current.onSuccess?.(data, context);
+      if (mutationOptions?.onSuccess) {
+        mutationOptions.onSuccess(data, variables, context);
+      }
+    },
+    onError: (error, variables, context) => {
+      optionsRef.current.onError?.(error, context);
+      if (mutationOptions?.onError) {
+        mutationOptions.onError(error, variables, context);
+      }
+    }
+  });
+  const reset = () => {
+    mutation.reset();
+    form.reset();
+  };
+  return {
+    ...form,
+    mutate: mutation.mutate,
+    mutateAsync: mutation.mutateAsync,
+    isPending: mutation.isPending,
+    isLoading: mutation.isPending,
+    isError: mutation.isError,
+    error: mutation.error,
+    formError: form.error,
+    data: mutation.data,
+    reset,
+    resetForm: form.reset,
+    resetMutation: mutation.reset,
+    status: mutation.status
+  };
+}
+
+// src/index.ts
+"use client";
+export {
+  FormHandlerProvider,
+  createFormHandler,
+  useFormHandler,
+  useFormHandlerContext,
+  useFormHandlerInternal,
+  useFormMutation,
+  withFormHandler
+};