alibaba / hooks / #42

Committed 13 Mar 2024 02:04PM UTC coverage: 90.705% (+0.2%) from 90.554%

Build # #42

Build Type

push

travis-pro

Committed by

web-flow

Commit Message

fix(useCountDown): targetDate resets leftTime (#2346)

Run Details

1088 of 1336 branches covered (81.44%)

Branch coverage included in aggregate %.

3 of 3 new or added lines in 1 file covered. (100.0%)

12 existing lines in 2 files now uncovered.

2542 of 2666 relevant lines covered (95.35%)

90.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.95

/packages/hooks/src/useAntdTable/index.tsx

import { useEffect, useRef, useState } from 'react';
import useMemoizedFn from '../useMemoizedFn';
import usePagination from '../usePagination';
import useUpdateEffect from '../useUpdateEffect';

import type {
  Antd4ValidateFields,
  AntdTableOptions,
  Data,
  Params,
  Service,
  AntdTableResult,
} from './types';

const useAntdTable = <TData extends Data, TParams extends Params>(
  service: Service<TData, TParams>,
  options: AntdTableOptions<TData, TParams> = {},
) => {
  const {
    form,
    defaultType = 'simple',
    defaultParams,
    manual = false,
    refreshDeps = [],
    ready = true,
    ...rest
  } = options;

  const result = usePagination<TData, TParams>(service, {
    ready,
    manual: true,
    ...rest,
    onSuccess(...args) {
      // eslint-disable-next-line @typescript-eslint/no-use-before-define
      runSuccessRef.current = true;
      rest.onSuccess?.(...args);
    },
  });

  const { params = [], run } = result;

  const cacheFormTableData = params[2] || ({} as any);

  const [type, setType] = useState(cacheFormTableData?.type || defaultType);

  const allFormDataRef = useRef<Record<string, any>>({});
  const defaultDataSourceRef = useRef([]);
  const runSuccessRef = useRef(false);

  const isAntdV4 = !!form?.getInternalHooks;

  // get current active field values
  const getActiveFieldValues = () => {
    if (!form) {
      return {};
    }

    // antd 4
    if (isAntdV4) {
      return form.getFieldsValue(null, () => true);
    }

    // antd 3
    const allFieldsValue = form.getFieldsValue();
    const activeFieldsValue = {};
    Object.keys(allFieldsValue).forEach((key: string) => {
      if (form.getFieldInstance ? form.getFieldInstance(key) : true) {
        activeFieldsValue[key] = allFieldsValue[key];
      }
    });

    return activeFieldsValue;
  };

  const validateFields = (): Promise<Record<string, any>> => {
    if (!form) {
      return Promise.resolve({});
    }
    const activeFieldsValue = getActiveFieldValues();
    const fields = Object.keys(activeFieldsValue);

    // antd 4
    if (isAntdV4) {
      return (form.validateFields as Antd4ValidateFields)(fields);
    }
    // antd 3
    return new Promise((resolve, reject) => {
      form.validateFields(fields, (errors, values) => {
        if (errors) {
          reject(errors);
        } else {
          resolve(values);
        }
      });
    });
  };

  const restoreForm = () => {
    if (!form) {
      return;
    }

    // antd v4
    if (isAntdV4) {
      return form.setFieldsValue(allFormDataRef.current);
    }

    // antd v3
    const activeFieldsValue = {};
    Object.keys(allFormDataRef.current).forEach((key) => {
      if (form.getFieldInstance ? form.getFieldInstance(key) : true) {
        activeFieldsValue[key] = allFormDataRef.current[key];
      }
    });
    form.setFieldsValue(activeFieldsValue);
  };

  const changeType = () => {
    const activeFieldsValue = getActiveFieldValues();
    allFormDataRef.current = {
      ...allFormDataRef.current,
      ...activeFieldsValue,
    };
    setType((t) => (t === 'simple' ? 'advance' : 'simple'));
  };

  const _submit = (initPagination?: TParams[0]) => {
    if (!ready) {
      return;
    }
    setTimeout(() => {
      validateFields()
        .then((values = {}) => {
          const pagination = initPagination || {
            pageSize: options.defaultPageSize || 10,
            ...(params?.[0] || {}),
            current: 1,
          };
          if (!form) {
            // @ts-ignore
            run(pagination);
            return;
          }

          // record all form data
          allFormDataRef.current = {
            ...allFormDataRef.current,
            ...values,
          };

          // @ts-ignore
          run(pagination, values, {
            allFormData: allFormDataRef.current,
            type,
          });
        })
        .catch((err) => err);
    });
  };

  const reset = () => {
    if (form) {
      form.resetFields();
    }
    _submit({
      ...(defaultParams?.[0] || {}),
      pageSize: options.defaultPageSize || options.defaultParams?.[0]?.pageSize || 10,
      current: 1,
    });
  };

  const submit = (e?: any) => {
    e?.preventDefault?.();
    _submit(
      runSuccessRef.current
        ? undefined
        : {
            pageSize: options.defaultPageSize || options.defaultParams?.[0]?.pageSize || 10,
            current: 1,
            ...(defaultParams?.[0] || {}),
          },
    );
  };

  const onTableChange = (pagination: any, filters: any, sorter: any, extra: any) => {
    const [oldPaginationParams, ...restParams] = params || [];
    run(
      // @ts-ignore
      {
        ...oldPaginationParams,
        current: pagination.current,
        pageSize: pagination.pageSize,
        filters,
        sorter,
        extra,
      },
      ...restParams,
    );
  };

  // init
  useEffect(() => {
    // if has cache, use cached params. ignore manual and ready.
    if (params.length > 0) {
      allFormDataRef.current = cacheFormTableData?.allFormData || {};
      restoreForm();
      // @ts-ignore
      run(...params);
      return;
    }
    if (!manual && ready) {
      allFormDataRef.current = defaultParams?.[1] || {};
      restoreForm();
      _submit(defaultParams?.[0]);
    }
  }, []);

  // change search type, restore form data
  useUpdateEffect(() => {
    if (!ready) {
      return;
    }
    restoreForm();
  }, [type]);

  // refresh & ready change on the same time
  const hasAutoRun = useRef(false);
  hasAutoRun.current = false;

  useUpdateEffect(() => {
    if (!manual && ready) {
      hasAutoRun.current = true;
      if (form) {
        form.resetFields();
      }
      allFormDataRef.current = defaultParams?.[1] || {};
      restoreForm();
      _submit(defaultParams?.[0]);
    }
  }, [ready]);

  useUpdateEffect(() => {
    if (hasAutoRun.current) {
      return;
    }
    if (!ready) {
      return;
    }
    if (!manual) {
      hasAutoRun.current = true;
      result.pagination.changeCurrent(1);
    }
  }, [...refreshDeps]);

  return {
    ...result,
    tableProps: {
      dataSource: result.data?.list || defaultDataSourceRef.current,
      loading: result.loading,
      onChange: useMemoizedFn(onTableChange),
      pagination: {
        current: result.pagination.current,
        pageSize: result.pagination.pageSize,
        total: result.pagination.total,
      },
    },
    search: {
      submit: useMemoizedFn(submit),
      type,
      changeType: useMemoizedFn(changeType),
      reset: useMemoizedFn(reset),
    },
  } as AntdTableResult<TData, TParams>;
};

export default useAntdTable;

1	import { useEffect, useRef, useState } from 'react';	3✔
2	import useMemoizedFn from '../useMemoizedFn';	3✔
3	import usePagination from '../usePagination';	3✔
4	import useUpdateEffect from '../useUpdateEffect';	3✔
5
6	import type {
7	Antd4ValidateFields,
8	AntdTableOptions,
9	Data,
10	Params,
11	Service,
12	AntdTableResult,
13	} from './types';
14
15	const useAntdTable = <TData extends Data, TParams extends Params>(	3✔
16	service: Service<TData, TParams>,
17	options: AntdTableOptions<TData, TParams> = {},	50!
18	) => {
19	const {
20	form,
21	defaultType = 'simple',	50✔
22	defaultParams,
23	manual = false,	50!
24	refreshDeps = [],	50!
25	ready = true,	50✔
26	...rest	50✔
27	} = options;	300✔
28
29	const result = usePagination<TData, TParams>(service, {	50✔
30	ready,
31	manual: true,
32	...rest,
33	onSuccess(...args) {	84✔
34	// eslint-disable-next-line @typescript-eslint/no-use-before-define
35	runSuccessRef.current = true;	21✔
36	rest.onSuccess?.(...args);	21!
37	},
38	});
39
40	const { params = [], run } = result;	100!
41
42	const cacheFormTableData = params[2] \|\| ({} as any);	50✔
43
44	const [type, setType] = useState(cacheFormTableData?.type \|\| defaultType);	50!
45
46	const allFormDataRef = useRef<Record<string, any>>({});	50✔
47	const defaultDataSourceRef = useRef([]);	50✔
48	const runSuccessRef = useRef(false);	50✔
49
50	const isAntdV4 = !!form?.getInternalHooks;	50✔
51
52	// get current active field values
53	const getActiveFieldValues = () => {	50✔
54	if (!form) {	15!
UNCOV 55	return {};	×
56	}
57
58	// antd 4
59	if (isAntdV4) {	15✔
60	return form.getFieldsValue(null, () => true);	9✔
61	}
62
63	// antd 3
64	const allFieldsValue = form.getFieldsValue();	6✔
65	const activeFieldsValue = {};	6✔
66	Object.keys(allFieldsValue).forEach((key: string) => {	6✔
67	if (form.getFieldInstance ? form.getFieldInstance(key) : true) {	4!
68	activeFieldsValue[key] = allFieldsValue[key];	2✔
69	}
70	});
71
72	return activeFieldsValue;	6✔
73	};
74
75	const validateFields = (): Promise<Record<string, any>> => {	50✔
76	if (!form) {	19✔
77	return Promise.resolve({});	4✔
78	}
79	const activeFieldsValue = getActiveFieldValues();	15✔
80	const fields = Object.keys(activeFieldsValue);	15✔
81
82	// antd 4
83	if (isAntdV4) {	15✔
84	return (form.validateFields as Antd4ValidateFields)(fields);	9✔
85	}
86	// antd 3
87	return new Promise((resolve, reject) => {	6✔
88	form.validateFields(fields, (errors, values) => {	6✔
89	if (errors) {	6!
UNCOV 90	reject(errors);	×
91	} else {
92	resolve(values);	6✔
93	}
94	});
95	});
96	};
97
98	const restoreForm = () => {	50✔
99	if (!form) {	16✔
100	return;	6✔
101	}
102
103	// antd v4
104	if (isAntdV4) {	10✔
105	return form.setFieldsValue(allFormDataRef.current);	6✔
106	}
107
108	// antd v3
109	const activeFieldsValue = {};	4✔
110	Object.keys(allFormDataRef.current).forEach((key) => {	4✔
111	if (form.getFieldInstance ? form.getFieldInstance(key) : true) {	4!
UNCOV 112	activeFieldsValue[key] = allFormDataRef.current[key];	×
113	}
114	});
115	form.setFieldsValue(activeFieldsValue);	4✔
116	};
117
118	const changeType = () => {	50✔
119	const activeFieldsValue = getActiveFieldValues();	×
UNCOV 120	allFormDataRef.current = {	×
121	...allFormDataRef.current,
122	...activeFieldsValue,
123	};
UNCOV 124	setType((t) => (t === 'simple' ? 'advance' : 'simple'));	×
125	};
126
127	const _submit = (initPagination?: TParams[0]) => {	50✔
128	if (!ready) {	21!
UNCOV 129	return;	×
130	}
131	setTimeout(() => {	21✔
132	validateFields()	19✔
133	.then((values = {}) => {	18!
134	const pagination = initPagination \|\| {	18✔
135	pageSize: options.defaultPageSize \|\| 10,	13✔
136	...(params?.[0] \|\| {}),	34!
137	current: 1,
138	};
139	if (!form) {	18✔
140	// @ts-ignore
141	run(pagination);	4✔
142	return;	4✔
143	}
144
145	// record all form data
146	allFormDataRef.current = {	14✔
147	...allFormDataRef.current,
148	...values,
149	};
150
151	// @ts-ignore
152	run(pagination, values, {	14✔
153	allFormData: allFormDataRef.current,
154	type,
155	});
156	})
157	.catch((err) => err);	1✔
158	});
159	};
160
161	const reset = () => {	50✔
162	if (form) {	3✔
163	form.resetFields();	3✔
164	}
165	_submit({	3✔
166	...(defaultParams?.[0] \|\| {}),	14✔
167	pageSize: options.defaultPageSize \|\| options.defaultParams?.[0]?.pageSize \|\| 10,	18✔
168	current: 1,
169	});
170	};
171
172	const submit = (e?: any) => {	50✔
173	e?.preventDefault?.();	3!
174	_submit(	3✔
175	runSuccessRef.current	3✔
176	? undefined
177	: {
178	pageSize: options.defaultPageSize \|\| options.defaultParams?.[0]?.pageSize \|\| 10,	17✔
179	current: 1,
180	...(defaultParams?.[0] \|\| {}),	9✔
181	},
182	);
183	};
184
185	const onTableChange = (pagination: any, filters: any, sorter: any, extra: any) => {	50✔
186	const [oldPaginationParams, ...restParams] = params \|\| [];	5!
187	run(	5✔
188	// @ts-ignore
189	{
190	...oldPaginationParams,
191	current: pagination.current,
192	pageSize: pagination.pageSize,
193	filters,
194	sorter,
195	extra,
196	},
197	...restParams,
198	);
199	};
200
201	// init
202	useEffect(() => {	50✔
203	// if has cache, use cached params. ignore manual and ready.
204	if (params.length > 0) {	16✔
205	allFormDataRef.current = cacheFormTableData?.allFormData \|\| {};	1!
206	restoreForm();	1✔
207	// @ts-ignore
208	run(...params);	1✔
209	return;	1✔
210	}
211	if (!manual && ready) {	15✔
212	allFormDataRef.current = defaultParams?.[1] \|\| {};	14✔
213	restoreForm();	14✔
214	_submit(defaultParams?.[0]);	14✔
215	}
216	}, []);
217
218	// change search type, restore form data
219	useUpdateEffect(() => {	50✔
220	if (!ready) {	×
UNCOV 221	return;	×
222	}
UNCOV 223	restoreForm();	×
224	}, [type]);
225
226	// refresh & ready change on the same time
227	const hasAutoRun = useRef(false);	50✔
228	hasAutoRun.current = false;	50✔
229
230	useUpdateEffect(() => {	50✔
231	if (!manual && ready) {	1✔
232	hasAutoRun.current = true;	1✔
233	if (form) {	1✔
234	form.resetFields();	1✔
235	}
236	allFormDataRef.current = defaultParams?.[1] \|\| {};	1!
237	restoreForm();	1✔
238	_submit(defaultParams?.[0]);	1!
239	}
240	}, [ready]);
241
242	useUpdateEffect(() => {	50✔
243	if (hasAutoRun.current) {	×
UNCOV 244	return;	×
245	}
246	if (!ready) {	×
UNCOV 247	return;	×
248	}
249	if (!manual) {	×
250	hasAutoRun.current = true;	×
UNCOV 251	result.pagination.changeCurrent(1);	×
252	}
253	}, [...refreshDeps]);
254
255	return {	50✔
256	...result,
257	tableProps: {
258	dataSource: result.data?.list \|\| defaultDataSourceRef.current,	223✔
259	loading: result.loading,
260	onChange: useMemoizedFn(onTableChange),
261	pagination: {
262	current: result.pagination.current,
263	pageSize: result.pagination.pageSize,
264	total: result.pagination.total,
265	},
266	},
267	search: {
268	submit: useMemoizedFn(submit),
269	type,
270	changeType: useMemoizedFn(changeType),
271	reset: useMemoizedFn(reset),
272	},
273	} as AntdTableResult<TData, TParams>;
274	};
275
276	export default useAntdTable;	3✔

alibaba / hooks / #42

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous