@himanshu-sorathiya/react-kit 1.0.19 → 1.0.21
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/events2.js +1 -1
- package/dist/index.d.ts +71 -17
- package/dist/index.js +4 -4
- package/dist/performance.d.ts +58 -4
- package/dist/performance.js +2 -2
- package/dist/performance2.js +155 -34
- package/dist/state.d.ts +8 -8
- package/dist/state2.js +193 -191
- package/dist/ui.d.ts +5 -5
- package/dist/ui2.js +177 -177
- package/package.json +1 -1
package/dist/state2.js
CHANGED
|
@@ -58,13 +58,13 @@ var a = {
|
|
|
58
58
|
};
|
|
59
59
|
//#endregion
|
|
60
60
|
//#region src/state/useFilter/useFilter.ts
|
|
61
|
-
function o(o, s = []) {
|
|
62
|
-
let c =
|
|
63
|
-
let t =
|
|
61
|
+
function o(o = [], s = []) {
|
|
62
|
+
let c = n(() => Array.isArray(o) ? o : [], [o]), l = n(() => Array.isArray(s) ? s : [], [s]), u = r(l), [d, f] = i(() => l), p = n(() => {
|
|
63
|
+
let t = d.filter((e) => e.isActive !== !1).map((e) => ({
|
|
64
64
|
...e,
|
|
65
65
|
pathArray: (e.field || e.id).split(".")
|
|
66
66
|
}));
|
|
67
|
-
return
|
|
67
|
+
return c.filter((n) => t.every((t) => {
|
|
68
68
|
let { id: r, type: i, operator: o, value: s, compare: c, pathArray: l } = t, u = e(n, l, r);
|
|
69
69
|
if (i === "custom") return !c || c(u, s, n);
|
|
70
70
|
let d = a[i];
|
|
@@ -72,26 +72,26 @@ function o(o, s = []) {
|
|
|
72
72
|
let f = d[o];
|
|
73
73
|
return !f || f(u, s, t);
|
|
74
74
|
}));
|
|
75
|
-
}, [
|
|
76
|
-
|
|
77
|
-
}, []),
|
|
78
|
-
|
|
79
|
-
}, []),
|
|
80
|
-
|
|
81
|
-
}, []),
|
|
82
|
-
u
|
|
83
|
-
}, []),
|
|
84
|
-
|
|
75
|
+
}, [c, d]), m = t((e) => {
|
|
76
|
+
f((t) => t.some((t) => t.id === e.id) ? t.map((t) => t.id === e.id ? e : t) : [...t, e]);
|
|
77
|
+
}, []), h = t((e) => {
|
|
78
|
+
f((t) => Array.isArray(e) ? t.filter((t) => !e.includes(t.id)) : t.filter((t) => t.id !== e));
|
|
79
|
+
}, []), g = t(() => {
|
|
80
|
+
f([]);
|
|
81
|
+
}, []), _ = t(() => {
|
|
82
|
+
f(u.current);
|
|
83
|
+
}, []), v = t((e) => {
|
|
84
|
+
f(Array.isArray(e) ? e : []);
|
|
85
85
|
}, []);
|
|
86
86
|
return {
|
|
87
|
-
filteredItems:
|
|
88
|
-
filters:
|
|
89
|
-
upsertFilter:
|
|
90
|
-
removeFilter:
|
|
91
|
-
clearFilters:
|
|
92
|
-
resetFilters:
|
|
87
|
+
filteredItems: p,
|
|
88
|
+
filters: d,
|
|
89
|
+
upsertFilter: m,
|
|
90
|
+
removeFilter: h,
|
|
91
|
+
clearFilters: g,
|
|
92
|
+
resetFilters: _,
|
|
93
93
|
toggleFilter: t((e) => {
|
|
94
|
-
|
|
94
|
+
f((t) => t.some((t) => t.id === e.id) ? t.map((t) => t.id === e.id ? {
|
|
95
95
|
...t,
|
|
96
96
|
isActive: t.isActive === !1
|
|
97
97
|
} : t) : [...t, {
|
|
@@ -100,23 +100,23 @@ function o(o, s = []) {
|
|
|
100
100
|
}]);
|
|
101
101
|
}, []),
|
|
102
102
|
updateFilterConfig: t((e, t) => {
|
|
103
|
-
|
|
103
|
+
f((n) => n.map((n) => n.id === e ? {
|
|
104
104
|
...n,
|
|
105
105
|
...t
|
|
106
106
|
} : n));
|
|
107
107
|
}, []),
|
|
108
|
-
replaceFilters:
|
|
109
|
-
getFilterValue: t((e) =>
|
|
108
|
+
replaceFilters: v,
|
|
109
|
+
getFilterValue: t((e) => d.find((t) => t.id === e)?.value, [d]),
|
|
110
110
|
updateFilterValue: t((e, t) => {
|
|
111
|
-
|
|
111
|
+
f((n) => n.map((n) => n.id === e ? {
|
|
112
112
|
...n,
|
|
113
113
|
value: t
|
|
114
114
|
} : n));
|
|
115
115
|
}, []),
|
|
116
116
|
isFilterActive: t((e) => {
|
|
117
|
-
let t =
|
|
117
|
+
let t = d.find((t) => t.id === e);
|
|
118
118
|
return t ? t.isActive !== !1 : !1;
|
|
119
|
-
}, [
|
|
119
|
+
}, [d])
|
|
120
120
|
};
|
|
121
121
|
}
|
|
122
122
|
//#endregion
|
|
@@ -252,223 +252,223 @@ function c(t, r, i, a = {}) {
|
|
|
252
252
|
}
|
|
253
253
|
//#endregion
|
|
254
254
|
//#region src/state/useGrouping/useGrouping.ts
|
|
255
|
-
function l(
|
|
256
|
-
let [
|
|
257
|
-
let r = e(n,
|
|
255
|
+
function l(r = {}) {
|
|
256
|
+
let a = r || {}, o = n(() => Array.isArray(a.items) ? a.items : [], [a.items]), s = a.initialGroupBy, [c, l] = i(s), u = n(() => c ? o.reduce((t, n) => {
|
|
257
|
+
let r = e(n, c), i = r == null ? "Unknown" : String(r);
|
|
258
258
|
return t[i] || (t[i] = []), t[i].push(n), t;
|
|
259
|
-
}, {}) : { Ungrouped:
|
|
259
|
+
}, {}) : { Ungrouped: o }, [o, c]), d = n(() => Object.keys(u).map((e) => ({
|
|
260
260
|
key: e,
|
|
261
|
-
items:
|
|
262
|
-
})), [
|
|
263
|
-
|
|
264
|
-
}, []),
|
|
265
|
-
|
|
266
|
-
}, []),
|
|
267
|
-
s
|
|
268
|
-
}, [
|
|
261
|
+
items: u[e]
|
|
262
|
+
})), [u]), f = n(() => Object.keys(u), [u]), p = t((e) => {
|
|
263
|
+
l(e);
|
|
264
|
+
}, []), m = t(() => {
|
|
265
|
+
l(void 0);
|
|
266
|
+
}, []), h = t(() => {
|
|
267
|
+
l(s);
|
|
268
|
+
}, [s]), g = t((e) => u[e] || [], [u]);
|
|
269
269
|
return {
|
|
270
|
-
groupedRecord:
|
|
271
|
-
groupedArray:
|
|
272
|
-
groupKeys:
|
|
273
|
-
totalGroups:
|
|
274
|
-
activeGroupBy:
|
|
275
|
-
changeGroupBy:
|
|
276
|
-
clearGrouping:
|
|
277
|
-
resetGrouping:
|
|
278
|
-
getGroupItems:
|
|
270
|
+
groupedRecord: u,
|
|
271
|
+
groupedArray: d,
|
|
272
|
+
groupKeys: f,
|
|
273
|
+
totalGroups: f.length,
|
|
274
|
+
activeGroupBy: c,
|
|
275
|
+
changeGroupBy: p,
|
|
276
|
+
clearGrouping: m,
|
|
277
|
+
resetGrouping: h,
|
|
278
|
+
getGroupItems: g
|
|
279
279
|
};
|
|
280
280
|
}
|
|
281
281
|
//#endregion
|
|
282
282
|
//#region src/state/useMultipleSelection/useMultipleSelection.ts
|
|
283
|
-
function u(
|
|
284
|
-
let c = r(
|
|
285
|
-
|
|
286
|
-
let r = new Set(n), i = e(t,
|
|
283
|
+
function u(a = {}) {
|
|
284
|
+
let o = a || {}, s = n(() => Array.isArray(o.items) ? o.items : [], [o.items]), c = Array.isArray(o.initialSelectedIds) ? o.initialSelectedIds : [], l = o.field, u = r(c), [d, f] = i(() => new Set(c)), p = t((t) => {
|
|
285
|
+
f((n) => {
|
|
286
|
+
let r = new Set(n), i = e(t, l);
|
|
287
287
|
return r.add(i), r;
|
|
288
288
|
});
|
|
289
|
-
}, [
|
|
290
|
-
|
|
291
|
-
let r = new Set(n), i = e(t,
|
|
289
|
+
}, [l]), m = t((t) => {
|
|
290
|
+
f((n) => {
|
|
291
|
+
let r = new Set(n), i = e(t, l);
|
|
292
292
|
return r.delete(i), r;
|
|
293
293
|
});
|
|
294
|
-
}, [
|
|
295
|
-
|
|
296
|
-
let r = new Set(n), i = e(t,
|
|
294
|
+
}, [l]), h = t((t) => {
|
|
295
|
+
f((n) => {
|
|
296
|
+
let r = new Set(n), i = e(t, l);
|
|
297
297
|
return r.has(i) ? r.delete(i) : r.add(i), r;
|
|
298
298
|
});
|
|
299
|
-
}, [
|
|
300
|
-
let n = e(t,
|
|
301
|
-
return
|
|
302
|
-
}, [
|
|
303
|
-
let n = t.map((t) => e(t,
|
|
304
|
-
|
|
305
|
-
}, [
|
|
306
|
-
let t =
|
|
307
|
-
|
|
308
|
-
}, [
|
|
309
|
-
|
|
310
|
-
}, []),
|
|
311
|
-
if (t.size ===
|
|
312
|
-
let n =
|
|
299
|
+
}, [l]), g = t((t) => {
|
|
300
|
+
let n = e(t, l);
|
|
301
|
+
return d.has(n);
|
|
302
|
+
}, [d, l]), _ = t(() => f(new Set(u.current)), []), v = t((t) => {
|
|
303
|
+
let n = (Array.isArray(t) ? t : []).map((t) => e(t, l));
|
|
304
|
+
f(new Set(n));
|
|
305
|
+
}, [l]), y = t(() => {
|
|
306
|
+
let t = s.map((t) => e(t, l));
|
|
307
|
+
f(new Set(t));
|
|
308
|
+
}, [s, l]), b = t(() => {
|
|
309
|
+
f(/* @__PURE__ */ new Set());
|
|
310
|
+
}, []), x = t(() => f((t) => {
|
|
311
|
+
if (t.size === s.length) return /* @__PURE__ */ new Set();
|
|
312
|
+
let n = s.map((t) => e(t, l));
|
|
313
313
|
return new Set(n);
|
|
314
|
-
}), [
|
|
315
|
-
if (t.size ===
|
|
316
|
-
let n =
|
|
314
|
+
}), [s, l]), S = t(() => f((t) => {
|
|
315
|
+
if (t.size === s.length) return /* @__PURE__ */ new Set();
|
|
316
|
+
let n = s.filter((n) => !t.has(e(n, l))).map((t) => e(t, l));
|
|
317
317
|
return new Set(n);
|
|
318
|
-
}), [
|
|
319
|
-
|
|
318
|
+
}), [s, l]), C = t((t) => {
|
|
319
|
+
f((n) => {
|
|
320
320
|
let r = new Set(n);
|
|
321
|
-
return t.map((t) => e(t,
|
|
321
|
+
return (Array.isArray(t) ? t : []).map((t) => e(t, l)).forEach((e) => r.add(e)), r;
|
|
322
322
|
});
|
|
323
|
-
}, [
|
|
324
|
-
|
|
323
|
+
}, [l]), w = t((t) => {
|
|
324
|
+
f((n) => {
|
|
325
325
|
let r = new Set(n);
|
|
326
|
-
return t.map((t) => e(t,
|
|
326
|
+
return (Array.isArray(t) ? t : []).map((t) => e(t, l)).forEach((e) => r.delete(e)), r;
|
|
327
327
|
});
|
|
328
|
-
}, [
|
|
329
|
-
|
|
328
|
+
}, [l]), T = t((t) => {
|
|
329
|
+
f((n) => {
|
|
330
330
|
let r = /* @__PURE__ */ new Set();
|
|
331
|
-
return t.map((t) => e(t,
|
|
331
|
+
return (Array.isArray(t) ? t : []).map((t) => e(t, l)).forEach((e) => n.has(e) && r.add(e)), r;
|
|
332
332
|
});
|
|
333
|
-
}, [
|
|
334
|
-
let n = e(t,
|
|
335
|
-
return
|
|
333
|
+
}, [l]), E = n(() => s.filter((t) => {
|
|
334
|
+
let n = e(t, l);
|
|
335
|
+
return d.has(n);
|
|
336
336
|
}), [
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
337
|
+
s,
|
|
338
|
+
l,
|
|
339
|
+
d
|
|
340
340
|
]);
|
|
341
341
|
return {
|
|
342
|
-
selectedIds: [...
|
|
343
|
-
selectedCount:
|
|
344
|
-
selectedItems:
|
|
345
|
-
isEmpty:
|
|
346
|
-
select:
|
|
347
|
-
deselect:
|
|
348
|
-
toggle:
|
|
349
|
-
isSelected:
|
|
350
|
-
replaceSelection:
|
|
351
|
-
resetSelection:
|
|
352
|
-
selectAll:
|
|
353
|
-
deselectAll:
|
|
354
|
-
toggleAll:
|
|
355
|
-
invertSelection:
|
|
356
|
-
selectMultiple:
|
|
357
|
-
deselectMultiple:
|
|
358
|
-
retainOnly:
|
|
342
|
+
selectedIds: [...d],
|
|
343
|
+
selectedCount: d.size,
|
|
344
|
+
selectedItems: E,
|
|
345
|
+
isEmpty: d.size === 0,
|
|
346
|
+
select: p,
|
|
347
|
+
deselect: m,
|
|
348
|
+
toggle: h,
|
|
349
|
+
isSelected: g,
|
|
350
|
+
replaceSelection: v,
|
|
351
|
+
resetSelection: _,
|
|
352
|
+
selectAll: y,
|
|
353
|
+
deselectAll: b,
|
|
354
|
+
toggleAll: x,
|
|
355
|
+
invertSelection: S,
|
|
356
|
+
selectMultiple: C,
|
|
357
|
+
deselectMultiple: w,
|
|
358
|
+
retainOnly: T
|
|
359
359
|
};
|
|
360
360
|
}
|
|
361
361
|
//#endregion
|
|
362
362
|
//#region src/state/useOrder/useOrder.ts
|
|
363
|
-
function d(e) {
|
|
364
|
-
let
|
|
365
|
-
typeof e == "number" &&
|
|
363
|
+
function d(e = []) {
|
|
364
|
+
let a = n(() => Array.isArray(e) ? e : [], [e]), o = r(a), [s, c] = i(() => a), l = t((e) => {
|
|
365
|
+
typeof e == "number" && c((t) => {
|
|
366
366
|
if (e <= 0 || e >= t.length) return t;
|
|
367
367
|
let n = [...t];
|
|
368
368
|
return [n[e], n[e - 1]] = [n[e - 1], n[e]], n;
|
|
369
369
|
});
|
|
370
|
-
}, []),
|
|
371
|
-
typeof e == "number" &&
|
|
370
|
+
}, []), u = t((e) => {
|
|
371
|
+
typeof e == "number" && c((t) => {
|
|
372
372
|
if (e < 0 || e >= t.length - 1) return t;
|
|
373
373
|
let n = [...t];
|
|
374
374
|
return [n[e], n[e + 1]] = [n[e + 1], n[e]], n;
|
|
375
375
|
});
|
|
376
|
-
}, []),
|
|
377
|
-
typeof e == "number" &&
|
|
376
|
+
}, []), d = t((e) => e > 0, []), f = t((e) => e < s.length - 1, [s.length]), p = t((e) => {
|
|
377
|
+
typeof e == "number" && c((t) => {
|
|
378
378
|
if (e <= 0 || e >= t.length) return t;
|
|
379
379
|
let n = [...t], [r] = n.splice(e, 1);
|
|
380
380
|
return n.unshift(r), n;
|
|
381
381
|
});
|
|
382
|
-
}, []),
|
|
383
|
-
typeof e == "number" &&
|
|
382
|
+
}, []), m = t((e) => {
|
|
383
|
+
typeof e == "number" && c((t) => {
|
|
384
384
|
if (e < 0 || e >= t.length - 1) return t;
|
|
385
385
|
let n = [...t], [r] = n.splice(e, 1);
|
|
386
386
|
return n.push(r), n;
|
|
387
387
|
});
|
|
388
|
-
}, []),
|
|
389
|
-
typeof e != "number" || typeof t != "number" || e === t ||
|
|
388
|
+
}, []), h = t((e, t) => {
|
|
389
|
+
typeof e != "number" || typeof t != "number" || e === t || c((n) => {
|
|
390
390
|
if (e < 0 || e >= n.length || t < 0 || t >= n.length) return n;
|
|
391
391
|
let r = [...n], [i] = r.splice(e, 1);
|
|
392
392
|
return r.splice(t, 0, i), r;
|
|
393
393
|
});
|
|
394
|
-
}, []),
|
|
395
|
-
typeof e != "number" || typeof t != "number" || e === t ||
|
|
394
|
+
}, []), g = t((e, t) => {
|
|
395
|
+
typeof e != "number" || typeof t != "number" || e === t || c((n) => {
|
|
396
396
|
if (e < 0 || e >= n.length || t < 0 || t >= n.length) return n;
|
|
397
397
|
let r = [...n];
|
|
398
398
|
return [r[e], r[t]] = [r[t], r[e]], r;
|
|
399
399
|
});
|
|
400
|
-
}, []),
|
|
401
|
-
o
|
|
400
|
+
}, []), _ = t(() => {
|
|
401
|
+
c(o.current);
|
|
402
402
|
}, []);
|
|
403
403
|
return {
|
|
404
|
-
orderedItems:
|
|
405
|
-
moveUp:
|
|
406
|
-
moveDown:
|
|
407
|
-
canMoveUp:
|
|
408
|
-
canMoveDown:
|
|
409
|
-
moveToTop:
|
|
410
|
-
moveToBottom:
|
|
411
|
-
move:
|
|
412
|
-
swap:
|
|
404
|
+
orderedItems: s,
|
|
405
|
+
moveUp: l,
|
|
406
|
+
moveDown: u,
|
|
407
|
+
canMoveUp: d,
|
|
408
|
+
canMoveDown: f,
|
|
409
|
+
moveToTop: p,
|
|
410
|
+
moveToBottom: m,
|
|
411
|
+
move: h,
|
|
412
|
+
swap: g,
|
|
413
413
|
replaceOrder: t((e) => {
|
|
414
|
-
|
|
414
|
+
c(Array.isArray(e) ? e : []);
|
|
415
415
|
}, []),
|
|
416
|
-
resetOrder:
|
|
416
|
+
resetOrder: _
|
|
417
417
|
};
|
|
418
418
|
}
|
|
419
419
|
//#endregion
|
|
420
420
|
//#region src/state/usePagination/usePagination.ts
|
|
421
|
-
function f(e, r, a = 0) {
|
|
422
|
-
let [
|
|
423
|
-
return
|
|
424
|
-
pageItems: n(() => typeof
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
421
|
+
function f(e = [], r, a = 0) {
|
|
422
|
+
let o = n(() => Array.isArray(e) ? e : [], [e]), [s, c] = i(r), [l, u] = i(a), d = Math.max(1, Math.ceil(o.length / Math.max(1, s))), f = Math.min(Math.max(0, l), d - 1);
|
|
423
|
+
return l !== f && u(f), {
|
|
424
|
+
pageItems: n(() => typeof s != "number" || s < 1 ? [] : o.slice(l * s, (l + 1) * s), [
|
|
425
|
+
l,
|
|
426
|
+
s,
|
|
427
|
+
o
|
|
428
428
|
]),
|
|
429
|
-
pageSize:
|
|
430
|
-
pageIndex:
|
|
431
|
-
totalPages:
|
|
432
|
-
canPrevious:
|
|
433
|
-
canNext:
|
|
429
|
+
pageSize: s,
|
|
430
|
+
pageIndex: l,
|
|
431
|
+
totalPages: d,
|
|
432
|
+
canPrevious: l > 0,
|
|
433
|
+
canNext: l < d - 1,
|
|
434
434
|
nextPage: t(() => {
|
|
435
|
-
|
|
436
|
-
}, [
|
|
435
|
+
u((e) => e < d - 1 ? e + 1 : e);
|
|
436
|
+
}, [d]),
|
|
437
437
|
previousPage: t(() => {
|
|
438
|
-
|
|
438
|
+
u((e) => e > 0 ? e - 1 : e);
|
|
439
439
|
}, []),
|
|
440
440
|
goToFirstPage: t(() => {
|
|
441
|
-
|
|
441
|
+
u(0);
|
|
442
442
|
}, []),
|
|
443
443
|
goToLastPage: t(() => {
|
|
444
|
-
|
|
445
|
-
}, [
|
|
444
|
+
u(d - 1);
|
|
445
|
+
}, [d]),
|
|
446
446
|
goToPage: t((e) => {
|
|
447
|
-
typeof e == "number" && e >= 0 && e <=
|
|
448
|
-
}, [
|
|
449
|
-
changePageSize: t((
|
|
450
|
-
if (typeof
|
|
451
|
-
|
|
452
|
-
let
|
|
453
|
-
|
|
447
|
+
typeof e == "number" && e >= 0 && e <= d - 1 && u(e);
|
|
448
|
+
}, [d]),
|
|
449
|
+
changePageSize: t((e) => {
|
|
450
|
+
if (typeof e == "number" && e > 0) {
|
|
451
|
+
c(e);
|
|
452
|
+
let t = Math.max(1, Math.ceil(o.length / Math.max(1, e)));
|
|
453
|
+
u((e) => Math.min(Math.max(0, e), t - 1));
|
|
454
454
|
}
|
|
455
|
-
}, [
|
|
455
|
+
}, [o.length]),
|
|
456
456
|
resetPageIndex: t(() => {
|
|
457
|
-
|
|
458
|
-
}, [a,
|
|
457
|
+
u(Math.min(Math.max(0, a), d - 1));
|
|
458
|
+
}, [a, d]),
|
|
459
459
|
resetPageSize: t(() => {
|
|
460
|
-
|
|
461
|
-
let
|
|
462
|
-
|
|
463
|
-
}, [r,
|
|
460
|
+
c(Math.max(1, r));
|
|
461
|
+
let e = Math.max(1, Math.ceil(o.length / Math.max(1, r)));
|
|
462
|
+
u((t) => Math.min(Math.max(0, t), e - 1));
|
|
463
|
+
}, [r, o.length]),
|
|
464
464
|
resetPagination: t(() => {
|
|
465
|
-
|
|
466
|
-
let
|
|
467
|
-
|
|
465
|
+
c(Math.max(1, r));
|
|
466
|
+
let e = Math.max(1, Math.ceil(o.length / Math.max(1, r)));
|
|
467
|
+
u(Math.min(Math.max(0, a), e - 1));
|
|
468
468
|
}, [
|
|
469
469
|
r,
|
|
470
470
|
a,
|
|
471
|
-
|
|
471
|
+
o.length
|
|
472
472
|
])
|
|
473
473
|
};
|
|
474
474
|
}
|
|
@@ -547,13 +547,13 @@ function x(e, t, n = "last", r) {
|
|
|
547
547
|
}
|
|
548
548
|
//#endregion
|
|
549
549
|
//#region src/state/useSort/useSort.ts
|
|
550
|
-
function S(a, o = []) {
|
|
551
|
-
let s =
|
|
552
|
-
let t =
|
|
550
|
+
function S(a = [], o = []) {
|
|
551
|
+
let s = n(() => Array.isArray(a) ? a : [], [a]), c = n(() => Array.isArray(o) ? o : [], [o]), l = r(c), [u, d] = i(() => c), f = n(() => {
|
|
552
|
+
let t = u.map((e) => ({
|
|
553
553
|
...e,
|
|
554
554
|
pathArray: (e.field || e.id).split(".")
|
|
555
555
|
}));
|
|
556
|
-
return [...
|
|
556
|
+
return [...s].sort((n, r) => {
|
|
557
557
|
for (let i of t) {
|
|
558
558
|
let { type: t, id: a, desc: o = !1, invertSorting: s = !1, pathArray: c } = i, l = e(n, c, a), u = e(r, c, a), d;
|
|
559
559
|
switch (t) {
|
|
@@ -584,11 +584,13 @@ function S(a, o = []) {
|
|
|
584
584
|
}
|
|
585
585
|
return 0;
|
|
586
586
|
});
|
|
587
|
-
}, [
|
|
588
|
-
|
|
589
|
-
}, []),
|
|
587
|
+
}, [u, s]), p = t((e) => d((t) => t.some((t) => t.id === e.id) ? t.map((t) => t.id === e.id ? e : t) : [...t, e]), []), x = t((e) => {
|
|
588
|
+
d((t) => Array.isArray(e) ? t.filter((t) => !e.includes(t.id)) : t.filter((t) => t.id !== e));
|
|
589
|
+
}, []), S = t(() => d([]), []), C = t(() => d(l.current), []), w = t((e) => {
|
|
590
|
+
d(Array.isArray(e) ? e : []);
|
|
591
|
+
}, []), T = t((e, t, n) => {
|
|
590
592
|
let { multi: r = !1, ...i } = n || {};
|
|
591
|
-
|
|
593
|
+
d((n) => {
|
|
592
594
|
let a = n.find((t) => t.id === e);
|
|
593
595
|
if (!a) {
|
|
594
596
|
let a = {
|
|
@@ -619,26 +621,26 @@ function S(a, o = []) {
|
|
|
619
621
|
});
|
|
620
622
|
}, []);
|
|
621
623
|
return {
|
|
622
|
-
sortedItems:
|
|
623
|
-
sorts:
|
|
624
|
-
upsertSorts:
|
|
625
|
-
removeSort:
|
|
626
|
-
clearSorts:
|
|
627
|
-
resetSorts:
|
|
628
|
-
replaceSorts:
|
|
624
|
+
sortedItems: f,
|
|
625
|
+
sorts: u,
|
|
626
|
+
upsertSorts: p,
|
|
627
|
+
removeSort: x,
|
|
628
|
+
clearSorts: S,
|
|
629
|
+
resetSorts: C,
|
|
630
|
+
replaceSorts: w,
|
|
629
631
|
getSortDirection: t((e) => {
|
|
630
|
-
let t =
|
|
632
|
+
let t = u.find((t) => t.id === e);
|
|
631
633
|
return t ? t.desc ? "desc" : "asc" : void 0;
|
|
632
|
-
}, [
|
|
633
|
-
toggleSort:
|
|
634
|
+
}, [u]),
|
|
635
|
+
toggleSort: T,
|
|
634
636
|
getNextSortingOrder: t((e) => {
|
|
635
|
-
let t =
|
|
637
|
+
let t = u.find((t) => t.id === e);
|
|
636
638
|
return t ? t.desc ? t.disableSortRemoval ? "asc" : "none" : "desc" : "asc";
|
|
637
|
-
}, [
|
|
639
|
+
}, [u]),
|
|
638
640
|
getSortIndex: t((e) => {
|
|
639
|
-
let t =
|
|
641
|
+
let t = u.findIndex((t) => t.id === e);
|
|
640
642
|
return t === -1 ? void 0 : t + 1;
|
|
641
|
-
}, [
|
|
643
|
+
}, [u])
|
|
642
644
|
};
|
|
643
645
|
}
|
|
644
646
|
//#endregion
|
package/dist/ui.d.ts
CHANGED
|
@@ -32,7 +32,7 @@ export interface UseExpansionReturn<T> {
|
|
|
32
32
|
resetExpansion: () => void;
|
|
33
33
|
replaceExpansion: (newExpandedItems: ExpansionId[] | T[]) => void;
|
|
34
34
|
}
|
|
35
|
-
export declare function useExpansion<T = unknown>(
|
|
35
|
+
export declare function useExpansion<T = unknown>(options?: {
|
|
36
36
|
items?: T[];
|
|
37
37
|
field?: string;
|
|
38
38
|
initialExpandedIds?: ExpansionId[];
|
|
@@ -70,8 +70,8 @@ export interface UsePinReturn<T> {
|
|
|
70
70
|
pinMultiple: (newItems: PinId[] | T[]) => void;
|
|
71
71
|
unpinMultiple: (itemsToRemove: PinId[] | T[]) => void;
|
|
72
72
|
}
|
|
73
|
-
export declare function usePin<T = unknown>(
|
|
74
|
-
items
|
|
73
|
+
export declare function usePin<T = unknown>(options?: {
|
|
74
|
+
items?: T[];
|
|
75
75
|
field?: string;
|
|
76
76
|
initialPinnedIds?: PinId[];
|
|
77
77
|
maxPins?: number;
|
|
@@ -91,8 +91,8 @@ export interface UseVisibilityReturn<T> {
|
|
|
91
91
|
resetVisibility: () => void;
|
|
92
92
|
replaceVisibility: (newVisibleItems: VisibilityId[] | T[]) => void;
|
|
93
93
|
}
|
|
94
|
-
export declare function useVisibility<T = unknown>(
|
|
95
|
-
items
|
|
94
|
+
export declare function useVisibility<T = unknown>(options?: {
|
|
95
|
+
items?: T[];
|
|
96
96
|
field?: string;
|
|
97
97
|
initialVisibleIds?: VisibilityId[];
|
|
98
98
|
}): UseVisibilityReturn<T>;
|