10057009462

Committed 23 Jul 2024 10:11AM UTC coverage: 17.811% (-0.04%) from 17.849%

Build # 10057009462

Build Type

Pull #748

github

Committed by

web-flow

Commit Message

Merge dec0c237f into 8d891a1e3

Pull Request Pull Request #748: feat: copy and paste operations for pre-filled rows in the grid

Run Details

1384 of 2805 branches covered (49.34%)

0 of 369 new or added lines in 8 files covered. (0.0%)

1 existing line in 1 file now uncovered.

14014 of 78680 relevant lines covered (17.81%)

1.77 hits per line

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

0.0

/packages/sdk/src/components/grid-enhancements/hooks/use-grid-prefilling-row.ts

import type { IUpdateOrderRo } from '@teable/openapi';
import { isEqual } from 'lodash';
import { useCallback, useMemo, useState } from 'react';
import { useFieldCellEditable, useFields } from '../../../hooks';
import { createRecordInstance } from '../../../model';
import { CellType } from '../../grid/interface';
import type { ICell, ICellItem, IGridColumn, IInnerCell } from '../../grid/interface';
import { createCellValue2GridDisplay } from './use-grid-columns';

export const useGridPrefillingRow = (columns: (IGridColumn & { id: string })[]) => {
  const fields = useFields();
  const fieldEditable = useFieldCellEditable();

  const [prefillingRowOrder, setPrefillingRowOrder] = useState<IUpdateOrderRo>();
  const [prefillingRowIndex, setPrefillingRowIndex] = useState<number>();
  const [prefillingFieldValueMap, setPrefillingFieldValueMap] = useState<
    { [fieldId: string]: unknown } | undefined
  >();

  const localRecord = useMemo(() => {
    if (prefillingFieldValueMap == null) {
      return null;
    }

    const record = createRecordInstance({
      id: '',
      fields: prefillingFieldValueMap,
    });
    record.getCellValue = (fieldId: string) => {
      return prefillingFieldValueMap[fieldId];
    };
    record.updateCell = (fieldId: string, newValue: unknown) => {
      record.fields[fieldId] = newValue;
      setPrefillingFieldValueMap({
        ...prefillingFieldValueMap,
        [fieldId]: newValue,
      });
      return Promise.resolve();
    };

    return record;
  }, [prefillingFieldValueMap]);

  const getPrefillingCellContent = useCallback<(cell: ICellItem) => ICell>(
    (cell) => {
      const [columnIndex] = cell;
      const cellValue2GridDisplay = createCellValue2GridDisplay(fields, fieldEditable);
      if (localRecord != null) {
        const fieldId = columns[columnIndex]?.id;
        if (!fieldId) return { type: CellType.Loading };
        return cellValue2GridDisplay(localRecord, columnIndex);
      }
      return { type: CellType.Loading };
    },
    [columns, fieldEditable, fields, localRecord]
  );

  const onPrefillingCellEdited = useCallback(
    (cell: ICellItem, newVal: IInnerCell) => {
      if (localRecord == null) return;

      const [col] = cell;
      const fieldId = columns[col].id;
      const { type, data } = newVal;
      let newCellValue: unknown = null;

      switch (type) {
        case CellType.Select:
          newCellValue = data?.length ? data : null;
          break;
        case CellType.Text:
        case CellType.Number:
        case CellType.Boolean:
        default:
          newCellValue = data === '' ? null : data;
      }
      const oldCellValue = localRecord.getCellValue(fieldId) ?? null;
      if (isEqual(newCellValue, oldCellValue)) return;
      localRecord.updateCell(fieldId, newCellValue);
      return localRecord;
    },
    [localRecord, columns]
  );

  return useMemo(() => {
    return {
      localRecord,
      prefillingRowIndex,
      prefillingRowOrder,
      prefillingFieldValueMap,
      setPrefillingRowIndex,
      setPrefillingRowOrder,
      onPrefillingCellEdited,
      getPrefillingCellContent,
      setPrefillingFieldValueMap,
    };
  }, [
    localRecord,
    prefillingRowIndex,
    prefillingRowOrder,
    prefillingFieldValueMap,
    setPrefillingRowIndex,
    setPrefillingRowOrder,
    onPrefillingCellEdited,
    getPrefillingCellContent,
    setPrefillingFieldValueMap,
  ]);
};

1	import type { IUpdateOrderRo } from '@teable/openapi';	×
2	import { isEqual } from 'lodash';	×
3	import { useCallback, useMemo, useState } from 'react';	×
4	import { useFieldCellEditable, useFields } from '../../../hooks';	×
5	import { createRecordInstance } from '../../../model';	×
6	import { CellType } from '../../grid/interface';	×
7	import type { ICell, ICellItem, IGridColumn, IInnerCell } from '../../grid/interface';	×
8	import { createCellValue2GridDisplay } from './use-grid-columns';	×
9		×
10	export const useGridPrefillingRow = (columns: (IGridColumn & { id: string })[]) => {	×
11	const fields = useFields();	×
12	const fieldEditable = useFieldCellEditable();	×
13		×
14	const [prefillingRowOrder, setPrefillingRowOrder] = useState<IUpdateOrderRo>();	×
15	const [prefillingRowIndex, setPrefillingRowIndex] = useState<number>();	×
16	const [prefillingFieldValueMap, setPrefillingFieldValueMap] = useState<	×
17	{ [fieldId: string]: unknown } \| undefined	×
18	>();	×
19		×
20	const localRecord = useMemo(() => {	×
21	if (prefillingFieldValueMap == null) {	×
22	return null;	×
23	}	×
24		×
25	const record = createRecordInstance({	×
26	id: '',	×
27	fields: prefillingFieldValueMap,	×
28	});	×
29	record.getCellValue = (fieldId: string) => {	×
30	return prefillingFieldValueMap[fieldId];	×
31	};	×
32	record.updateCell = (fieldId: string, newValue: unknown) => {	×
33	record.fields[fieldId] = newValue;	×
34	setPrefillingFieldValueMap({	×
35	...prefillingFieldValueMap,	×
36	[fieldId]: newValue,	×
37	});	×
38	return Promise.resolve();	×
39	};	×
40		×
41	return record;	×
42	}, [prefillingFieldValueMap]);	×
43		×
44	const getPrefillingCellContent = useCallback<(cell: ICellItem) => ICell>(	×
45	(cell) => {	×
46	const [columnIndex] = cell;	×
47	const cellValue2GridDisplay = createCellValue2GridDisplay(fields, fieldEditable);	×
48	if (localRecord != null) {	×
49	const fieldId = columns[columnIndex]?.id;	×
50	if (!fieldId) return { type: CellType.Loading };	×
51	return cellValue2GridDisplay(localRecord, columnIndex);	×
52	}	×
53	return { type: CellType.Loading };	×
54	},	×
55	[columns, fieldEditable, fields, localRecord]	×
56	);	×
57		×
58	const onPrefillingCellEdited = useCallback(	×
59	(cell: ICellItem, newVal: IInnerCell) => {	×
60	if (localRecord == null) return;	×
61		×
62	const [col] = cell;	×
63	const fieldId = columns[col].id;	×
64	const { type, data } = newVal;	×
65	let newCellValue: unknown = null;	×
66		×
67	switch (type) {	×
68	case CellType.Select:	×
69	newCellValue = data?.length ? data : null;	×
70	break;	×
71	case CellType.Text:	×
72	case CellType.Number:	×
73	case CellType.Boolean:	×
74	default:	×
75	newCellValue = data === '' ? null : data;	×
76	}	×
77	const oldCellValue = localRecord.getCellValue(fieldId) ?? null;	×
78	if (isEqual(newCellValue, oldCellValue)) return;	×
79	localRecord.updateCell(fieldId, newCellValue);	×
80	return localRecord;	×
81	},	×
82	[localRecord, columns]	×
83	);	×
84		×
85	return useMemo(() => {	×
86	return {	×
NEW 87	localRecord,	×
88	prefillingRowIndex,	×
89	prefillingRowOrder,	×
90	prefillingFieldValueMap,	×
91	setPrefillingRowIndex,	×
92	setPrefillingRowOrder,	×
93	onPrefillingCellEdited,	×
94	getPrefillingCellContent,	×
95	setPrefillingFieldValueMap,	×
96	};	×
97	}, [	×
NEW 98	localRecord,	×
99	prefillingRowIndex,	×
100	prefillingRowOrder,	×
101	prefillingFieldValueMap,	×
102	setPrefillingRowIndex,	×
103	setPrefillingRowOrder,	×
104	onPrefillingCellEdited,	×
105	getPrefillingCellContent,	×
106	setPrefillingFieldValueMap,	×
107	]);	×
108	};	×

teableio / teable / 10057009462

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