8421654220

Committed 25 Mar 2024 02:22PM CUT coverage: 79.934% (+53.8%) from 26.087%

Build # 8421654220

Build Type

Pull #495

github

Committed by

web-flow

Commit Message

Merge 4faeebea5 into 1869c986d

Pull Request Pull Request #495: chore: add licenses for non-NPM packages

Run Details

3256 of 3853 branches covered (84.51%)

25152 of 31466 relevant lines covered (79.93%)

1188.29 hits per line

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

90.57

/apps/nestjs-backend/src/utils/update-order.ts

/**
 * if we have [1,2,3,4,5]
 * --------------------------------
 * case 1:
 * anchorId = 3, position = 'before', order = 2
 * pick the order < 3, we have [1, 2]
 * orderBy desc, we have [2, 1]
 * pick the first one, we have 2
 * --------------------------------
 * case 2:
 * anchorId = 3, position = 'after', order = 2
 * pick the order > 3, we have [4, 5]
 * orderBy asc, we have [4, 5]
 * pick the first one, we have 4
 */
export async function updateOrder(params: {
  parentId: string;
  position: 'before' | 'after';
  item: { id: string; order: number };
  anchorItem: { id: string; order: number };
  getNextItem: (
    whereOrder: { lt?: number; gt?: number },
    align: 'desc' | 'asc'
  ) => Promise<{ id: string; order: number } | null>;
  update: (
    parentId: string,
    id: string,
    data: { newOrder: number; oldOrder: number }
  ) => Promise<void>;
  shuffle: (parentId: string) => Promise<void>;
}) {
  const { parentId, position, item, anchorItem, getNextItem, update, shuffle } = params;
  const nextView = await getNextItem(
    { [position === 'before' ? 'lt' : 'gt']: anchorItem.order },
    position === 'before' ? 'desc' : 'asc'
  );

  const order = nextView
    ? (nextView.order + anchorItem.order) / 2
    : anchorItem.order + (position === 'before' ? -1 : 1);

  const { id, order: oldOrder } = item;

  if (Math.abs(order - anchorItem.order) < Number.EPSILON * 2) {
    await shuffle(parentId);
    // recursive call
    await updateOrder(params);
    return;
  }
  await update(parentId, id, { newOrder: order, oldOrder });
}

/**
 * if we have [1,2,3,4,5]
 * --------------------------------
 * case 1:
 * anchor = 3, position = 'before', item.length = 2
 * pick the order < 3, we have [1, 2]
 * orderBy desc, we have [2, 1]
 * pick the first one, we have 2 for the next order
 * gap = ABS((anchor - next) / (item.length + 1)) = (3 - 2) / (2 + 1) = 0.333
 * new item orders = next + gap * item.index = [2.333, 2.667]
 * --------------------------------
 * case 2:
 * anchor = 3, position = 'after', item.length = 2
 * pick the order > 3, we have [4, 5]
 * orderBy asc, we have [4, 5]
 * pick the first one, we have 4 for the next order
 * gap = ABS((anchor - next) / (item.length + 1)) = ABS((3 - 4) / (2 + 1)) = 0.333
 * new item orders = anchor + gap * item.index = [3.333, 3.667]
 */
export async function updateMultipleOrders(params: {
  parentId: string;
  position: 'before' | 'after';
  itemLength: number;
  anchorItem: { id: string; order: number };
  getNextItem: (
    whereOrder: { lt?: number; gt?: number },
    align: 'desc' | 'asc'
  ) => Promise<{ id: string; order: number } | null>;
  update: (indexes: number[]) => Promise<void>;
  shuffle: (parentId: string) => Promise<void>;
}) {
  const { parentId, position, itemLength, anchorItem, getNextItem, update, shuffle } = params;
  const nextView = await getNextItem(
    { [position === 'before' ? 'lt' : 'gt']: anchorItem.order },
    position === 'before' ? 'desc' : 'asc'
  );

  const nextOrder = nextView ? nextView.order : anchorItem.order + (position === 'before' ? -1 : 1);
  const gap = Math.abs((anchorItem.order - nextOrder) / (itemLength + 1));

  if (gap < Number.EPSILON * 2) {
    await shuffle(parentId);
    // recursive call
    await updateMultipleOrders(params);
    return;
  }

  const orderBase = position === 'before' ? nextOrder : anchorItem.order;
  const newItems = Array.from({ length: itemLength }).map(
    (_, index) => orderBase + gap * (index + 1)
  );

  await update(newItems);
}

1	/**	2✔
2	* if we have [1,2,3,4,5]	2✔
3	* --------------------------------	2✔
4	* case 1:	2✔
5	* anchorId = 3, position = 'before', order = 2	2✔
6	* pick the order < 3, we have [1, 2]	2✔
7	* orderBy desc, we have [2, 1]	2✔
8	* pick the first one, we have 2	2✔
9	* --------------------------------	2✔
10	* case 2:	2✔
11	* anchorId = 3, position = 'after', order = 2	2✔
12	* pick the order > 3, we have [4, 5]	2✔
13	* orderBy asc, we have [4, 5]	2✔
14	* pick the first one, we have 4	2✔
15	*/	2✔
16	export async function updateOrder(params: {	2✔
17	parentId: string;	24✔
18	position: 'before' \| 'after';	24✔
19	item: { id: string; order: number };	24✔
20	anchorItem: { id: string; order: number };	24✔
21	getNextItem: (	24✔
22	whereOrder: { lt?: number; gt?: number },	24✔
23	align: 'desc' \| 'asc'	24✔
24	) => Promise<{ id: string; order: number } \| null>;	24✔
25	update: (	24✔
26	parentId: string,	24✔
27	id: string,	24✔
28	data: { newOrder: number; oldOrder: number }	24✔
29	) => Promise<void>;	24✔
30	shuffle: (parentId: string) => Promise<void>;	24✔
31	}) {	24✔
32	const { parentId, position, item, anchorItem, getNextItem, update, shuffle } = params;	24✔
33	const nextView = await getNextItem(	24✔
34	{ [position === 'before' ? 'lt' : 'gt']: anchorItem.order },	24✔
35	position === 'before' ? 'desc' : 'asc'	24✔
36	);	24✔
37		24✔
38	const order = nextView	24✔
39	? (nextView.order + anchorItem.order) / 2	12✔
40	: anchorItem.order + (position === 'before' ? -1 : 1);	12✔
41		24✔
42	const { id, order: oldOrder } = item;	24✔
43		24✔
44	if (Math.abs(order - anchorItem.order) < Number.EPSILON * 2) {	24!
45	await shuffle(parentId);	×
46	// recursive call	×
47	await updateOrder(params);	×
48	return;	×
49	}	×
50	await update(parentId, id, { newOrder: order, oldOrder });	24✔
51	}	24✔
52		2✔
53	/**	2✔
54	* if we have [1,2,3,4,5]	2✔
55	* --------------------------------	2✔
56	* case 1:	2✔
57	* anchor = 3, position = 'before', item.length = 2	2✔
58	* pick the order < 3, we have [1, 2]	2✔
59	* orderBy desc, we have [2, 1]	2✔
60	* pick the first one, we have 2 for the next order	2✔
61	* gap = ABS((anchor - next) / (item.length + 1)) = (3 - 2) / (2 + 1) = 0.333	2✔
62	* new item orders = next + gap * item.index = [2.333, 2.667]	2✔
63	* --------------------------------	2✔
64	* case 2:	2✔
65	* anchor = 3, position = 'after', item.length = 2	2✔
66	* pick the order > 3, we have [4, 5]	2✔
67	* orderBy asc, we have [4, 5]	2✔
68	* pick the first one, we have 4 for the next order	2✔
69	* gap = ABS((anchor - next) / (item.length + 1)) = ABS((3 - 4) / (2 + 1)) = 0.333	2✔
70	* new item orders = anchor + gap * item.index = [3.333, 3.667]	2✔
71	*/	2✔
72	export async function updateMultipleOrders(params: {	2✔
73	parentId: string;	14✔
74	position: 'before' \| 'after';	14✔
75	itemLength: number;	14✔
76	anchorItem: { id: string; order: number };	14✔
77	getNextItem: (	14✔
78	whereOrder: { lt?: number; gt?: number },	14✔
79	align: 'desc' \| 'asc'	14✔
80	) => Promise<{ id: string; order: number } \| null>;	14✔
81	update: (indexes: number[]) => Promise<void>;	14✔
82	shuffle: (parentId: string) => Promise<void>;	14✔
83	}) {	14✔
84	const { parentId, position, itemLength, anchorItem, getNextItem, update, shuffle } = params;	14✔
85	const nextView = await getNextItem(	14✔
86	{ [position === 'before' ? 'lt' : 'gt']: anchorItem.order },	14✔
87	position === 'before' ? 'desc' : 'asc'	14✔
88	);	14✔
89		14✔
90	const nextOrder = nextView ? nextView.order : anchorItem.order + (position === 'before' ? -1 : 1);	14✔
91	const gap = Math.abs((anchorItem.order - nextOrder) / (itemLength + 1));	14✔
92		14✔
93	if (gap < Number.EPSILON * 2) {	14!
94	await shuffle(parentId);	×
95	// recursive call	×
96	await updateMultipleOrders(params);	×
97	return;	×
98	}	×
99		14✔
100	const orderBase = position === 'before' ? nextOrder : anchorItem.order;	14✔
101	const newItems = Array.from({ length: itemLength }).map(	14✔
102	(_, index) => orderBase + gap * (index + 1)	14✔
103	);	14✔
104		14✔
105	await update(newItems);	14✔
106	}	14✔

teableio / teable / 8421654220

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