react-antd-admin-panel/dist/useForm-nHibry26.js

Modern TypeScript-first React admin panel builder with Ant Design 6

import { useState, useRef, useCallback, useEffect, useMemo } from "react";
import { G as Get, P as Post } from "./Post-DGMrLEoA.js";
import { useForm as useForm$1 } from "react-hook-form";
function useGet(options) {
  const {
    url,
    params,
    immediate = true,
    enabled = true
  } = options;
  const [data, setData] = useState(void 0);
  const [loading, setLoading] = useState(immediate && enabled);
  const [error, setError] = useState(void 0);
  const getInstanceRef = useRef(null);
  const mountedRef = useRef(true);
  const optionsRef = useRef(options);
  optionsRef.current = options;
  const execute = useCallback(async (overrideParams) => {
    var _a, _b;
    if (getInstanceRef.current) {
      getInstanceRef.current.cancel();
    }
    const currentOptions = optionsRef.current;
    const get = new Get().target(currentOptions.url).params({ ...currentOptions.params, ...overrideParams });
    if (currentOptions.headers) {
      get.headers(currentOptions.headers);
    }
    getInstanceRef.current = get;
    if (mountedRef.current) {
      setLoading(true);
      setError(void 0);
    }
    try {
      const result = await get.execute();
      if (mountedRef.current) {
        setData(result);
        setLoading(false);
        (_a = currentOptions.onSuccess) == null ? void 0 : _a.call(currentOptions, result);
      }
      return result;
    } catch (err) {
      const error2 = err instanceof Error ? err : new Error(String(err));
      if (error2.name === "CanceledError" || error2.name === "AbortError") {
        return void 0;
      }
      if (mountedRef.current) {
        setError(error2);
        setLoading(false);
        (_b = currentOptions.onError) == null ? void 0 : _b.call(currentOptions, error2);
      }
      return void 0;
    }
  }, []);
  const abort = useCallback(() => {
    if (getInstanceRef.current) {
      getInstanceRef.current.cancel();
      getInstanceRef.current = null;
    }
    if (mountedRef.current) {
      setLoading(false);
    }
  }, []);
  const reset = useCallback(() => {
    abort();
    if (mountedRef.current) {
      setData(void 0);
      setError(void 0);
      setLoading(false);
    }
  }, [abort]);
  useEffect(() => {
    if (immediate && enabled) {
      execute();
    }
  }, [url, immediate, enabled, execute]);
  useEffect(() => {
  }, [params]);
  useEffect(() => {
    mountedRef.current = true;
    return () => {
      mountedRef.current = false;
      if (getInstanceRef.current) {
        getInstanceRef.current.cancel();
      }
    };
  }, []);
  return {
    data,
    loading,
    error,
    execute,
    abort,
    reset
  };
}
function usePost(options) {
  const [submitting, setSubmitting] = useState(false);
  const [error, setError] = useState(void 0);
  const [data, setData] = useState(void 0);
  const postInstanceRef = useRef(null);
  const mountedRef = useRef(true);
  const optionsRef = useRef(options);
  optionsRef.current = options;
  const execute = useCallback(async (body) => {
    var _a, _b;
    if (postInstanceRef.current) {
      postInstanceRef.current.cancel();
    }
    const currentOptions = optionsRef.current;
    const post = new Post().target(currentOptions.url).method(currentOptions.method || "POST");
    if (body !== void 0) {
      post.body(body);
    }
    if (currentOptions.headers) {
      post.headers(currentOptions.headers);
    }
    postInstanceRef.current = post;
    if (mountedRef.current) {
      setSubmitting(true);
      setError(void 0);
    }
    try {
      const result = await post.execute();
      if (mountedRef.current) {
        setData(result);
        setSubmitting(false);
        (_a = currentOptions.onSuccess) == null ? void 0 : _a.call(currentOptions, result);
      }
      return result;
    } catch (err) {
      const error2 = err instanceof Error ? err : new Error(String(err));
      if (error2.name === "CanceledError" || error2.name === "AbortError") {
        return void 0;
      }
      if (mountedRef.current) {
        setError(error2);
        setSubmitting(false);
        (_b = currentOptions.onError) == null ? void 0 : _b.call(currentOptions, error2);
      }
      return void 0;
    }
  }, []);
  const abort = useCallback(() => {
    if (postInstanceRef.current) {
      postInstanceRef.current.cancel();
      postInstanceRef.current = null;
    }
    if (mountedRef.current) {
      setSubmitting(false);
    }
  }, []);
  const reset = useCallback(() => {
    abort();
    if (mountedRef.current) {
      setData(void 0);
      setError(void 0);
      setSubmitting(false);
    }
  }, [abort]);
  if (mountedRef.current === false) {
    mountedRef.current = true;
  }
  return {
    execute,
    submitting,
    error,
    data,
    reset,
    abort
  };
}
function useList(options) {
  const {
    pagination: paginationConfig,
    initialFilters = {},
    rowKey = "id",
    enabled = true
  } = options;
  const [data, setData] = useState([]);
  const [loading, setLoading] = useState(enabled);
  const [error, setError] = useState(void 0);
  const [pagination, setPaginationState] = useState(() => ({
    current: 1,
    pageSize: 10,
    total: 0,
    ...paginationConfig !== false ? paginationConfig : {}
  }));
  const [filters, setFiltersState] = useState(initialFilters);
  const [selectedRowKeys, setSelectedRowKeys] = useState([]);
  const getInstanceRef = useRef(null);
  const mountedRef = useRef(true);
  const optionsRef = useRef(options);
  optionsRef.current = options;
  const getRowKey = useCallback((record) => {
    if (typeof rowKey === "function") {
      return rowKey(record);
    }
    return record[rowKey];
  }, [rowKey]);
  const selectedRows = useMemo(() => {
    if (selectedRowKeys.length === 0) return [];
    return data.filter((item) => selectedRowKeys.includes(getRowKey(item)));
  }, [data, selectedRowKeys, getRowKey]);
  const fetchData = useCallback(async () => {
    var _a, _b;
    if (getInstanceRef.current) {
      getInstanceRef.current.cancel();
    }
    const currentOptions = optionsRef.current;
    const currentGet = typeof currentOptions.get === "string" ? { url: currentOptions.get } : currentOptions.get;
    const params = {
      ...currentGet.params,
      ...filters
    };
    if (paginationConfig !== false) {
      params.page = pagination.current;
      params.pageSize = pagination.pageSize;
    }
    const get = new Get().target(currentGet.url).params(params);
    if (currentGet.headers) {
      get.headers(currentGet.headers);
    }
    getInstanceRef.current = get;
    if (mountedRef.current) {
      setLoading(true);
      setError(void 0);
    }
    try {
      const response = await get.execute();
      if (mountedRef.current) {
        let resultData;
        let total;
        if (currentOptions.transform) {
          const transformed = currentOptions.transform(response);
          resultData = transformed.data;
          total = transformed.total;
        } else if (Array.isArray(response)) {
          resultData = response;
          total = response.length;
        } else if (response && typeof response === "object") {
          resultData = response.data || response.items || response.records || [];
          total = response.total ?? response.totalCount ?? response.count ?? resultData.length;
        } else {
          resultData = [];
          total = 0;
        }
        setData(resultData);
        if (paginationConfig !== false && total !== void 0) {
          setPaginationState((prev) => ({ ...prev, total }));
        }
        setLoading(false);
        (_a = currentOptions.onSuccess) == null ? void 0 : _a.call(currentOptions, resultData);
      }
    } catch (err) {
      const error2 = err instanceof Error ? err : new Error(String(err));
      if (error2.name === "CanceledError" || error2.name === "AbortError") {
        return;
      }
      if (mountedRef.current) {
        setError(error2);
        setLoading(false);
        (_b = currentOptions.onError) == null ? void 0 : _b.call(currentOptions, error2);
      }
    }
  }, [filters, pagination.current, pagination.pageSize, paginationConfig]);
  const refresh = useCallback(async () => {
    await fetchData();
  }, [fetchData]);
  const setPagination = useCallback((newPagination) => {
    setPaginationState((prev) => ({ ...prev, ...newPagination }));
  }, []);
  const setFilters = useCallback((newFilters) => {
    setFiltersState(newFilters);
    setPaginationState((prev) => ({ ...prev, current: 1 }));
  }, []);
  const clearSelection = useCallback(() => {
    setSelectedRowKeys([]);
  }, []);
  const reset = useCallback(() => {
    if (getInstanceRef.current) {
      getInstanceRef.current.cancel();
    }
    setData([]);
    setError(void 0);
    setLoading(false);
    setPaginationState({
      current: 1,
      pageSize: paginationConfig !== false ? (paginationConfig == null ? void 0 : paginationConfig.pageSize) ?? 10 : 10,
      total: 0
    });
    setFiltersState(initialFilters);
    setSelectedRowKeys([]);
  }, [initialFilters, paginationConfig]);
  useEffect(() => {
    if (enabled) {
      fetchData();
    }
  }, [enabled, fetchData]);
  useEffect(() => {
    mountedRef.current = true;
    return () => {
      mountedRef.current = false;
      if (getInstanceRef.current) {
        getInstanceRef.current.cancel();
      }
    };
  }, []);
  return {
    data,
    loading,
    error,
    refresh,
    pagination,
    setPagination,
    filters,
    setFilters,
    selectedRowKeys,
    setSelectedRowKeys,
    selectedRows,
    clearSelection,
    reset
  };
}
function useForm(options) {
  const {
    initialValues,
    mode = "onSubmit"
  } = options;
  const [submitting, setSubmitting] = useState(false);
  const optionsRef = useRef(options);
  optionsRef.current = options;
  const form = useForm$1({
    defaultValues: initialValues,
    mode
  });
  const {
    register,
    reset: rhfReset,
    formState: { errors, isDirty, isValid },
    setValue: rhfSetValue,
    getValues,
    getFieldState,
    trigger,
    clearErrors,
    setError: rhfSetError,
    watch
  } = form;
  const setValue = useCallback((name, value) => {
    rhfSetValue(name, value, { shouldValidate: true, shouldDirty: true });
  }, [rhfSetValue]);
  const setValues = useCallback((values2) => {
    Object.entries(values2).forEach(([key, value]) => {
      rhfSetValue(key, value, { shouldValidate: true, shouldDirty: true });
    });
  }, [rhfSetValue]);
  const submit = useCallback(async () => {
    var _a, _b, _c;
    const currentOptions = optionsRef.current;
    const isFormValid = await trigger();
    if (!isFormValid) {
      return;
    }
    const values2 = getValues();
    if (currentOptions.validate) {
      const validationErrors = await currentOptions.validate(values2);
      if (Object.keys(validationErrors).length > 0) {
        Object.entries(validationErrors).forEach(([field, message]) => {
          rhfSetError(field, { type: "validate", message });
        });
        return;
      }
    }
    setSubmitting(true);
    try {
      if (currentOptions.post) {
        const postInstance = new Post().target(currentOptions.post.url).method(currentOptions.post.method || "POST").body(values2);
        if (currentOptions.post.headers) {
          postInstance.headers(currentOptions.post.headers);
        }
        const response = await postInstance.execute();
        (_b = (_a = currentOptions.post).onSuccess) == null ? void 0 : _b.call(_a, response);
      } else if (currentOptions.onSubmit) {
        await currentOptions.onSubmit(values2);
      }
    } catch (error) {
      if ((_c = currentOptions.post) == null ? void 0 : _c.onError) {
        currentOptions.post.onError(error instanceof Error ? error : new Error(String(error)));
      }
      throw error;
    } finally {
      setSubmitting(false);
    }
  }, [trigger, getValues, rhfSetError]);
  const reset = useCallback((values2) => {
    rhfReset(values2 ?? initialValues);
  }, [rhfReset, initialValues]);
  const values = watch();
  return {
    values,
    errors,
    setValue,
    setValues,
    submit,
    submitting,
    reset,
    isDirty,
    isValid,
    register,
    getFieldState,
    trigger,
    clearErrors,
    setError: rhfSetError,
    watch
  };
}
export {
  usePost as a,
  useList as b,
  useForm as c,
  useGet as u
};
//# sourceMappingURL=useForm-nHibry26.js.map