@himanshu-sorathiya/react-kit 1.0.33 → 1.0.34
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/index.d.ts +1201 -131
- package/dist/index.js +4 -4
- package/dist/state.d.ts +1201 -68
- package/dist/state.js +2 -2
- package/dist/state2.js +1375 -611
- package/dist/ui.d.ts +0 -63
- package/dist/ui.js +2 -2
- package/dist/ui2.js +14 -220
- package/dist/utils.js +8 -4
- package/package.json +1 -1
package/dist/state2.js
CHANGED
|
@@ -1,377 +1,708 @@
|
|
|
1
1
|
import { t as e } from "./utils.js";
|
|
2
|
-
import { useCallback as t,
|
|
3
|
-
|
|
4
|
-
|
|
2
|
+
import { useCallback as t, useDeferredValue as n, useMemo as r, useRef as i, useState as a } from "react";
|
|
3
|
+
import { format as o, getDate as s, getMonth as c, getYear as l, isAfter as u, isBefore as d, isDate as f, isEqual as p, isSameDay as m, isValid as h, isWithinRange as g, startOfDay as _, toDate as v } from "@himanshu-sorathiya/datetime";
|
|
4
|
+
//#region src/shared/stateShared/coercion.ts
|
|
5
|
+
function y(e) {
|
|
6
|
+
return f(e) || typeof e == "string" || typeof e == "number";
|
|
7
|
+
}
|
|
8
|
+
function b(e) {
|
|
9
|
+
return typeof e == "number" && Number.isInteger(e);
|
|
10
|
+
}
|
|
11
|
+
function x(e) {
|
|
12
|
+
return typeof e == "object" && !!e && !Array.isArray(e) && "min" in e && "max" in e;
|
|
13
|
+
}
|
|
14
|
+
function S(e) {
|
|
15
|
+
return e == null;
|
|
16
|
+
}
|
|
17
|
+
function C(e) {
|
|
18
|
+
return typeof e == "number" && Number.isInteger(e) && e >= 1;
|
|
19
|
+
}
|
|
20
|
+
function w(e) {
|
|
21
|
+
return typeof e == "string" || typeof e == "number";
|
|
22
|
+
}
|
|
23
|
+
function T(e) {
|
|
24
|
+
return typeof e == "string" || typeof e == "number" || typeof e == "boolean";
|
|
25
|
+
}
|
|
26
|
+
function E(e) {
|
|
27
|
+
if (S(e)) return null;
|
|
28
|
+
if (typeof e == "boolean") return e;
|
|
29
|
+
if (typeof e == "number") return e === 1 || e !== 0 && null;
|
|
30
|
+
if (typeof e == "string") {
|
|
31
|
+
let t = e.trim().toLowerCase();
|
|
32
|
+
return t === "true" || t === "1" ? !0 : t === "false" || t === "0" ? !1 : null;
|
|
33
|
+
}
|
|
34
|
+
return null;
|
|
35
|
+
}
|
|
36
|
+
function D(e) {
|
|
37
|
+
if (S(e)) return null;
|
|
38
|
+
let t = v(e);
|
|
39
|
+
return h(t) ? t : null;
|
|
40
|
+
}
|
|
41
|
+
function O(e) {
|
|
42
|
+
return S(e) || typeof e == "object" ? null : String(e);
|
|
43
|
+
}
|
|
44
|
+
function k(e) {
|
|
45
|
+
if (S(e) || typeof e == "boolean" || typeof e != "number" && typeof e != "string" || typeof e == "string" && e.trim() === "") return null;
|
|
46
|
+
let t = Number(e);
|
|
47
|
+
return Number.isNaN(t) ? null : t;
|
|
48
|
+
}
|
|
49
|
+
//#endregion
|
|
50
|
+
//#region src/state/useExpansion/validation.ts
|
|
51
|
+
var A = globalThis.process?.env?.NODE_ENV !== "production";
|
|
52
|
+
function j(e, t, n) {
|
|
53
|
+
if (w(e)) return !0;
|
|
54
|
+
if (!t) {
|
|
55
|
+
if (A) throw console.warn(`[useExpansion] ${n}: received an object item but no "field" option is configured to resolve its id. Every such item would collapse onto the same expanded id.`), Error(`[useExpansion] ${n}: received an object item but no "field" option is configured to resolve its id.`);
|
|
56
|
+
return !1;
|
|
57
|
+
}
|
|
58
|
+
return !0;
|
|
59
|
+
}
|
|
60
|
+
function M(t, n, r) {
|
|
61
|
+
if (w(t)) return t;
|
|
62
|
+
if (!n) return;
|
|
63
|
+
let i = e(t, n);
|
|
64
|
+
return i === void 0 && A && console.warn(`[useExpansion] ${r}: could not resolve an id from the given item using field "${n}".`), i;
|
|
65
|
+
}
|
|
66
|
+
function N(e, t) {
|
|
67
|
+
A && console.warn(`[useExpansion] ${e}: ${t} expanded ids were given but "multiple" is false; keeping only the first.`);
|
|
68
|
+
}
|
|
69
|
+
function P(e) {
|
|
70
|
+
A && console.warn(`[useExpansion] ${e}: the only expanded item can't be collapsed because "collapsible" is false.`);
|
|
71
|
+
}
|
|
72
|
+
function ee() {
|
|
73
|
+
A && console.warn("[useExpansion] expandAll: has no effect because \"multiple\" is false.");
|
|
74
|
+
}
|
|
75
|
+
//#endregion
|
|
76
|
+
//#region src/state/useExpansion/useExpansion.ts
|
|
77
|
+
function te(e = {}) {
|
|
78
|
+
let n = e, o = n.field, s = !!n.multiple, c = n.collapsible ?? !0, l = r(() => Array.isArray(n.items) ? n.items : [], [n.items]), u = r(() => Array.isArray(n.initialExpandedIds) ? n.initialExpandedIds : [], [n.initialExpandedIds]), d = i(u), [f, p] = a(() => {
|
|
79
|
+
let e = [...new Set(u)];
|
|
80
|
+
return !s && e.length > 1 ? (N("useExpansion", e.length), new Set(e.slice(0, 1))) : new Set(e);
|
|
81
|
+
}), m = t((e) => {
|
|
82
|
+
if (!j(e, o, "isExpanded")) return !1;
|
|
83
|
+
let t = M(e, o, "isExpanded");
|
|
84
|
+
return t !== void 0 && f.has(t);
|
|
85
|
+
}, [f, o]), h = t((e) => {
|
|
86
|
+
j(e, o, "expand") && p((t) => {
|
|
87
|
+
let n = M(e, o, "expand");
|
|
88
|
+
if (n === void 0 || t.has(n)) return t;
|
|
89
|
+
let r = s ? new Set(t) : /* @__PURE__ */ new Set();
|
|
90
|
+
return r.add(n), r;
|
|
91
|
+
});
|
|
92
|
+
}, [o, s]), g = t((e) => {
|
|
93
|
+
j(e, o, "collapse") && p((t) => {
|
|
94
|
+
let n = M(e, o, "collapse");
|
|
95
|
+
if (n === void 0 || !t.has(n)) return t;
|
|
96
|
+
if (!s && !c) return P("collapse"), t;
|
|
97
|
+
let r = new Set(t);
|
|
98
|
+
return r.delete(n), r;
|
|
99
|
+
});
|
|
100
|
+
}, [
|
|
101
|
+
o,
|
|
102
|
+
s,
|
|
103
|
+
c
|
|
104
|
+
]), _ = t((e) => {
|
|
105
|
+
j(e, o, "toggleExpansion") && p((t) => {
|
|
106
|
+
let n = M(e, o, "toggleExpansion");
|
|
107
|
+
if (n === void 0) return t;
|
|
108
|
+
if (t.has(n)) {
|
|
109
|
+
if (!s && !c) return P("toggleExpansion"), t;
|
|
110
|
+
let e = s ? new Set(t) : /* @__PURE__ */ new Set();
|
|
111
|
+
return e.delete(n), e;
|
|
112
|
+
}
|
|
113
|
+
let r = s ? new Set(t) : /* @__PURE__ */ new Set();
|
|
114
|
+
return r.add(n), r;
|
|
115
|
+
});
|
|
116
|
+
}, [
|
|
117
|
+
o,
|
|
118
|
+
s,
|
|
119
|
+
c
|
|
120
|
+
]), v = t((e) => {
|
|
121
|
+
if (!s) {
|
|
122
|
+
ee();
|
|
123
|
+
return;
|
|
124
|
+
}
|
|
125
|
+
let t = Array.isArray(e) ? e : l, n = [];
|
|
126
|
+
for (let e of t) {
|
|
127
|
+
let t = M(e, o, "expandAll");
|
|
128
|
+
t !== void 0 && n.push(t);
|
|
129
|
+
}
|
|
130
|
+
p(new Set(n));
|
|
131
|
+
}, [
|
|
132
|
+
l,
|
|
133
|
+
o,
|
|
134
|
+
s
|
|
135
|
+
]), y = t((e) => {
|
|
136
|
+
if (e === void 0) {
|
|
137
|
+
p((e) => e.size === 0 ? e : /* @__PURE__ */ new Set());
|
|
138
|
+
return;
|
|
139
|
+
}
|
|
140
|
+
let t = Array.isArray(e) ? e : [];
|
|
141
|
+
p((e) => {
|
|
142
|
+
let n = new Set(e);
|
|
143
|
+
for (let e of t) {
|
|
144
|
+
if (!j(e, o, "collapseAll")) continue;
|
|
145
|
+
let t = M(e, o, "collapseAll");
|
|
146
|
+
t !== void 0 && n.delete(t);
|
|
147
|
+
}
|
|
148
|
+
return n;
|
|
149
|
+
});
|
|
150
|
+
}, [o]), b = t(() => {
|
|
151
|
+
let e = d.current;
|
|
152
|
+
if (!s && e.length > 1) {
|
|
153
|
+
N("resetExpansion", e.length), p(new Set(e.slice(0, 1)));
|
|
154
|
+
return;
|
|
155
|
+
}
|
|
156
|
+
p(new Set(e));
|
|
157
|
+
}, [s]), x = t((e) => {
|
|
158
|
+
let t = Array.isArray(e) ? e : [], n = [];
|
|
159
|
+
for (let e of t) {
|
|
160
|
+
if (!j(e, o, "replaceExpansion")) continue;
|
|
161
|
+
let t = M(e, o, "replaceExpansion");
|
|
162
|
+
t !== void 0 && n.push(t);
|
|
163
|
+
}
|
|
164
|
+
let r = [...new Set(n)];
|
|
165
|
+
if (!s && r.length > 1) {
|
|
166
|
+
N("replaceExpansion", r.length), p(new Set(r.slice(0, 1)));
|
|
167
|
+
return;
|
|
168
|
+
}
|
|
169
|
+
p(new Set(r));
|
|
170
|
+
}, [o, s]), S = r(() => [...f], [f]), { expandedItems: C, collapsedItems: w } = r(() => {
|
|
171
|
+
let e = [], t = [];
|
|
172
|
+
for (let n of l) {
|
|
173
|
+
let r = M(n, o, "expandedItems");
|
|
174
|
+
r !== void 0 && f.has(r) ? e.push(n) : t.push(n);
|
|
175
|
+
}
|
|
176
|
+
return {
|
|
177
|
+
expandedItems: e,
|
|
178
|
+
collapsedItems: t
|
|
179
|
+
};
|
|
180
|
+
}, [
|
|
181
|
+
l,
|
|
182
|
+
o,
|
|
183
|
+
f
|
|
184
|
+
]);
|
|
185
|
+
return {
|
|
186
|
+
expandedIds: S,
|
|
187
|
+
expandedItems: C,
|
|
188
|
+
collapsedItems: w,
|
|
189
|
+
expandedCount: f.size,
|
|
190
|
+
hasExpanded: f.size > 0,
|
|
191
|
+
isExpanded: m,
|
|
192
|
+
expand: h,
|
|
193
|
+
collapse: g,
|
|
194
|
+
toggleExpansion: _,
|
|
195
|
+
expandAll: v,
|
|
196
|
+
collapseAll: y,
|
|
197
|
+
resetExpansion: b,
|
|
198
|
+
replaceExpansion: x
|
|
199
|
+
};
|
|
200
|
+
}
|
|
201
|
+
//#endregion
|
|
202
|
+
//#region src/state/useFilter/strategies.ts
|
|
203
|
+
function ne(e, t) {
|
|
204
|
+
return re[e]?.[t];
|
|
205
|
+
}
|
|
206
|
+
var re = {
|
|
5
207
|
text: {
|
|
6
|
-
contains: (e, t, n) =>
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
208
|
+
contains: (e, t, n) => {
|
|
209
|
+
if (!T(e) || !T(t)) return !1;
|
|
210
|
+
let r = String(e), i = String(t);
|
|
211
|
+
return n?.caseSensitive ? r.includes(i) : r.toLowerCase().includes(i.toLowerCase());
|
|
212
|
+
},
|
|
213
|
+
equals: (e, t, n) => {
|
|
214
|
+
if (!T(e) || !T(t)) return !1;
|
|
215
|
+
let r = String(e), i = String(t);
|
|
216
|
+
return n?.caseSensitive ? r === i : r.toLowerCase() === i.toLowerCase();
|
|
217
|
+
},
|
|
218
|
+
startsWith: (e, t, n) => {
|
|
219
|
+
if (!T(e) || !T(t)) return !1;
|
|
220
|
+
let r = String(e), i = String(t);
|
|
221
|
+
return n?.caseSensitive ? r.startsWith(i) : r.toLowerCase().startsWith(i.toLowerCase());
|
|
222
|
+
},
|
|
223
|
+
endsWith: (e, t, n) => {
|
|
224
|
+
if (!T(e) || !T(t)) return !1;
|
|
225
|
+
let r = String(e), i = String(t);
|
|
226
|
+
return n?.caseSensitive ? r.endsWith(i) : r.toLowerCase().endsWith(i.toLowerCase());
|
|
227
|
+
},
|
|
228
|
+
notContains: (e, t, n) => {
|
|
229
|
+
if (!T(e) || !T(t)) return !1;
|
|
230
|
+
let r = String(e), i = String(t);
|
|
231
|
+
return n?.caseSensitive ? !r.includes(i) : !r.toLowerCase().includes(i.toLowerCase());
|
|
232
|
+
}
|
|
11
233
|
},
|
|
12
234
|
number: {
|
|
13
|
-
equals: (e, t) =>
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
235
|
+
equals: (e, t) => {
|
|
236
|
+
let n = k(e), r = k(t);
|
|
237
|
+
return n === null || r === null ? !1 : n === r;
|
|
238
|
+
},
|
|
239
|
+
greaterThan: (e, t) => {
|
|
240
|
+
let n = k(e), r = k(t);
|
|
241
|
+
return n === null || r === null ? !1 : n > r;
|
|
242
|
+
},
|
|
243
|
+
lessThan: (e, t) => {
|
|
244
|
+
let n = k(e), r = k(t);
|
|
245
|
+
return n === null || r === null ? !1 : n < r;
|
|
246
|
+
},
|
|
247
|
+
greaterThanOrEqual: (e, t) => {
|
|
248
|
+
let n = k(e), r = k(t);
|
|
249
|
+
return n === null || r === null ? !1 : n >= r;
|
|
250
|
+
},
|
|
251
|
+
lessThanOrEqual: (e, t) => {
|
|
252
|
+
let n = k(e), r = k(t);
|
|
253
|
+
return n === null || r === null ? !1 : n <= r;
|
|
254
|
+
},
|
|
18
255
|
between: (e, t) => {
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
256
|
+
let n = k(e);
|
|
257
|
+
if (n === null || !x(t)) return !1;
|
|
258
|
+
let r = k(t.min), i = k(t.max);
|
|
259
|
+
return r === null || i === null ? !1 : n >= Math.min(r, i) && n <= Math.max(r, i);
|
|
22
260
|
}
|
|
23
261
|
},
|
|
24
|
-
boolean: {
|
|
25
|
-
date: {
|
|
262
|
+
boolean: {
|
|
26
263
|
equals: (e, t) => {
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
return Number.isNaN(n.getTime()) || Number.isNaN(r.getTime()) ? !1 : n.getFullYear() === r.getFullYear() && n.getMonth() === r.getMonth() && n.getDate() === r.getDate();
|
|
264
|
+
let n = E(e), r = E(t);
|
|
265
|
+
return n === null || r === null ? !1 : n === r;
|
|
30
266
|
},
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
267
|
+
notEquals: (e, t) => {
|
|
268
|
+
let n = E(e), r = E(t);
|
|
269
|
+
return n === null || r === null ? !1 : n !== r;
|
|
270
|
+
}
|
|
271
|
+
},
|
|
272
|
+
date: {
|
|
273
|
+
equals: (e, t, n) => {
|
|
274
|
+
let r = D(e), i = D(t);
|
|
275
|
+
return !r || !i ? !1 : (n?.dateGranularity ?? "day") === "instant" ? p(r, i) : m(r, i);
|
|
35
276
|
},
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
return Number.isNaN(n) || Number.isNaN(r) ? !1 : n > r;
|
|
277
|
+
before: (e, t, n) => {
|
|
278
|
+
let r = D(e), i = D(t);
|
|
279
|
+
return !r || !i ? !1 : (n?.dateGranularity ?? "day") === "instant" ? d(r, i) : d(_(r), _(i));
|
|
40
280
|
},
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
281
|
+
after: (e, t, n) => {
|
|
282
|
+
let r = D(e), i = D(t);
|
|
283
|
+
return !r || !i ? !1 : (n?.dateGranularity ?? "day") === "instant" ? u(r, i) : u(_(r), _(i));
|
|
284
|
+
},
|
|
285
|
+
between: (e, t, n) => {
|
|
286
|
+
let r = D(e);
|
|
287
|
+
if (!r || !x(t)) return !1;
|
|
288
|
+
let i = D(t.min), a = D(t.max);
|
|
289
|
+
return !i || !a ? !1 : (n?.dateGranularity ?? "day") === "instant" ? g(r, i, a) : g(_(r), _(i), _(a));
|
|
47
290
|
}
|
|
48
291
|
},
|
|
49
292
|
select: {
|
|
50
|
-
equals: (e, t) => e
|
|
51
|
-
notEquals: (e, t) => e
|
|
293
|
+
equals: (e, t) => S(e) || S(t) ? !1 : e == t,
|
|
294
|
+
notEquals: (e, t) => S(e) || S(t) ? !1 : e != t,
|
|
295
|
+
in: (e, t) => S(e) || !Array.isArray(t) ? !1 : t.some((t) => e == t),
|
|
296
|
+
notIn: (e, t) => S(e) || !Array.isArray(t) ? !1 : !t.some((t) => e == t)
|
|
52
297
|
},
|
|
53
298
|
multiselect: {
|
|
54
|
-
in: (e, t) => t.includes(e),
|
|
55
|
-
notIn: (e, t) => !t.includes(e),
|
|
56
|
-
intersects: (e, t) => e.some((e) => t.includes(e))
|
|
299
|
+
in: (e, t) => S(e) || !Array.isArray(t) ? !1 : t.includes(e),
|
|
300
|
+
notIn: (e, t) => S(e) || !Array.isArray(t) ? !1 : !t.includes(e),
|
|
301
|
+
intersects: (e, t) => S(e) || !Array.isArray(e) || S(t) || !Array.isArray(t) ? !1 : e.some((e) => t.includes(e))
|
|
57
302
|
}
|
|
58
|
-
};
|
|
303
|
+
}, F = globalThis.process?.env?.NODE_ENV !== "production";
|
|
304
|
+
function I(e, t) {
|
|
305
|
+
if (!F) return;
|
|
306
|
+
let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
|
|
307
|
+
for (let t of e) n.has(t.id) && r.add(t.id), n.add(t.id);
|
|
308
|
+
r.size > 0 && console.warn(`[useFilter] ${t} contains duplicate filter ids: ${[...r].join(", ")}. Lookups by id (getFilter, getFilterValue, isFilterActive, updateFilterConfig, updateFilterValue) will only ever affect the first match.`);
|
|
309
|
+
}
|
|
310
|
+
function ie(e, t, n) {
|
|
311
|
+
switch (e) {
|
|
312
|
+
case "text": return typeof n == "string";
|
|
313
|
+
case "number": return t === "between" ? typeof n == "object" && !!n && !Array.isArray(n) && typeof n.min == "number" && typeof n.max == "number" : typeof n == "number";
|
|
314
|
+
case "boolean": return typeof n == "boolean";
|
|
315
|
+
case "date": return t === "between" ? typeof n == "object" && !!n && !Array.isArray(n) && y(n.min) && y(n.max) : y(n);
|
|
316
|
+
case "select": return t === "in" || t === "notIn" ? Array.isArray(n) && n.every((e) => typeof e == "string" || typeof e == "number") : typeof n == "string" || typeof n == "number";
|
|
317
|
+
case "multiselect": return Array.isArray(n);
|
|
318
|
+
case "custom": return !0;
|
|
319
|
+
default: return !1;
|
|
320
|
+
}
|
|
321
|
+
}
|
|
322
|
+
function ae(e, t, n, r) {
|
|
323
|
+
let i = e.findIndex((e) => e.id === t), a = e[i];
|
|
324
|
+
if (i === -1 || !a) {
|
|
325
|
+
if (F) throw console.warn(`[useFilter] ${r}: no filter found with id "${t}".`), Error(`[useFilter] ${r}: no filter found with id "${t}".`);
|
|
326
|
+
return e;
|
|
327
|
+
}
|
|
328
|
+
let o = {
|
|
329
|
+
...a,
|
|
330
|
+
...n
|
|
331
|
+
};
|
|
332
|
+
if (!ie(o.type, o.operator, o.value)) {
|
|
333
|
+
if (F) throw console.warn(`[useFilter] ${r}: update to filter "${t}" would produce a value incompatible with type "${o.type}" and operator "${o.operator}". Update was ignored to avoid corrupting filter state.`, {
|
|
334
|
+
attempted: n,
|
|
335
|
+
current: a
|
|
336
|
+
}), Error(`[useFilter] ${r}: update to filter "${t}" would produce a value incompatible with type "${o.type}" and operator "${o.operator}". Update was ignored to avoid corrupting filter state.`);
|
|
337
|
+
return e;
|
|
338
|
+
}
|
|
339
|
+
let s = [...e];
|
|
340
|
+
return s[i] = o, s;
|
|
341
|
+
}
|
|
59
342
|
//#endregion
|
|
60
343
|
//#region src/state/useFilter/useFilter.ts
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
}, []), v = t((e) => {
|
|
84
|
-
|
|
85
|
-
}, [])
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
344
|
+
var oe = globalThis.process?.env?.NODE_ENV !== "production";
|
|
345
|
+
function se(o = [], s = [], c) {
|
|
346
|
+
let l = r(() => Array.isArray(o) ? o : [], [o]), u = r(() => Array.isArray(s) ? s : [], [s]), d = i(u), [f, p] = a(() => (I(u, "initialFilters"), u)), m = n(f), h = c?.defer ? m : f, g = r(() => {
|
|
347
|
+
let t = h.filter((e) => e.isActive !== !1).map((e) => {
|
|
348
|
+
let { id: t, type: n, operator: r, value: i, compare: a, field: o } = e, s = (o ?? t).split(".");
|
|
349
|
+
if (n === "custom") return a ? {
|
|
350
|
+
pathArray: s,
|
|
351
|
+
evaluate: (e, t) => a(e, i, t)
|
|
352
|
+
} : (oe && console.warn(`[useFilter] filter "${t}" has type "custom" but no "compare" function was provided. Excluding all items for this filter.`), {
|
|
353
|
+
pathArray: s,
|
|
354
|
+
evaluate: () => !1
|
|
355
|
+
});
|
|
356
|
+
let c = ne(n, r);
|
|
357
|
+
return c ? {
|
|
358
|
+
pathArray: s,
|
|
359
|
+
evaluate: (t) => c(t, i, e)
|
|
360
|
+
} : (oe && console.warn(`[useFilter] filter "${t}" has an unknown type/operator combination ("${n}"/"${r}"). Excluding all items for this filter.`), {
|
|
361
|
+
pathArray: s,
|
|
362
|
+
evaluate: () => !1
|
|
363
|
+
});
|
|
364
|
+
});
|
|
365
|
+
return t.length === 0 ? l : l.filter((n) => t.every(({ pathArray: t, evaluate: r }) => r(e(n, t), n)));
|
|
366
|
+
}, [l, h]), _ = r(() => f.filter((e) => e.isActive !== !1).length, [f]), v = _ > 0, y = t((e) => {
|
|
367
|
+
p((t) => t.some((t) => t.id === e.id) ? t.map((t) => t.id === e.id ? e : t) : [...t, e]);
|
|
368
|
+
}, []), b = t((e) => {
|
|
369
|
+
p((t) => Array.isArray(e) ? t.filter((t) => !e.includes(t.id)) : t.filter((t) => t.id !== e));
|
|
370
|
+
}, []), x = t(() => {
|
|
371
|
+
p([]);
|
|
372
|
+
}, []), S = t(() => {
|
|
373
|
+
p(d.current);
|
|
374
|
+
}, []), C = t((e) => {
|
|
375
|
+
let t = Array.isArray(e) ? e : [];
|
|
376
|
+
I(t, "replaceFilters"), p(t);
|
|
377
|
+
}, []), w = t((e) => {
|
|
378
|
+
p((t) => {
|
|
379
|
+
let n = t.findIndex((t) => t.id === e.id), r = t[n];
|
|
380
|
+
if (n === -1 || !r) return [...t, {
|
|
98
381
|
...e,
|
|
99
382
|
isActive: !0
|
|
100
|
-
}]
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
383
|
+
}];
|
|
384
|
+
let i = [...t];
|
|
385
|
+
return i[n] = {
|
|
386
|
+
...r,
|
|
387
|
+
isActive: r.isActive === !1
|
|
388
|
+
}, i;
|
|
389
|
+
});
|
|
390
|
+
}, []), T = t((e, t) => {
|
|
391
|
+
p((n) => ae(n, e, t, "updateFilterConfig"));
|
|
392
|
+
}, []), E = t((e, t) => {
|
|
393
|
+
p((n) => ae(n, e, { value: t }, "updateFilterValue"));
|
|
394
|
+
}, []), D = r(() => {
|
|
395
|
+
let e = /* @__PURE__ */ new Map();
|
|
396
|
+
for (let t of f) e.has(t.id) || e.set(t.id, t);
|
|
397
|
+
return e;
|
|
398
|
+
}, [f]);
|
|
399
|
+
return {
|
|
400
|
+
filteredItems: g,
|
|
401
|
+
filters: f,
|
|
402
|
+
activeFilterCount: _,
|
|
403
|
+
hasActiveFilters: v,
|
|
404
|
+
upsertFilter: y,
|
|
405
|
+
removeFilter: b,
|
|
406
|
+
clearFilters: x,
|
|
407
|
+
resetFilters: S,
|
|
408
|
+
replaceFilters: C,
|
|
409
|
+
toggleFilter: w,
|
|
410
|
+
updateFilterConfig: T,
|
|
411
|
+
getFilter: t((e) => D.get(e), [D]),
|
|
412
|
+
getFilterValue: t((e) => D.get(e)?.value, [D]),
|
|
413
|
+
updateFilterValue: E,
|
|
116
414
|
isFilterActive: t((e) => {
|
|
117
|
-
let t =
|
|
415
|
+
let t = D.get(e);
|
|
118
416
|
return t ? t.isActive !== !1 : !1;
|
|
119
|
-
}, [
|
|
417
|
+
}, [D])
|
|
120
418
|
};
|
|
121
419
|
}
|
|
122
420
|
//#endregion
|
|
123
|
-
//#region src/state/
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
}
|
|
142
|
-
if (t === r.length) return .85;
|
|
421
|
+
//#region src/state/useGrouping/utils.ts
|
|
422
|
+
var ce = globalThis.process?.env?.NODE_ENV !== "production";
|
|
423
|
+
function le(e, t = 2) {
|
|
424
|
+
return String(e).padStart(t, "0");
|
|
425
|
+
}
|
|
426
|
+
function ue(e, t) {
|
|
427
|
+
return e.trim() === "" ? t : e;
|
|
428
|
+
}
|
|
429
|
+
function de(t, n) {
|
|
430
|
+
let r = t.split(".");
|
|
431
|
+
return { resolveKeys: (t) => {
|
|
432
|
+
let i = e(t, r), a = Array.isArray(i) ? i : [i], o = /* @__PURE__ */ new Set(), s = [];
|
|
433
|
+
for (let e of a) {
|
|
434
|
+
if (S(e) || typeof e == "object") continue;
|
|
435
|
+
let t = ue(String(e), n);
|
|
436
|
+
t !== n && (o.has(t) || (o.add(t), s.push({
|
|
437
|
+
key: t,
|
|
438
|
+
label: t
|
|
439
|
+
})));
|
|
143
440
|
}
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
let
|
|
152
|
-
|
|
153
|
-
let
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
let
|
|
159
|
-
if (
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
441
|
+
return s.length > 0 ? s : [{
|
|
442
|
+
key: n,
|
|
443
|
+
label: n
|
|
444
|
+
}];
|
|
445
|
+
} };
|
|
446
|
+
}
|
|
447
|
+
function fe(t, n, r) {
|
|
448
|
+
let i = t.split(".");
|
|
449
|
+
return { resolveKeys: (t) => {
|
|
450
|
+
let a = D(e(t, i));
|
|
451
|
+
if (!a) return [{
|
|
452
|
+
key: r,
|
|
453
|
+
label: r
|
|
454
|
+
}];
|
|
455
|
+
let u = l(a);
|
|
456
|
+
if (n === "year") return [{
|
|
457
|
+
key: `${u}`,
|
|
458
|
+
label: o(a, "yyyy")
|
|
459
|
+
}];
|
|
460
|
+
let d = c(a);
|
|
461
|
+
if (n === "month") return [{
|
|
462
|
+
key: `${u}-${le(d)}`,
|
|
463
|
+
label: o(a, "MMMM yyyy")
|
|
464
|
+
}];
|
|
465
|
+
let f = s(a);
|
|
466
|
+
return [{
|
|
467
|
+
key: `${u}-${le(d)}-${le(f)}`,
|
|
468
|
+
label: o(a, "MMMM dd, yyyy")
|
|
469
|
+
}];
|
|
470
|
+
} };
|
|
471
|
+
}
|
|
472
|
+
function pe(e, t, n) {
|
|
473
|
+
let r = !1;
|
|
474
|
+
return { resolveKeys: (i) => {
|
|
475
|
+
let a;
|
|
476
|
+
try {
|
|
477
|
+
a = e.getKey(i);
|
|
478
|
+
} catch (e) {
|
|
479
|
+
if (ce) throw console.warn(`[useGrouping] custom group level "${n}" threw an error while computing a key.`, e), e;
|
|
480
|
+
return r ||= (console.warn(`[useGrouping] custom group level "${n}" threw an error for at least one item; affected items were placed in "${t}".`, e), !0), [{
|
|
481
|
+
key: t,
|
|
482
|
+
label: t
|
|
483
|
+
}];
|
|
484
|
+
}
|
|
485
|
+
if (S(a)) return [{
|
|
486
|
+
key: t,
|
|
487
|
+
label: t
|
|
488
|
+
}];
|
|
489
|
+
let o = Array.isArray(a) ? a : [a];
|
|
490
|
+
if (o.some((e) => typeof e != "string")) {
|
|
491
|
+
if (ce) throw console.warn(`[useGrouping] custom group level "${n}" returned a non-string key.`, { returned: a }), Error(`[useGrouping] custom group level "${n}" returned a non-string key.`);
|
|
492
|
+
return r ||= (console.warn(`[useGrouping] custom group level "${n}" returned an invalid key for at least one item; affected items were placed in "${t}".`), !0), [{
|
|
493
|
+
key: t,
|
|
494
|
+
label: t
|
|
495
|
+
}];
|
|
165
496
|
}
|
|
497
|
+
let s = /* @__PURE__ */ new Set(), c = [];
|
|
498
|
+
for (let e of o) {
|
|
499
|
+
let n = ue(e, t);
|
|
500
|
+
n !== t && (s.has(n) || (s.add(n), c.push({
|
|
501
|
+
key: n,
|
|
502
|
+
label: n
|
|
503
|
+
})));
|
|
504
|
+
}
|
|
505
|
+
return c.length > 0 ? c : [{
|
|
506
|
+
key: t,
|
|
507
|
+
label: t
|
|
508
|
+
}];
|
|
509
|
+
} };
|
|
510
|
+
}
|
|
511
|
+
function me(e) {
|
|
512
|
+
throw Error(`[useGrouping] unhandled group level type: ${JSON.stringify(e)}`);
|
|
513
|
+
}
|
|
514
|
+
function he(e, t, n) {
|
|
515
|
+
switch (e.type) {
|
|
516
|
+
case "field": return de(e.field, n);
|
|
517
|
+
case "date": return fe(e.field, e.bucket ?? "day", n);
|
|
518
|
+
case "custom": return pe(e, n, e.id ?? `level ${t + 1}`);
|
|
519
|
+
default: return me(e);
|
|
166
520
|
}
|
|
167
|
-
if (c < r.length / 2) return 0;
|
|
168
|
-
let p = c / r.length, m = .6 ** d, h = c > 1 ? u / (c - 1) : 1, g = Math.max(.4, 1 - h / i.length), _ = p * m * g;
|
|
169
|
-
return Math.max(0, _ * .45);
|
|
170
521
|
}
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
let
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
text: e,
|
|
185
|
-
weight: o
|
|
186
|
-
});
|
|
187
|
-
}
|
|
188
|
-
} else if (i != null && i !== "" && typeof i != "object") {
|
|
189
|
-
let e = String(i);
|
|
190
|
-
a.push(e);
|
|
191
|
-
let t = e.split(/[^a-z0-9]+/i).filter((e) => e.length > 0);
|
|
192
|
-
for (let e of t) r.push({
|
|
193
|
-
text: e,
|
|
194
|
-
weight: o
|
|
195
|
-
});
|
|
196
|
-
}
|
|
197
|
-
}
|
|
522
|
+
function ge(e, t, n) {
|
|
523
|
+
let r = t[n];
|
|
524
|
+
if (!r) return [];
|
|
525
|
+
let i = /* @__PURE__ */ new Map();
|
|
526
|
+
for (let t of e) for (let { key: e, label: n } of r.resolveKeys(t)) {
|
|
527
|
+
let r = i.get(e);
|
|
528
|
+
r ? r.items.push(t) : i.set(e, {
|
|
529
|
+
label: n,
|
|
530
|
+
items: [t]
|
|
531
|
+
});
|
|
532
|
+
}
|
|
533
|
+
return Array.from(i.entries()).map(([e, r]) => {
|
|
534
|
+
let i = ge(r.items, t, n + 1);
|
|
198
535
|
return {
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
536
|
+
key: e,
|
|
537
|
+
label: r.label,
|
|
538
|
+
items: r.items,
|
|
539
|
+
...i.length > 0 ? { subGroups: i } : {}
|
|
203
540
|
};
|
|
204
|
-
})
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
541
|
+
});
|
|
542
|
+
}
|
|
543
|
+
function _e(e, t, n, r) {
|
|
544
|
+
return t.length === 0 ? [{
|
|
545
|
+
key: r,
|
|
546
|
+
label: r,
|
|
547
|
+
items: e
|
|
548
|
+
}] : ge(e, t.map((e, t) => he(e, t, n)), 0);
|
|
549
|
+
}
|
|
550
|
+
//#endregion
|
|
551
|
+
//#region src/state/useGrouping/validation.ts
|
|
552
|
+
var ve = globalThis.process?.env?.NODE_ENV !== "production";
|
|
553
|
+
function ye(e) {
|
|
554
|
+
return typeof e == "string" ? {
|
|
555
|
+
type: "field",
|
|
556
|
+
field: e
|
|
557
|
+
} : e;
|
|
558
|
+
}
|
|
559
|
+
function be(e) {
|
|
560
|
+
return e === void 0 ? [] : (Array.isArray(e) ? e : [e]).map((e) => ye(e));
|
|
561
|
+
}
|
|
562
|
+
function xe(e) {
|
|
563
|
+
return typeof e != "object" || !e ? !1 : e.type === "field" ? typeof e.field == "string" && e.field.length > 0 : e.type === "date" ? typeof e.field == "string" && e.field.length > 0 && (e.bucket === void 0 || e.bucket === "day" || e.bucket === "month" || e.bucket === "year") : e.type === "custom" && typeof e.getKey == "function" && (e.id === void 0 || typeof e.id == "string");
|
|
564
|
+
}
|
|
565
|
+
function Se(e) {
|
|
566
|
+
if (!ve) return;
|
|
567
|
+
let t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
|
|
568
|
+
for (let r of e) r.type !== "custom" || !r.id || (t.has(r.id) && n.add(r.id), t.add(r.id));
|
|
569
|
+
n.size > 0 && console.warn(`[useGrouping] duplicate custom group level ids: ${[...n].join(", ")}. Dev warnings referencing these ids may be ambiguous about which level they mean.`);
|
|
570
|
+
}
|
|
571
|
+
//#endregion
|
|
572
|
+
//#region src/state/useGrouping/useGrouping.ts
|
|
573
|
+
var Ce = globalThis.process?.env?.NODE_ENV !== "production";
|
|
574
|
+
function we(e = [], o, s) {
|
|
575
|
+
let c = r(() => Array.isArray(e) ? e : [], [e]), l = s?.unknownGroupLabel ?? "Unknown", u = s?.ungroupedGroupLabel ?? "Ungrouped", d = r(() => be(o), [o]), [f, p] = a(() => {
|
|
576
|
+
let e = d.find((e) => !xe(e));
|
|
577
|
+
if (e) {
|
|
578
|
+
if (Ce) throw console.warn("[useGrouping] initialGroupBy contains an invalid group level.", e), Error("[useGrouping] initialGroupBy contains an invalid group level.");
|
|
579
|
+
return [];
|
|
241
580
|
}
|
|
242
|
-
return
|
|
243
|
-
}, [
|
|
244
|
-
d,
|
|
245
|
-
t,
|
|
246
|
-
r,
|
|
247
|
-
o,
|
|
581
|
+
return Se(d), d;
|
|
582
|
+
}), m = i(f), h = n(f), g = s?.defer ? h : f, _ = r(() => _e(c, g, l, u), [
|
|
248
583
|
c,
|
|
584
|
+
g,
|
|
249
585
|
l,
|
|
250
586
|
u
|
|
251
|
-
])
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
let
|
|
258
|
-
return
|
|
259
|
-
},
|
|
260
|
-
key: e,
|
|
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]);
|
|
587
|
+
]), v = r(() => {
|
|
588
|
+
let e = /* @__PURE__ */ new Map();
|
|
589
|
+
for (let t of _) e.has(t.key) || e.set(t.key, t);
|
|
590
|
+
return e;
|
|
591
|
+
}, [_]), y = r(() => {
|
|
592
|
+
let e = {};
|
|
593
|
+
for (let t of _) e[t.key] = t.items;
|
|
594
|
+
return e;
|
|
595
|
+
}, [_]), b = r(() => _.map((e) => e.key), [_]);
|
|
269
596
|
return {
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
groupKeys:
|
|
273
|
-
totalGroups:
|
|
274
|
-
activeGroupBy:
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
597
|
+
groupedArray: _,
|
|
598
|
+
groupedRecord: y,
|
|
599
|
+
groupKeys: b,
|
|
600
|
+
totalGroups: b.length,
|
|
601
|
+
activeGroupBy: f,
|
|
602
|
+
hasActiveGrouping: f.length > 0,
|
|
603
|
+
unknownGroupKey: l,
|
|
604
|
+
ungroupedGroupKey: u,
|
|
605
|
+
changeGroupBy: t((e) => {
|
|
606
|
+
let t = be(e), n = t.find((e) => !xe(e));
|
|
607
|
+
if (n) {
|
|
608
|
+
if (Ce) throw console.warn("[useGrouping] changeGroupBy: received an invalid group level.", n), Error("[useGrouping] changeGroupBy: received an invalid group level.");
|
|
609
|
+
return;
|
|
610
|
+
}
|
|
611
|
+
Se(t), p(t);
|
|
612
|
+
}, []),
|
|
613
|
+
clearGrouping: t(() => {
|
|
614
|
+
p([]);
|
|
615
|
+
}, []),
|
|
616
|
+
resetGrouping: t(() => {
|
|
617
|
+
p(m.current);
|
|
618
|
+
}, []),
|
|
619
|
+
getGroup: t((e) => v.get(e), [v]),
|
|
620
|
+
getGroupItems: t((e) => v.get(e)?.items ?? [], [v])
|
|
279
621
|
};
|
|
280
622
|
}
|
|
281
623
|
//#endregion
|
|
282
|
-
//#region src/shared/stateShared/utils.ts
|
|
283
|
-
function u(e, t, n) {
|
|
284
|
-
if (!((typeof e == "object" || typeof e == "function") && e !== null)) return e;
|
|
285
|
-
let r = typeof t == "string" ? t.split(".") : Array.isArray(t) ? t : [];
|
|
286
|
-
if (r.length === 0) return n ?? void 0;
|
|
287
|
-
let i = r.reduce((e, t) => {
|
|
288
|
-
if ((typeof e == "object" || typeof e == "function") && e !== null) return e[t];
|
|
289
|
-
}, e);
|
|
290
|
-
return i === void 0 ? n ?? void 0 : i;
|
|
291
|
-
}
|
|
292
|
-
//#endregion
|
|
293
624
|
//#region src/shared/selectionShared/utils.ts
|
|
294
|
-
var
|
|
295
|
-
function
|
|
296
|
-
let
|
|
297
|
-
if (
|
|
298
|
-
item:
|
|
299
|
-
field:
|
|
300
|
-
}), Error(`[resolveSelectionId] Invalid id resolved: ${String(
|
|
301
|
-
return
|
|
625
|
+
var Te = globalThis.process?.env?.NODE_ENV !== "production";
|
|
626
|
+
function L(t, n) {
|
|
627
|
+
let r = e(t, n);
|
|
628
|
+
if (Te && r == null) throw console.warn("[resolveSelectionId] Resolved id is", r, "— this usually means `field` does not point to a valid property on the item, or the item's runtime shape doesn't match its declared type.", {
|
|
629
|
+
item: t,
|
|
630
|
+
field: n
|
|
631
|
+
}), Error(`[resolveSelectionId] Invalid id resolved: ${String(r)}`);
|
|
632
|
+
return r;
|
|
302
633
|
}
|
|
303
634
|
//#endregion
|
|
304
635
|
//#region src/state/useMultipleSelection/useMultipleSelection.ts
|
|
305
|
-
function
|
|
306
|
-
let { items:
|
|
636
|
+
function Ee(e = {}) {
|
|
637
|
+
let { items: n, defaultSelectedIds: i, isDisabled: o, field: s } = e, c = r(() => Array.isArray(n) ? n : [], [n]), l = r(() => Array.isArray(i) ? i : [], [i]), [u, d] = a(() => new Set(l)), f = r(() => c.map((e) => ({
|
|
307
638
|
item: e,
|
|
308
|
-
id:
|
|
309
|
-
})), [c, s]),
|
|
310
|
-
let e =
|
|
639
|
+
id: L(e, s)
|
|
640
|
+
})), [c, s]), p = r(() => f.map((e) => e.id), [f]), m = r(() => p.filter((e) => !(o?.(e) ?? !1)), [p, o]), h = r(() => f.filter((e) => u.has(e.id)).map((e) => e.item), [f, u]), g = r(() => {
|
|
641
|
+
let e = p.filter((e) => u.has(e));
|
|
311
642
|
if (e.length === u.size) return e;
|
|
312
643
|
let t = new Set(e), n = [];
|
|
313
644
|
return u.forEach((e) => {
|
|
314
645
|
t.has(e) || n.push(e);
|
|
315
646
|
}), [...e, ...n];
|
|
316
|
-
}, [
|
|
317
|
-
|
|
318
|
-
|
|
647
|
+
}, [p, u]), _ = r(() => m.length > 0 && m.every((e) => u.has(e)), [m, u]), v = r(() => !_ && m.some((e) => u.has(e)), [
|
|
648
|
+
_,
|
|
649
|
+
m,
|
|
319
650
|
u
|
|
320
|
-
]),
|
|
321
|
-
let t =
|
|
651
|
+
]), y = t((e) => {
|
|
652
|
+
let t = L(e, s);
|
|
322
653
|
o?.(t) || d((e) => {
|
|
323
654
|
if (e.has(t)) return e;
|
|
324
655
|
let n = new Set(e);
|
|
325
656
|
return n.add(t), n;
|
|
326
657
|
});
|
|
327
|
-
}, [s, o]),
|
|
328
|
-
let t =
|
|
658
|
+
}, [s, o]), b = t((e) => {
|
|
659
|
+
let t = L(e, s);
|
|
329
660
|
d((e) => {
|
|
330
661
|
if (!e.has(t)) return e;
|
|
331
662
|
let n = new Set(e);
|
|
332
663
|
return n.delete(t), n;
|
|
333
664
|
});
|
|
334
|
-
}, [s]),
|
|
335
|
-
let t =
|
|
665
|
+
}, [s]), x = t((e) => {
|
|
666
|
+
let t = L(e, s);
|
|
336
667
|
d((e) => {
|
|
337
668
|
let n = e.has(t);
|
|
338
669
|
if (!n && o?.(t)) return e;
|
|
339
670
|
let r = new Set(e);
|
|
340
671
|
return n ? r.delete(t) : r.add(t), r;
|
|
341
672
|
});
|
|
342
|
-
}, [s, o]),
|
|
343
|
-
let t = (Array.isArray(e) ? e : []).map((e) =>
|
|
673
|
+
}, [s, o]), S = t((e) => u.has(L(e, s)), [u, s]), C = t(() => d(new Set(l)), [l]), w = t((e) => {
|
|
674
|
+
let t = (Array.isArray(e) ? e : []).map((e) => L(e, s)).filter((e) => !(o?.(e) ?? !1));
|
|
344
675
|
d(new Set(t));
|
|
345
|
-
}, [s, o]),
|
|
346
|
-
d(new Set(
|
|
347
|
-
}, [
|
|
676
|
+
}, [s, o]), T = t(() => {
|
|
677
|
+
d(new Set(m));
|
|
678
|
+
}, [m]), E = t(() => {
|
|
348
679
|
d((e) => e.size === 0 ? e : /* @__PURE__ */ new Set());
|
|
349
|
-
}, []),
|
|
350
|
-
d((e) =>
|
|
351
|
-
}, [
|
|
680
|
+
}, []), D = t(() => {
|
|
681
|
+
d((e) => m.length > 0 && m.every((t) => e.has(t)) ? /* @__PURE__ */ new Set() : new Set(m));
|
|
682
|
+
}, [m]), O = t(() => {
|
|
352
683
|
d((e) => {
|
|
353
|
-
let t =
|
|
684
|
+
let t = m.filter((t) => !e.has(t));
|
|
354
685
|
return new Set(t);
|
|
355
686
|
});
|
|
356
|
-
}, [
|
|
687
|
+
}, [m]), k = t((e) => {
|
|
357
688
|
let t = Array.isArray(e) ? e : [];
|
|
358
689
|
d((e) => {
|
|
359
690
|
let n = new Set(e);
|
|
360
691
|
for (let e of t) {
|
|
361
|
-
let t =
|
|
692
|
+
let t = L(e, s);
|
|
362
693
|
(o?.(t) ?? !1) || n.add(t);
|
|
363
694
|
}
|
|
364
695
|
return n;
|
|
365
696
|
});
|
|
366
|
-
}, [s, o]),
|
|
697
|
+
}, [s, o]), A = t((e) => {
|
|
367
698
|
let t = Array.isArray(e) ? e : [];
|
|
368
699
|
d((e) => {
|
|
369
700
|
let n = new Set(e);
|
|
370
|
-
for (let e of t) n.delete(
|
|
701
|
+
for (let e of t) n.delete(L(e, s));
|
|
371
702
|
return n;
|
|
372
703
|
});
|
|
373
|
-
}, [s]),
|
|
374
|
-
let t = new Set((Array.isArray(e) ? e : []).map((e) =>
|
|
704
|
+
}, [s]), j = t((e) => {
|
|
705
|
+
let t = new Set((Array.isArray(e) ? e : []).map((e) => L(e, s)));
|
|
375
706
|
d((e) => {
|
|
376
707
|
let n = /* @__PURE__ */ new Set();
|
|
377
708
|
return e.forEach((e) => {
|
|
@@ -380,152 +711,418 @@ function p(e = {}) {
|
|
|
380
711
|
});
|
|
381
712
|
}, [s]);
|
|
382
713
|
return {
|
|
383
|
-
selectedIds:
|
|
714
|
+
selectedIds: g,
|
|
384
715
|
selectedCount: u.size,
|
|
385
|
-
selectedItems:
|
|
716
|
+
selectedItems: h,
|
|
386
717
|
isEmpty: u.size === 0,
|
|
387
|
-
isAllSelected:
|
|
388
|
-
isPartiallySelected:
|
|
389
|
-
select:
|
|
390
|
-
deselect:
|
|
391
|
-
toggle:
|
|
392
|
-
isSelected:
|
|
393
|
-
reset:
|
|
394
|
-
replaceSelection:
|
|
395
|
-
selectAll:
|
|
396
|
-
deselectAll:
|
|
397
|
-
toggleAll:
|
|
398
|
-
invertSelection:
|
|
399
|
-
selectMultiple:
|
|
400
|
-
deselectMultiple:
|
|
401
|
-
retainOnly:
|
|
718
|
+
isAllSelected: _,
|
|
719
|
+
isPartiallySelected: v,
|
|
720
|
+
select: y,
|
|
721
|
+
deselect: b,
|
|
722
|
+
toggle: x,
|
|
723
|
+
isSelected: S,
|
|
724
|
+
reset: C,
|
|
725
|
+
replaceSelection: w,
|
|
726
|
+
selectAll: T,
|
|
727
|
+
deselectAll: E,
|
|
728
|
+
toggleAll: D,
|
|
729
|
+
invertSelection: O,
|
|
730
|
+
selectMultiple: k,
|
|
731
|
+
deselectMultiple: A,
|
|
732
|
+
retainOnly: j
|
|
402
733
|
};
|
|
403
734
|
}
|
|
404
735
|
//#endregion
|
|
736
|
+
//#region src/state/useOrder/utils.ts
|
|
737
|
+
function De(e, t) {
|
|
738
|
+
return e < 0 ? t + e : e;
|
|
739
|
+
}
|
|
740
|
+
//#endregion
|
|
741
|
+
//#region src/state/useOrder/validation.ts
|
|
742
|
+
var R = globalThis.process?.env?.NODE_ENV !== "production";
|
|
743
|
+
function z(e, t, n) {
|
|
744
|
+
if (typeof e == "number") {
|
|
745
|
+
if (b(e)) return !0;
|
|
746
|
+
if (R) throw console.warn(`[useOrder] ${n}: index must be an integer, received: ${e}.`), Error(`[useOrder] ${n}: index must be an integer, received: ${e}.`);
|
|
747
|
+
return !1;
|
|
748
|
+
}
|
|
749
|
+
if (!t) {
|
|
750
|
+
if (R) throw console.warn(`[useOrder] ${n}: received an item instead of a numeric index, but no "field" option is configured to resolve it.`), Error(`[useOrder] ${n}: received an item instead of a numeric index, but no "field" option is configured to resolve it.`);
|
|
751
|
+
return !1;
|
|
752
|
+
}
|
|
753
|
+
return !0;
|
|
754
|
+
}
|
|
755
|
+
function B(t, n, r, i, a, o) {
|
|
756
|
+
let s = n.length;
|
|
757
|
+
if (typeof t == "number") {
|
|
758
|
+
let e = De(t, s);
|
|
759
|
+
if (e < 0 || e >= s) {
|
|
760
|
+
R && a && console.warn(`[useOrder] ${i}: index ${t} is out of bounds for an array of length ${s}. Call ignored.`);
|
|
761
|
+
return;
|
|
762
|
+
}
|
|
763
|
+
return e;
|
|
764
|
+
}
|
|
765
|
+
let c = e(t, r);
|
|
766
|
+
if (c === void 0) {
|
|
767
|
+
R && a && console.warn(`[useOrder] ${i}: could not resolve an id from the given item using field "${r}". Call ignored.`);
|
|
768
|
+
return;
|
|
769
|
+
}
|
|
770
|
+
if (o) {
|
|
771
|
+
let e = o.get(c);
|
|
772
|
+
return e === void 0 && R && a && console.warn(`[useOrder] ${i}: no item with a matching id was found in orderedItems. Call ignored.`), e;
|
|
773
|
+
}
|
|
774
|
+
let l = n.findIndex((t) => e(t, r) === c);
|
|
775
|
+
if (l === -1) {
|
|
776
|
+
R && a && console.warn(`[useOrder] ${i}: no item with a matching id was found in orderedItems. Call ignored.`);
|
|
777
|
+
return;
|
|
778
|
+
}
|
|
779
|
+
return l;
|
|
780
|
+
}
|
|
781
|
+
//#endregion
|
|
405
782
|
//#region src/state/useOrder/useOrder.ts
|
|
406
|
-
function
|
|
407
|
-
let
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
});
|
|
413
|
-
}, [
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
783
|
+
function Oe(n = [], o) {
|
|
784
|
+
let { isDisabled: s, field: c } = o ?? {}, l = r(() => Array.isArray(n) ? n : [], [n]), u = i(l), [d, f] = a(() => l), p = r(() => {
|
|
785
|
+
if (!c) return;
|
|
786
|
+
let t = /* @__PURE__ */ new Map();
|
|
787
|
+
return d.forEach((n, r) => {
|
|
788
|
+
t.set(e(n, c), r);
|
|
789
|
+
}), t;
|
|
790
|
+
}, [d, c]);
|
|
791
|
+
return {
|
|
792
|
+
orderedItems: d,
|
|
793
|
+
movePrevious: t((e) => {
|
|
794
|
+
z(e, c, "movePrevious") && f((t) => {
|
|
795
|
+
let n = B(e, t, c, "movePrevious", !0);
|
|
796
|
+
if (n === void 0 || n === 0) return t;
|
|
797
|
+
let r = n - 1;
|
|
798
|
+
if (s?.(t[n], n) || s?.(t[r], r)) return t;
|
|
799
|
+
let i = [...t];
|
|
800
|
+
return [i[n], i[r]] = [i[r], i[n]], i;
|
|
801
|
+
});
|
|
802
|
+
}, [s, c]),
|
|
803
|
+
moveNext: t((e) => {
|
|
804
|
+
z(e, c, "moveNext") && f((t) => {
|
|
805
|
+
let n = B(e, t, c, "moveNext", !0);
|
|
806
|
+
if (n === void 0 || n === t.length - 1) return t;
|
|
807
|
+
let r = n + 1;
|
|
808
|
+
if (s?.(t[n], n) || s?.(t[r], r)) return t;
|
|
809
|
+
let i = [...t];
|
|
810
|
+
return [i[n], i[r]] = [i[r], i[n]], i;
|
|
811
|
+
});
|
|
812
|
+
}, [s, c]),
|
|
813
|
+
canMovePrevious: t((e) => {
|
|
814
|
+
if (!z(e, c, "canMovePrevious")) return !1;
|
|
815
|
+
let t = B(e, d, c, "canMovePrevious", !1, p);
|
|
816
|
+
if (t === void 0 || t === 0) return !1;
|
|
817
|
+
let n = t - 1;
|
|
818
|
+
return !(s?.(d[t], t) || s?.(d[n], n));
|
|
819
|
+
}, [
|
|
820
|
+
d,
|
|
821
|
+
s,
|
|
822
|
+
c,
|
|
823
|
+
p
|
|
824
|
+
]),
|
|
825
|
+
canMoveNext: t((e) => {
|
|
826
|
+
if (!z(e, c, "canMoveNext")) return !1;
|
|
827
|
+
let t = B(e, d, c, "canMoveNext", !1, p);
|
|
828
|
+
if (t === void 0 || t === d.length - 1) return !1;
|
|
829
|
+
let n = t + 1;
|
|
830
|
+
return !(s?.(d[t], t) || s?.(d[n], n));
|
|
831
|
+
}, [
|
|
832
|
+
d,
|
|
833
|
+
s,
|
|
834
|
+
c,
|
|
835
|
+
p
|
|
836
|
+
]),
|
|
837
|
+
moveToStart: t((e) => {
|
|
838
|
+
z(e, c, "moveToStart") && f((t) => {
|
|
839
|
+
let n = B(e, t, c, "moveToStart", !0);
|
|
840
|
+
if (n === void 0 || n === 0 || s?.(t[n], n)) return t;
|
|
841
|
+
let r = [...t], [i] = r.splice(n, 1);
|
|
842
|
+
return r.unshift(i), r;
|
|
843
|
+
});
|
|
844
|
+
}, [s, c]),
|
|
845
|
+
moveToEnd: t((e) => {
|
|
846
|
+
z(e, c, "moveToEnd") && f((t) => {
|
|
847
|
+
let n = B(e, t, c, "moveToEnd", !0);
|
|
848
|
+
if (n === void 0 || n === t.length - 1 || s?.(t[n], n)) return t;
|
|
849
|
+
let r = [...t], [i] = r.splice(n, 1);
|
|
850
|
+
return r.push(i), r;
|
|
851
|
+
});
|
|
852
|
+
}, [s, c]),
|
|
853
|
+
move: t((e, t) => {
|
|
854
|
+
!z(e, c, "move(from)") || !z(t, c, "move(to)") || f((n) => {
|
|
855
|
+
let r = B(e, n, c, "move(from)", !0), i = B(t, n, c, "move(to)", !0);
|
|
856
|
+
if (r === void 0 || i === void 0 || r === i || s?.(n[r], r)) return n;
|
|
857
|
+
let a = [...n], [o] = a.splice(r, 1);
|
|
858
|
+
return a.splice(i, 0, o), a;
|
|
859
|
+
});
|
|
860
|
+
}, [s, c]),
|
|
861
|
+
swap: t((e, t) => {
|
|
862
|
+
!z(e, c, "swap(a)") || !z(t, c, "swap(b)") || f((n) => {
|
|
863
|
+
let r = B(e, n, c, "swap(a)", !0), i = B(t, n, c, "swap(b)", !0);
|
|
864
|
+
if (r === void 0 || i === void 0 || r === i || s?.(n[r], r) || s?.(n[i], i)) return n;
|
|
865
|
+
let a = [...n];
|
|
866
|
+
return [a[r], a[i]] = [a[i], a[r]], a;
|
|
867
|
+
});
|
|
868
|
+
}, [s, c]),
|
|
869
|
+
resetOrder: t(() => {
|
|
870
|
+
f(u.current);
|
|
871
|
+
}, []),
|
|
872
|
+
replaceOrder: t((e) => {
|
|
873
|
+
f(Array.isArray(e) ? e : []);
|
|
874
|
+
}, [])
|
|
875
|
+
};
|
|
876
|
+
}
|
|
877
|
+
//#endregion
|
|
878
|
+
//#region src/state/usePagination/usePagination.ts
|
|
879
|
+
var V = globalThis.process?.env?.NODE_ENV !== "production";
|
|
880
|
+
function ke(e = [], n = 10, o = 1) {
|
|
881
|
+
let s = r(() => Array.isArray(e) ? e : [], [e]), [c, l] = a(() => {
|
|
882
|
+
if (C(n)) return n;
|
|
883
|
+
if (V) throw console.warn(`[usePagination] initialPageSize must be a positive integer, received: ${n}. Falling back to 10.`), Error(`[usePagination] initialPageSize must be a positive integer, received: ${n}.`);
|
|
884
|
+
return 10;
|
|
885
|
+
}), [u, d] = a(() => {
|
|
886
|
+
if (C(o)) return o - 1;
|
|
887
|
+
if (V) throw console.warn(`[usePagination] initialPageNumber must be a positive integer, received: ${o}. Falling back to 1.`), Error(`[usePagination] initialPageNumber must be a positive integer, received: ${o}.`);
|
|
888
|
+
return 0;
|
|
889
|
+
}), f = i(c), p = i(u), m = s.length, h = Math.max(1, Math.ceil(m / Math.max(1, c))), g = Math.min(Math.max(0, u), h - 1), _ = r(() => {
|
|
890
|
+
if (C(c)) return s.slice(g * c, (g + 1) * c);
|
|
891
|
+
if (V) throw console.warn(`[usePagination] internal invariant violated: pageSize should always be a valid positive integer here, received: ${c}.`), Error(`[usePagination] internal invariant violated: pageSize should always be a valid positive integer here, received: ${c}.`);
|
|
892
|
+
return [];
|
|
893
|
+
}, [
|
|
894
|
+
g,
|
|
895
|
+
c,
|
|
896
|
+
s
|
|
897
|
+
]), v = g > 0, y = g < h - 1, b = m === 0 ? 0 : g * c + 1, x = m === 0 ? 0 : Math.min((g + 1) * c, m), S = t(() => {
|
|
898
|
+
d((e) => {
|
|
899
|
+
let t = Math.min(Math.max(0, e), h - 1);
|
|
900
|
+
return t < h - 1 ? t + 1 : t;
|
|
436
901
|
});
|
|
437
|
-
}, []),
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
return [r[e], r[t]] = [r[t], r[e]], r;
|
|
902
|
+
}, [h]), w = t(() => {
|
|
903
|
+
d((e) => {
|
|
904
|
+
let t = Math.min(Math.max(0, e), h - 1);
|
|
905
|
+
return t > 0 ? t - 1 : t;
|
|
442
906
|
});
|
|
443
|
-
}, []),
|
|
444
|
-
|
|
907
|
+
}, [h]), T = t(() => {
|
|
908
|
+
d(0);
|
|
909
|
+
}, []), E = t(() => {
|
|
910
|
+
d(h - 1);
|
|
911
|
+
}, [h]), D = t((e) => {
|
|
912
|
+
if (!C(e)) {
|
|
913
|
+
if (V) throw console.warn(`[usePagination] goToPage: newPageNumber must be a positive integer, received: ${e}.`), Error(`[usePagination] goToPage: newPageNumber must be a positive integer, received: ${e}.`);
|
|
914
|
+
return;
|
|
915
|
+
}
|
|
916
|
+
d(Math.min(e - 1, h - 1));
|
|
917
|
+
}, [h]), O = t((e) => {
|
|
918
|
+
if (!C(e)) {
|
|
919
|
+
if (V) throw console.warn(`[usePagination] changePageSize: newPageSize must be a positive integer, received: ${e}.`), Error(`[usePagination] changePageSize: newPageSize must be a positive integer, received: ${e}.`);
|
|
920
|
+
return;
|
|
921
|
+
}
|
|
922
|
+
l(e);
|
|
923
|
+
}, []), k = t(() => {
|
|
924
|
+
d(p.current);
|
|
925
|
+
}, []), A = t(() => {
|
|
926
|
+
l(f.current);
|
|
927
|
+
}, []), j = t(() => {
|
|
928
|
+
l(f.current), d(p.current);
|
|
445
929
|
}, []);
|
|
446
930
|
return {
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
931
|
+
pageItems: _,
|
|
932
|
+
pageNumber: g + 1,
|
|
933
|
+
pageSize: c,
|
|
934
|
+
totalPages: h,
|
|
935
|
+
totalCount: m,
|
|
936
|
+
startIndex: b,
|
|
937
|
+
endIndex: x,
|
|
938
|
+
canPreviousPage: v,
|
|
939
|
+
canNextPage: y,
|
|
940
|
+
nextPage: S,
|
|
941
|
+
previousPage: w,
|
|
942
|
+
goToFirstPage: T,
|
|
943
|
+
goToLastPage: E,
|
|
944
|
+
goToPage: D,
|
|
945
|
+
changePageSize: O,
|
|
946
|
+
resetPageNumber: k,
|
|
947
|
+
resetPageSize: A,
|
|
948
|
+
resetPagination: j
|
|
460
949
|
};
|
|
461
950
|
}
|
|
462
951
|
//#endregion
|
|
463
|
-
//#region src/state/
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
952
|
+
//#region src/state/usePin/validation.ts
|
|
953
|
+
var H = globalThis.process?.env?.NODE_ENV !== "production";
|
|
954
|
+
function U(e, t, n) {
|
|
955
|
+
if (w(e)) return !0;
|
|
956
|
+
if (!t) {
|
|
957
|
+
if (H) throw console.warn(`[usePin] ${n}: received an object item but no "field" option is configured to resolve its id. Every such item would collapse onto the same pinned id.`), Error(`[usePin] ${n}: received an object item but no "field" option is configured to resolve its id.`);
|
|
958
|
+
return !1;
|
|
959
|
+
}
|
|
960
|
+
return !0;
|
|
961
|
+
}
|
|
962
|
+
function W(t, n, r) {
|
|
963
|
+
if (w(t)) return t;
|
|
964
|
+
if (!n) return;
|
|
965
|
+
let i = e(t, n);
|
|
966
|
+
return i === void 0 && H && console.warn(`[usePin] ${r}: could not resolve an id from the given item using field "${n}".`), i;
|
|
967
|
+
}
|
|
968
|
+
function Ae(e, t) {
|
|
969
|
+
if (e === void 0) return 2 ** 53 - 1;
|
|
970
|
+
if (C(e)) return e;
|
|
971
|
+
if (H) throw console.warn(`[usePin] ${t}: maxPins must be a positive integer, received: ${e}.`), Error(`[usePin] ${t}: maxPins must be a positive integer, received: ${e}.`);
|
|
972
|
+
return 2 ** 53 - 1;
|
|
973
|
+
}
|
|
974
|
+
function je(e) {
|
|
975
|
+
H && console.warn(`[usePin] ${e}: pin limit reached; call ignored. Check "canPin" before calling, or raise "maxPins".`);
|
|
976
|
+
}
|
|
977
|
+
function Me(e, t, n) {
|
|
978
|
+
H && console.warn(`[usePin] ${e}: ${t} pinned ids exceeds maxPins (${n}); truncating to the first ${n}.`);
|
|
979
|
+
}
|
|
980
|
+
//#endregion
|
|
981
|
+
//#region src/state/usePin/usePin.ts
|
|
982
|
+
function Ne(e = {}) {
|
|
983
|
+
let n = e, o = n.field, s = r(() => Array.isArray(n.items) ? n.items : [], [n.items]), c = r(() => Array.isArray(n.initialPinnedIds) ? n.initialPinnedIds : [], [n.initialPinnedIds]), l = i(c), [u, d] = a(() => Ae(n.maxPins, "usePin")), f = i(u), [p, m] = a(() => {
|
|
984
|
+
let e = [...new Set(c)];
|
|
985
|
+
return e.length > u && Me("usePin", e.length, u), new Set(e.slice(0, u));
|
|
986
|
+
}), h = t((e) => {
|
|
987
|
+
U(e, o, "pin") && m((t) => {
|
|
988
|
+
let n = W(e, o, "pin");
|
|
989
|
+
if (n === void 0 || t.has(n)) return t;
|
|
990
|
+
if (t.size >= u) return je("pin"), t;
|
|
991
|
+
let r = new Set(t);
|
|
992
|
+
return r.add(n), r;
|
|
993
|
+
});
|
|
994
|
+
}, [o, u]), g = t((e) => {
|
|
995
|
+
U(e, o, "unpin") && m((t) => {
|
|
996
|
+
let n = W(e, o, "unpin");
|
|
997
|
+
if (n === void 0 || !t.has(n)) return t;
|
|
998
|
+
let r = new Set(t);
|
|
999
|
+
return r.delete(n), r;
|
|
1000
|
+
});
|
|
1001
|
+
}, [o]), _ = t((e) => {
|
|
1002
|
+
U(e, o, "togglePin") && m((t) => {
|
|
1003
|
+
let n = W(e, o, "togglePin");
|
|
1004
|
+
if (n === void 0) return t;
|
|
1005
|
+
if (t.has(n)) {
|
|
1006
|
+
let e = new Set(t);
|
|
1007
|
+
return e.delete(n), e;
|
|
497
1008
|
}
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
}
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
|
|
1009
|
+
if (t.size >= u) return je("togglePin"), t;
|
|
1010
|
+
let r = new Set(t);
|
|
1011
|
+
return r.add(n), r;
|
|
1012
|
+
});
|
|
1013
|
+
}, [o, u]), v = t((e) => {
|
|
1014
|
+
if (!U(e, o, "isPinned")) return !1;
|
|
1015
|
+
let t = W(e, o, "isPinned");
|
|
1016
|
+
return t !== void 0 && p.has(t);
|
|
1017
|
+
}, [p, o]), y = t((e) => {
|
|
1018
|
+
if (!U(e, o, "canPin")) return !1;
|
|
1019
|
+
let t = W(e, o, "canPin");
|
|
1020
|
+
return t === void 0 ? !1 : p.has(t) || p.size < u;
|
|
1021
|
+
}, [
|
|
1022
|
+
p,
|
|
1023
|
+
o,
|
|
1024
|
+
u
|
|
1025
|
+
]), b = t(() => {
|
|
1026
|
+
m((e) => e.size === 0 ? e : /* @__PURE__ */ new Set());
|
|
1027
|
+
}, []), x = t(() => {
|
|
1028
|
+
m(new Set(l.current));
|
|
1029
|
+
}, []), S = t((e) => {
|
|
1030
|
+
let t = Array.isArray(e) ? e : [], n = [];
|
|
1031
|
+
for (let e of t) {
|
|
1032
|
+
if (!U(e, o, "replacePins")) continue;
|
|
1033
|
+
let t = W(e, o, "replacePins");
|
|
1034
|
+
t !== void 0 && n.push(t);
|
|
1035
|
+
}
|
|
1036
|
+
let r = [...new Set(n)];
|
|
1037
|
+
r.length > u && Me("replacePins", r.length, u), m(new Set(r.slice(0, u)));
|
|
1038
|
+
}, [o, u]), C = t((e) => {
|
|
1039
|
+
let t = Array.isArray(e) ? e : s;
|
|
1040
|
+
m((e) => {
|
|
1041
|
+
let n = new Set(e);
|
|
1042
|
+
for (let e of t) {
|
|
1043
|
+
if (!U(e, o, "pinAll")) continue;
|
|
1044
|
+
let t = W(e, o, "pinAll");
|
|
1045
|
+
if (t !== void 0) {
|
|
1046
|
+
if (n.size >= u && !n.has(t)) {
|
|
1047
|
+
je("pinAll");
|
|
1048
|
+
break;
|
|
1049
|
+
}
|
|
1050
|
+
n.add(t);
|
|
1051
|
+
}
|
|
1052
|
+
}
|
|
1053
|
+
return n;
|
|
1054
|
+
});
|
|
1055
|
+
}, [
|
|
1056
|
+
o,
|
|
1057
|
+
u,
|
|
1058
|
+
s
|
|
1059
|
+
]), w = t((e) => {
|
|
1060
|
+
if (e === void 0) {
|
|
1061
|
+
m((e) => e.size === 0 ? e : /* @__PURE__ */ new Set());
|
|
1062
|
+
return;
|
|
1063
|
+
}
|
|
1064
|
+
let t = Array.isArray(e) ? e : [];
|
|
1065
|
+
m((e) => {
|
|
1066
|
+
let n = new Set(e);
|
|
1067
|
+
for (let e of t) {
|
|
1068
|
+
if (!U(e, o, "unpinAll")) continue;
|
|
1069
|
+
let t = W(e, o, "unpinAll");
|
|
1070
|
+
t !== void 0 && n.delete(t);
|
|
1071
|
+
}
|
|
1072
|
+
return n;
|
|
1073
|
+
});
|
|
1074
|
+
}, [o]), T = t((e) => {
|
|
1075
|
+
d(Ae(e, "changeMaxPins"));
|
|
1076
|
+
}, []), E = t(() => {
|
|
1077
|
+
d(f.current);
|
|
1078
|
+
}, []), D = r(() => [...p], [p]), { pinnedItems: O, unpinnedItems: k } = r(() => {
|
|
1079
|
+
let e = [], t = [];
|
|
1080
|
+
for (let n of s) {
|
|
1081
|
+
let r = W(n, o, "pinnedItems");
|
|
1082
|
+
r !== void 0 && p.has(r) ? e.push(n) : t.push(n);
|
|
1083
|
+
}
|
|
1084
|
+
return {
|
|
1085
|
+
pinnedItems: e,
|
|
1086
|
+
unpinnedItems: t
|
|
1087
|
+
};
|
|
1088
|
+
}, [
|
|
1089
|
+
s,
|
|
1090
|
+
o,
|
|
1091
|
+
p
|
|
1092
|
+
]);
|
|
1093
|
+
return {
|
|
1094
|
+
pinnedIds: D,
|
|
1095
|
+
pinnedItems: O,
|
|
1096
|
+
unpinnedItems: k,
|
|
1097
|
+
pinnedCount: p.size,
|
|
1098
|
+
hasPins: p.size > 0,
|
|
1099
|
+
isAtMaxLimit: p.size >= u,
|
|
1100
|
+
maxPins: u,
|
|
1101
|
+
pin: h,
|
|
1102
|
+
unpin: g,
|
|
1103
|
+
togglePin: _,
|
|
1104
|
+
isPinned: v,
|
|
1105
|
+
canPin: y,
|
|
1106
|
+
clearPins: b,
|
|
1107
|
+
resetPins: x,
|
|
1108
|
+
replacePins: S,
|
|
1109
|
+
pinAll: C,
|
|
1110
|
+
unpinAll: w,
|
|
1111
|
+
changeMaxPins: T,
|
|
1112
|
+
resetMaxPins: E
|
|
516
1113
|
};
|
|
517
1114
|
}
|
|
518
1115
|
//#endregion
|
|
519
1116
|
//#region src/state/useSingleSelection/useSingleSelection.ts
|
|
520
|
-
function
|
|
521
|
-
let { defaultSelectedId: n, isDisabled: r } = e, [
|
|
1117
|
+
function Pe(e = {}) {
|
|
1118
|
+
let { defaultSelectedId: n, isDisabled: r } = e, [i, o] = a(n), s = t((e) => {
|
|
522
1119
|
r?.(e) || o(e);
|
|
523
1120
|
}, [r]), c = t(() => o(void 0), []), l = t((e) => {
|
|
524
1121
|
r?.(e) || o((t) => t === e ? void 0 : e);
|
|
525
|
-
}, [r]), u = t((e) =>
|
|
1122
|
+
}, [r]), u = t((e) => i === e, [i]), d = t(() => o(n), [n]);
|
|
526
1123
|
return {
|
|
527
|
-
selectedId:
|
|
528
|
-
hasSelection:
|
|
1124
|
+
selectedId: i,
|
|
1125
|
+
hasSelection: i !== void 0,
|
|
529
1126
|
select: s,
|
|
530
1127
|
deselect: c,
|
|
531
1128
|
toggle: l,
|
|
@@ -534,110 +1131,137 @@ function g(e = {}) {
|
|
|
534
1131
|
};
|
|
535
1132
|
}
|
|
536
1133
|
//#endregion
|
|
537
|
-
//#region src/state/useSort/
|
|
538
|
-
function
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
return
|
|
543
|
-
}
|
|
544
|
-
function
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
return
|
|
549
|
-
}
|
|
550
|
-
function
|
|
551
|
-
|
|
552
|
-
if (o !== null) return o;
|
|
553
|
-
let s = String(e), c = String(t);
|
|
554
|
-
return s.localeCompare(c, void 0, { sensitivity: a ? "variant" : "base" });
|
|
555
|
-
}
|
|
556
|
-
function b(e, t, n = {}) {
|
|
557
|
-
let { desc: r = !1, sortUndefined: i, caseSensitive: a = !1 } = n, o = w(e, t, i, r);
|
|
558
|
-
if (o !== null) return o;
|
|
559
|
-
let s = String(e), c = String(t);
|
|
560
|
-
return s.localeCompare(c, void 0, {
|
|
1134
|
+
//#region src/state/useSort/comparators.ts
|
|
1135
|
+
function Fe(e, t) {
|
|
1136
|
+
return e === t ? 0 : e < t ? -1 : 1;
|
|
1137
|
+
}
|
|
1138
|
+
function Ie(e, t) {
|
|
1139
|
+
return e === t ? 0 : e ? 1 : -1;
|
|
1140
|
+
}
|
|
1141
|
+
function Le(e, t, n = "day") {
|
|
1142
|
+
return n === "instant" ? e.getTime() - t.getTime() : _(e).getTime() - _(t).getTime();
|
|
1143
|
+
}
|
|
1144
|
+
function Re(e, t, n = !1) {
|
|
1145
|
+
return e.localeCompare(t, void 0, { sensitivity: n ? "variant" : "base" });
|
|
1146
|
+
}
|
|
1147
|
+
function ze(e, t, n = !1) {
|
|
1148
|
+
return e.localeCompare(t, void 0, {
|
|
561
1149
|
numeric: !0,
|
|
562
|
-
sensitivity:
|
|
1150
|
+
sensitivity: n ? "variant" : "base"
|
|
563
1151
|
});
|
|
564
1152
|
}
|
|
565
|
-
function
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
return (
|
|
570
|
-
}
|
|
571
|
-
function
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
1153
|
+
function Be(e, t) {
|
|
1154
|
+
return e < t ? -1 : +(e > t);
|
|
1155
|
+
}
|
|
1156
|
+
function Ve(e, t, n) {
|
|
1157
|
+
return n(e, t);
|
|
1158
|
+
}
|
|
1159
|
+
function He(e, t = "last", n) {
|
|
1160
|
+
if (t === "first") return e ? -1 : 1;
|
|
1161
|
+
if (t === "last") return e ? 1 : -1;
|
|
1162
|
+
let r = t === -1 ? e ? -1 : 1 : e ? 1 : -1;
|
|
1163
|
+
return n ? -r : r;
|
|
1164
|
+
}
|
|
1165
|
+
function G(e, t, n, r) {
|
|
1166
|
+
return (i, a) => {
|
|
1167
|
+
let o = e(i), s = e(a);
|
|
1168
|
+
if (o === null || s === null) return o === null && s === null ? 0 : He(o === null, n, r);
|
|
1169
|
+
let c = t(o, s);
|
|
1170
|
+
return c === 0 ? 0 : r ? -c : c;
|
|
1171
|
+
};
|
|
1172
|
+
}
|
|
1173
|
+
function Ue(e, t) {
|
|
1174
|
+
let { type: n, sortUndefined: r } = e;
|
|
1175
|
+
switch (n) {
|
|
1176
|
+
case "numeric": return G(k, Fe, r, t);
|
|
1177
|
+
case "boolean": return G(E, Ie, r, t);
|
|
1178
|
+
case "date": {
|
|
1179
|
+
let n = e.dateGranularity ?? "day";
|
|
1180
|
+
return G(D, (e, t) => Le(e, t, n), r, t);
|
|
1181
|
+
}
|
|
1182
|
+
case "alphabetical": {
|
|
1183
|
+
let n = e.caseSensitive ?? !1;
|
|
1184
|
+
return G(O, (e, t) => Re(e, t, n), r, t);
|
|
1185
|
+
}
|
|
1186
|
+
case "alphanumeric": {
|
|
1187
|
+
let n = e.caseSensitive ?? !1;
|
|
1188
|
+
return G(O, (e, t) => ze(e, t, n), r, t);
|
|
1189
|
+
}
|
|
1190
|
+
case "basic": return G((e) => S(e) ? null : e, Be, r, t);
|
|
1191
|
+
case "custom": {
|
|
1192
|
+
let { compare: n } = e;
|
|
1193
|
+
return typeof n == "function" ? G((e) => S(e) ? null : e, (e, t) => Ve(e, t, n), r, t) : void 0;
|
|
1194
|
+
}
|
|
1195
|
+
default: return;
|
|
588
1196
|
}
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
1197
|
+
}
|
|
1198
|
+
//#endregion
|
|
1199
|
+
//#region src/state/useSort/validation.ts
|
|
1200
|
+
var K = globalThis.process?.env?.NODE_ENV !== "production";
|
|
1201
|
+
function We(e, t) {
|
|
1202
|
+
if (!K) return;
|
|
1203
|
+
let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
|
|
1204
|
+
for (let t of e) n.has(t.id) && r.add(t.id), n.add(t.id);
|
|
1205
|
+
r.size > 0 && console.warn(`[useSort] ${t} contains duplicate sort ids: ${[...r].join(", ")}. Lookups by id (getSort, getSortDirection, getNextSortingOrder, getSortIndex, updateSortConfig) will only ever affect the first match.`);
|
|
1206
|
+
}
|
|
1207
|
+
function q(e) {
|
|
1208
|
+
return e.type === "custom" ? typeof e.compare == "function" : e.type === "date" ? e.dateGranularity === void 0 || e.dateGranularity === "day" || e.dateGranularity === "instant" : e.type === "alphabetical" || e.type === "alphanumeric" ? e.caseSensitive === void 0 || typeof e.caseSensitive == "boolean" : !0;
|
|
1209
|
+
}
|
|
1210
|
+
function Ge(e, t, n, r) {
|
|
1211
|
+
let i = e.findIndex((e) => e.id === t), a = e[i];
|
|
1212
|
+
if (i === -1 || !a) {
|
|
1213
|
+
if (K) throw console.warn(`[useSort] ${r}: no sort found with id "${t}".`), Error(`[useSort] ${r}: no sort found with id "${t}".`);
|
|
1214
|
+
return e;
|
|
592
1215
|
}
|
|
593
|
-
|
|
1216
|
+
let o = {
|
|
1217
|
+
...a,
|
|
1218
|
+
...n
|
|
1219
|
+
};
|
|
1220
|
+
if (!q(o)) {
|
|
1221
|
+
if (K) throw console.warn(`[useSort] ${r}: update to sort "${t}" would produce an invalid config for type "${o.type}".`, {
|
|
1222
|
+
attempted: n,
|
|
1223
|
+
current: a
|
|
1224
|
+
}), Error(`[useSort] ${r}: update to sort "${t}" would produce an invalid config for type "${o.type}".`);
|
|
1225
|
+
return e;
|
|
1226
|
+
}
|
|
1227
|
+
let s = [...e];
|
|
1228
|
+
return s[i] = o, s;
|
|
594
1229
|
}
|
|
595
1230
|
//#endregion
|
|
596
1231
|
//#region src/state/useSort/useSort.ts
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
|
|
608
|
-
|
|
609
|
-
|
|
610
|
-
|
|
611
|
-
|
|
612
|
-
|
|
613
|
-
|
|
614
|
-
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
d = _(l, u, i);
|
|
618
|
-
break;
|
|
619
|
-
case "date":
|
|
620
|
-
d = x(l, u, i);
|
|
621
|
-
break;
|
|
622
|
-
case "basic":
|
|
623
|
-
d = S(l, u, i);
|
|
624
|
-
break;
|
|
625
|
-
case "custom":
|
|
626
|
-
d = C(l, u, i);
|
|
627
|
-
break;
|
|
628
|
-
default: d = S(l, u, i);
|
|
629
|
-
}
|
|
630
|
-
if (d !== 0) return d * (o === s ? 1 : -1);
|
|
1232
|
+
var J = globalThis.process?.env?.NODE_ENV !== "production";
|
|
1233
|
+
function Ke(o = [], s = [], c) {
|
|
1234
|
+
let l = r(() => Array.isArray(o) ? o : [], [o]), u = r(() => Array.isArray(s) ? s : [], [s]), d = i(u), [f, p] = a(() => (We(u, "initialSorts"), u)), m = n(f), h = c?.defer ? m : f, g = r(() => {
|
|
1235
|
+
if (h.length === 0) return l;
|
|
1236
|
+
let t = [];
|
|
1237
|
+
for (let e of h) {
|
|
1238
|
+
let { id: n, type: r, field: i, desc: a = !1, invertSorting: o = !1 } = e, s = (i ?? n).split("."), c = Ue(e, a !== o);
|
|
1239
|
+
if (!c) {
|
|
1240
|
+
if (J) throw console.warn(`[useSort] sort "${n}" could not be resolved (type "${r}" is unknown, or a "custom" sort is missing its "compare" function). Skipping this sort key.`), Error(`[useSort] sort "${n}" could not be resolved (type "${r}" is unknown, or a "custom" sort is missing its "compare" function).`);
|
|
1241
|
+
continue;
|
|
1242
|
+
}
|
|
1243
|
+
t.push({
|
|
1244
|
+
pathArray: s,
|
|
1245
|
+
compareValues: c
|
|
1246
|
+
});
|
|
1247
|
+
}
|
|
1248
|
+
return t.length === 0 ? l : [...l].sort((n, r) => {
|
|
1249
|
+
for (let { pathArray: i, compareValues: a } of t) {
|
|
1250
|
+
let t = a(e(n, i), e(r, i));
|
|
1251
|
+
if (t !== 0) return t;
|
|
631
1252
|
}
|
|
632
1253
|
return 0;
|
|
633
1254
|
});
|
|
634
|
-
}, [
|
|
635
|
-
|
|
636
|
-
}, []),
|
|
637
|
-
|
|
638
|
-
}, []),
|
|
639
|
-
let
|
|
640
|
-
|
|
1255
|
+
}, [l, h]), _ = f.length, v = _ > 0, y = t((e) => {
|
|
1256
|
+
p((t) => t.some((t) => t.id === e.id) ? t.map((t) => t.id === e.id ? e : t) : [...t, e]);
|
|
1257
|
+
}, []), b = t((e) => {
|
|
1258
|
+
p((t) => Array.isArray(e) ? t.filter((t) => !e.includes(t.id)) : t.filter((t) => t.id !== e));
|
|
1259
|
+
}, []), x = t(() => p([]), []), S = t(() => p(d.current), []), C = t((e) => {
|
|
1260
|
+
let t = Array.isArray(e) ? e : [];
|
|
1261
|
+
We(t, "replaceSorts"), p(t);
|
|
1262
|
+
}, []), w = t((e, t, n) => {
|
|
1263
|
+
let { multi: r = !1, ...i } = n ?? {};
|
|
1264
|
+
p((n) => {
|
|
641
1265
|
let a = n.find((t) => t.id === e);
|
|
642
1266
|
if (!a) {
|
|
643
1267
|
let a = {
|
|
@@ -646,6 +1270,10 @@ function T(a = [], o = []) {
|
|
|
646
1270
|
...i,
|
|
647
1271
|
desc: !1
|
|
648
1272
|
};
|
|
1273
|
+
if (!q(a)) {
|
|
1274
|
+
if (J) throw console.warn(`[useSort] toggleSort: constructed an invalid sort config for id "${e}" (type "${t}").`), Error(`[useSort] toggleSort: constructed an invalid sort config for id "${e}" (type "${t}").`);
|
|
1275
|
+
return n;
|
|
1276
|
+
}
|
|
649
1277
|
return r ? [...n, a] : [a];
|
|
650
1278
|
}
|
|
651
1279
|
if (!a.desc) {
|
|
@@ -654,6 +1282,10 @@ function T(a = [], o = []) {
|
|
|
654
1282
|
...i,
|
|
655
1283
|
desc: !0
|
|
656
1284
|
};
|
|
1285
|
+
if (!q(t)) {
|
|
1286
|
+
if (J) throw console.warn(`[useSort] toggleSort: update would produce an invalid sort config for id "${e}".`), Error(`[useSort] toggleSort: update would produce an invalid sort config for id "${e}".`);
|
|
1287
|
+
return n;
|
|
1288
|
+
}
|
|
657
1289
|
return r ? n.map((n) => n.id === e ? t : n) : [t];
|
|
658
1290
|
}
|
|
659
1291
|
if (a.disableSortRemoval || i.disableSortRemoval) {
|
|
@@ -662,48 +1294,67 @@ function T(a = [], o = []) {
|
|
|
662
1294
|
...i,
|
|
663
1295
|
desc: !1
|
|
664
1296
|
};
|
|
1297
|
+
if (!q(t)) {
|
|
1298
|
+
if (J) throw console.warn(`[useSort] toggleSort: update would produce an invalid sort config for id "${e}".`), Error(`[useSort] toggleSort: update would produce an invalid sort config for id "${e}".`);
|
|
1299
|
+
return n;
|
|
1300
|
+
}
|
|
665
1301
|
return r ? n.map((n) => n.id === e ? t : n) : [t];
|
|
666
1302
|
}
|
|
667
1303
|
return r ? n.filter((t) => t.id !== e) : [];
|
|
668
1304
|
});
|
|
669
|
-
}, [])
|
|
1305
|
+
}, []), T = t((e, t) => {
|
|
1306
|
+
p((n) => Ge(n, e, t, "updateSortConfig"));
|
|
1307
|
+
}, []), E = r(() => {
|
|
1308
|
+
let e = /* @__PURE__ */ new Map();
|
|
1309
|
+
for (let t of f) e.has(t.id) || e.set(t.id, t);
|
|
1310
|
+
return e;
|
|
1311
|
+
}, [f]), D = r(() => {
|
|
1312
|
+
let e = /* @__PURE__ */ new Map();
|
|
1313
|
+
return f.forEach((t, n) => {
|
|
1314
|
+
e.has(t.id) || e.set(t.id, n);
|
|
1315
|
+
}), e;
|
|
1316
|
+
}, [f]);
|
|
670
1317
|
return {
|
|
671
|
-
sortedItems:
|
|
672
|
-
sorts:
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
|
|
1318
|
+
sortedItems: g,
|
|
1319
|
+
sorts: f,
|
|
1320
|
+
sortCount: _,
|
|
1321
|
+
hasSorts: v,
|
|
1322
|
+
upsertSorts: y,
|
|
1323
|
+
removeSort: b,
|
|
1324
|
+
clearSorts: x,
|
|
1325
|
+
resetSorts: S,
|
|
1326
|
+
replaceSorts: C,
|
|
1327
|
+
toggleSort: w,
|
|
1328
|
+
updateSortConfig: T,
|
|
1329
|
+
getSort: t((e) => E.get(e), [E]),
|
|
678
1330
|
getSortDirection: t((e) => {
|
|
679
|
-
let t =
|
|
1331
|
+
let t = E.get(e);
|
|
680
1332
|
return t ? t.desc ? "desc" : "asc" : void 0;
|
|
681
|
-
}, [
|
|
682
|
-
toggleSort: T,
|
|
1333
|
+
}, [E]),
|
|
683
1334
|
getNextSortingOrder: t((e) => {
|
|
684
|
-
let t =
|
|
1335
|
+
let t = E.get(e);
|
|
685
1336
|
return t ? t.desc ? t.disableSortRemoval ? "asc" : "none" : "desc" : "asc";
|
|
686
|
-
}, [
|
|
1337
|
+
}, [E]),
|
|
687
1338
|
getSortIndex: t((e) => {
|
|
688
|
-
let t =
|
|
689
|
-
return t ===
|
|
690
|
-
}, [
|
|
1339
|
+
let t = D.get(e);
|
|
1340
|
+
return t === void 0 ? void 0 : t + 1;
|
|
1341
|
+
}, [D])
|
|
691
1342
|
};
|
|
692
1343
|
}
|
|
693
1344
|
//#endregion
|
|
694
1345
|
//#region src/state/useTreeSelection/core.ts
|
|
695
|
-
function
|
|
1346
|
+
function qe(e, t) {
|
|
696
1347
|
let n;
|
|
697
1348
|
if (n = typeof t == "function" ? t(e) : e[t], typeof process < "u" && process.env.NODE_ENV !== "production" && n == null) throw console.warn("[resolveTreeItemId] Resolved id is", n, "— this usually means `field` does not point to a valid property on the item."), Error(`[resolveTreeItemId] Invalid id resolved: ${String(n)}`);
|
|
698
1349
|
return n;
|
|
699
1350
|
}
|
|
700
|
-
function
|
|
1351
|
+
function Je(e, t) {
|
|
701
1352
|
return typeof t == "function" ? t(e) : e[t];
|
|
702
1353
|
}
|
|
703
|
-
function
|
|
1354
|
+
function Ye(e, t, n) {
|
|
704
1355
|
let r = [], i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map();
|
|
705
1356
|
function o(e, s, c, l) {
|
|
706
|
-
let u =
|
|
1357
|
+
let u = qe(e, t);
|
|
707
1358
|
if (l.has(u)) {
|
|
708
1359
|
if (typeof process < "u" && process.env.NODE_ENV !== "production") throw console.warn("[useTreeSelection] Cycle detected: node", u, "is its own ancestor. This subtree is being skipped rather than recursed forever."), Error(`[useTreeSelection] Cycle detected: node ${u} is its own ancestor.`);
|
|
709
1360
|
return;
|
|
@@ -717,7 +1368,7 @@ function O(e, t, n) {
|
|
|
717
1368
|
r.push(d), i.set(u, d);
|
|
718
1369
|
let f = a.get(s);
|
|
719
1370
|
f ? f.push(u) : a.set(s, [u]);
|
|
720
|
-
let p =
|
|
1371
|
+
let p = Je(e, n);
|
|
721
1372
|
if (!p || p.length === 0) return;
|
|
722
1373
|
let m = new Set(l);
|
|
723
1374
|
m.add(u);
|
|
@@ -730,13 +1381,13 @@ function O(e, t, n) {
|
|
|
730
1381
|
childIdsByParentId: a
|
|
731
1382
|
};
|
|
732
1383
|
}
|
|
733
|
-
function
|
|
1384
|
+
function Y(e, t) {
|
|
734
1385
|
return !(t?.(e) ?? !1);
|
|
735
1386
|
}
|
|
736
|
-
function
|
|
737
|
-
return typeof e == "string" || typeof e == "number" ? e :
|
|
1387
|
+
function X(e, t) {
|
|
1388
|
+
return typeof e == "string" || typeof e == "number" ? e : qe(e, t);
|
|
738
1389
|
}
|
|
739
|
-
function
|
|
1390
|
+
function Z(e, t, n, r) {
|
|
740
1391
|
let i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
|
|
741
1392
|
function o(s) {
|
|
742
1393
|
let c = e.childIdsByParentId.get(s);
|
|
@@ -744,7 +1395,7 @@ function j(e, t, n, r) {
|
|
|
744
1395
|
let e = t.has(s) ? "selected" : "unselected";
|
|
745
1396
|
return e === "selected" && i.add(s), e;
|
|
746
1397
|
}
|
|
747
|
-
let l = c.filter((e) =>
|
|
1398
|
+
let l = c.filter((e) => Y(e, n));
|
|
748
1399
|
if (l.length === 0) {
|
|
749
1400
|
let e = t.has(s) ? "selected" : "unselected";
|
|
750
1401
|
return e === "selected" && i.add(s), e;
|
|
@@ -763,7 +1414,7 @@ function j(e, t, n, r) {
|
|
|
763
1414
|
indeterminateIds: a
|
|
764
1415
|
};
|
|
765
1416
|
}
|
|
766
|
-
function
|
|
1417
|
+
function Xe(e, t, n, r, i, a, o, s) {
|
|
767
1418
|
let c = new Set(t), l = new Set(n), u = [r];
|
|
768
1419
|
if (o) {
|
|
769
1420
|
let t = [r];
|
|
@@ -772,11 +1423,11 @@ function M(e, t, n, r, i, a, o, s) {
|
|
|
772
1423
|
if (r) for (let e of r) u.push(e), t.push(e);
|
|
773
1424
|
}
|
|
774
1425
|
}
|
|
775
|
-
for (let e of u) l.delete(e), !(i && !
|
|
1426
|
+
for (let e of u) l.delete(e), !(i && !Y(e, a)) && (i ? c.add(e) : c.delete(e));
|
|
776
1427
|
if (s) {
|
|
777
1428
|
let t = e.entryById.get(r)?.parentId;
|
|
778
1429
|
for (; t !== void 0;) {
|
|
779
|
-
let n = (e.childIdsByParentId.get(t) ?? []).filter((e) =>
|
|
1430
|
+
let n = (e.childIdsByParentId.get(t) ?? []).filter((e) => Y(e, a));
|
|
780
1431
|
if (n.length === 0) {
|
|
781
1432
|
t = e.entryById.get(t)?.parentId;
|
|
782
1433
|
continue;
|
|
@@ -794,7 +1445,7 @@ function M(e, t, n, r, i, a, o, s) {
|
|
|
794
1445
|
indeterminateIds: l
|
|
795
1446
|
};
|
|
796
1447
|
}
|
|
797
|
-
function
|
|
1448
|
+
function Ze(e, t, n, r, i, a, o, s) {
|
|
798
1449
|
let c = new Set(t), l = new Set(n), u = /* @__PURE__ */ new Set();
|
|
799
1450
|
for (let t of r) {
|
|
800
1451
|
let n = [t];
|
|
@@ -805,7 +1456,7 @@ function N(e, t, n, r, i, a, o, s) {
|
|
|
805
1456
|
if (i) for (let e of i) n.push(e), r.push(e);
|
|
806
1457
|
}
|
|
807
1458
|
}
|
|
808
|
-
for (let e of n) l.delete(e), !(i && !
|
|
1459
|
+
for (let e of n) l.delete(e), !(i && !Y(e, a)) && (i ? c.add(e) : c.delete(e));
|
|
809
1460
|
if (s) {
|
|
810
1461
|
let n = e.entryById.get(t)?.parentId;
|
|
811
1462
|
for (; n !== void 0;) u.add(n), n = e.entryById.get(n)?.parentId;
|
|
@@ -814,7 +1465,7 @@ function N(e, t, n, r, i, a, o, s) {
|
|
|
814
1465
|
if (u.size > 0) {
|
|
815
1466
|
let t = [...u].sort((t, n) => (e.entryById.get(n)?.depth ?? 0) - (e.entryById.get(t)?.depth ?? 0));
|
|
816
1467
|
for (let n of t) {
|
|
817
|
-
let t = (e.childIdsByParentId.get(n) ?? []).filter((e) =>
|
|
1468
|
+
let t = (e.childIdsByParentId.get(n) ?? []).filter((e) => Y(e, a));
|
|
818
1469
|
if (t.length === 0) continue;
|
|
819
1470
|
let r = !0, i = !1;
|
|
820
1471
|
for (let e of t) {
|
|
@@ -831,15 +1482,15 @@ function N(e, t, n, r, i, a, o, s) {
|
|
|
831
1482
|
}
|
|
832
1483
|
//#endregion
|
|
833
1484
|
//#region src/state/useTreeSelection/useTreeSelection.ts
|
|
834
|
-
function
|
|
835
|
-
let { items:
|
|
1485
|
+
function Qe(e) {
|
|
1486
|
+
let { items: n, field: i, childrenField: o, isDisabled: s, leafOnly: c = !1 } = e, l = r(() => Array.isArray(n) ? n : [], [n]), u = r(() => Array.isArray(e.defaultSelectedIds) ? e.defaultSelectedIds : [], [e.defaultSelectedIds]), d = e.cascade?.down ?? !0, f = e.cascade?.up ?? !0, p = r(() => Ye(l, i, o), [
|
|
836
1487
|
l,
|
|
837
|
-
|
|
1488
|
+
i,
|
|
838
1489
|
o
|
|
839
|
-
]), [m, h] =
|
|
1490
|
+
]), [m, h] = a(() => Z(p, new Set(u), s, f)), g = t((e) => {
|
|
840
1491
|
let t = p.childIdsByParentId.get(e);
|
|
841
1492
|
return !t || t.length === 0;
|
|
842
|
-
}, [p]), _ =
|
|
1493
|
+
}, [p]), _ = r(() => {
|
|
843
1494
|
let e = [];
|
|
844
1495
|
for (let t of p.entries) m.selectedIds.has(t.id) && (c && !g(t.id) || e.push(t.id));
|
|
845
1496
|
return e;
|
|
@@ -848,7 +1499,7 @@ function P(e) {
|
|
|
848
1499
|
m.selectedIds,
|
|
849
1500
|
c,
|
|
850
1501
|
g
|
|
851
|
-
]), v =
|
|
1502
|
+
]), v = r(() => {
|
|
852
1503
|
let e = [];
|
|
853
1504
|
for (let t of p.entries) m.selectedIds.has(t.id) && g(t.id) && e.push(t.id);
|
|
854
1505
|
return e;
|
|
@@ -856,153 +1507,153 @@ function P(e) {
|
|
|
856
1507
|
p,
|
|
857
1508
|
m.selectedIds,
|
|
858
1509
|
g
|
|
859
|
-
]), y =
|
|
1510
|
+
]), y = r(() => {
|
|
860
1511
|
let e = [];
|
|
861
1512
|
for (let t of p.entries) m.indeterminateIds.has(t.id) && e.push(t.id);
|
|
862
1513
|
return e;
|
|
863
|
-
}, [p, m.indeterminateIds]), b =
|
|
1514
|
+
}, [p, m.indeterminateIds]), b = r(() => {
|
|
864
1515
|
let e = new Set(_);
|
|
865
1516
|
return p.entries.filter((t) => e.has(t.id)).map((e) => e.item);
|
|
866
|
-
}, [p, _]), x =
|
|
867
|
-
let e = x.filter((e) =>
|
|
1517
|
+
}, [p, _]), x = r(() => p.childIdsByParentId.get(void 0) ?? [], [p]), S = r(() => {
|
|
1518
|
+
let e = x.filter((e) => Y(e, s));
|
|
868
1519
|
return e.length > 0 && e.every((e) => m.selectedIds.has(e));
|
|
869
1520
|
}, [
|
|
870
1521
|
x,
|
|
871
1522
|
s,
|
|
872
1523
|
m.selectedIds
|
|
873
|
-
]), C =
|
|
1524
|
+
]), C = r(() => !S && x.some((e) => m.selectedIds.has(e) || m.indeterminateIds.has(e)), [
|
|
874
1525
|
S,
|
|
875
1526
|
x,
|
|
876
1527
|
m.selectedIds,
|
|
877
1528
|
m.indeterminateIds
|
|
878
1529
|
]), w = t((e) => {
|
|
879
|
-
let t =
|
|
1530
|
+
let t = X(e, i);
|
|
880
1531
|
return m.selectedIds.has(t) ? "selected" : m.indeterminateIds.has(t) ? "indeterminate" : "unselected";
|
|
881
|
-
}, [m,
|
|
882
|
-
let t =
|
|
883
|
-
s?.(t) || h((e) =>
|
|
1532
|
+
}, [m, i]), T = t((e) => w(e) === "selected", [w]), E = t((e) => w(e) === "indeterminate", [w]), D = t((e) => {
|
|
1533
|
+
let t = X(e, i);
|
|
1534
|
+
s?.(t) || h((e) => Xe(p, e.selectedIds, e.indeterminateIds, t, !0, s, d, f));
|
|
884
1535
|
}, [
|
|
885
|
-
|
|
1536
|
+
i,
|
|
886
1537
|
p,
|
|
887
1538
|
s,
|
|
888
1539
|
d,
|
|
889
1540
|
f
|
|
890
|
-
]),
|
|
891
|
-
let t =
|
|
892
|
-
h((e) =>
|
|
1541
|
+
]), O = t((e) => {
|
|
1542
|
+
let t = X(e, i);
|
|
1543
|
+
h((e) => Xe(p, e.selectedIds, e.indeterminateIds, t, !1, s, d, f));
|
|
893
1544
|
}, [
|
|
894
|
-
|
|
1545
|
+
i,
|
|
895
1546
|
p,
|
|
896
1547
|
s,
|
|
897
1548
|
d,
|
|
898
1549
|
f
|
|
899
|
-
]),
|
|
900
|
-
let t =
|
|
1550
|
+
]), k = t((e) => {
|
|
1551
|
+
let t = X(e, i);
|
|
901
1552
|
h((e) => {
|
|
902
1553
|
let n = e.selectedIds.has(t);
|
|
903
|
-
return !n && s?.(t) ? e :
|
|
1554
|
+
return !n && s?.(t) ? e : Xe(p, e.selectedIds, e.indeterminateIds, t, !n, s, d, f);
|
|
904
1555
|
});
|
|
905
1556
|
}, [
|
|
906
|
-
|
|
1557
|
+
i,
|
|
907
1558
|
p,
|
|
908
1559
|
s,
|
|
909
1560
|
d,
|
|
910
1561
|
f
|
|
911
|
-
]),
|
|
912
|
-
h(
|
|
1562
|
+
]), A = t(() => {
|
|
1563
|
+
h(Z(p, new Set(u), s, f));
|
|
913
1564
|
}, [
|
|
914
1565
|
p,
|
|
915
1566
|
u,
|
|
916
1567
|
s,
|
|
917
1568
|
f
|
|
918
|
-
]),
|
|
919
|
-
let t = (Array.isArray(e) ? e : []).map((e) =>
|
|
920
|
-
h(
|
|
1569
|
+
]), j = t((e) => {
|
|
1570
|
+
let t = (Array.isArray(e) ? e : []).map((e) => X(e, i));
|
|
1571
|
+
h(Z(p, new Set(t), s, f));
|
|
921
1572
|
}, [
|
|
922
|
-
|
|
1573
|
+
i,
|
|
923
1574
|
p,
|
|
924
1575
|
s,
|
|
925
1576
|
f
|
|
926
|
-
]),
|
|
1577
|
+
]), M = t(() => {
|
|
927
1578
|
let e = p.entries.map((e) => e.id);
|
|
928
|
-
h(
|
|
1579
|
+
h(Z(p, new Set(e), s, f));
|
|
929
1580
|
}, [
|
|
930
1581
|
p,
|
|
931
1582
|
s,
|
|
932
1583
|
f
|
|
933
|
-
]),
|
|
1584
|
+
]), N = t(() => {
|
|
934
1585
|
h((e) => e.selectedIds.size === 0 && e.indeterminateIds.size === 0 ? e : {
|
|
935
1586
|
selectedIds: /* @__PURE__ */ new Set(),
|
|
936
1587
|
indeterminateIds: /* @__PURE__ */ new Set()
|
|
937
1588
|
});
|
|
938
|
-
}, []),
|
|
1589
|
+
}, []), P = t(() => {
|
|
939
1590
|
h((e) => {
|
|
940
|
-
let t = x.filter((e) =>
|
|
1591
|
+
let t = x.filter((e) => Y(e, s));
|
|
941
1592
|
if (t.length > 0 && t.every((t) => e.selectedIds.has(t))) return {
|
|
942
1593
|
selectedIds: /* @__PURE__ */ new Set(),
|
|
943
1594
|
indeterminateIds: /* @__PURE__ */ new Set()
|
|
944
1595
|
};
|
|
945
1596
|
let n = p.entries.map((e) => e.id);
|
|
946
|
-
return
|
|
1597
|
+
return Z(p, new Set(n), s, f);
|
|
947
1598
|
});
|
|
948
1599
|
}, [
|
|
949
1600
|
x,
|
|
950
1601
|
p,
|
|
951
1602
|
s,
|
|
952
1603
|
f
|
|
953
|
-
]),
|
|
954
|
-
let t = (Array.isArray(e) ? e : []).map((e) =>
|
|
955
|
-
h((e) =>
|
|
1604
|
+
]), ee = t((e) => {
|
|
1605
|
+
let t = (Array.isArray(e) ? e : []).map((e) => X(e, i));
|
|
1606
|
+
h((e) => Ze(p, e.selectedIds, e.indeterminateIds, t, !0, s, d, f));
|
|
956
1607
|
}, [
|
|
957
|
-
|
|
1608
|
+
i,
|
|
958
1609
|
p,
|
|
959
1610
|
s,
|
|
960
1611
|
d,
|
|
961
1612
|
f
|
|
962
|
-
]),
|
|
963
|
-
let t = (Array.isArray(e) ? e : []).map((e) =>
|
|
964
|
-
h((e) =>
|
|
1613
|
+
]), te = t((e) => {
|
|
1614
|
+
let t = (Array.isArray(e) ? e : []).map((e) => X(e, i));
|
|
1615
|
+
h((e) => Ze(p, e.selectedIds, e.indeterminateIds, t, !1, s, d, f));
|
|
965
1616
|
}, [
|
|
966
|
-
|
|
1617
|
+
i,
|
|
967
1618
|
p,
|
|
968
1619
|
s,
|
|
969
1620
|
d,
|
|
970
1621
|
f
|
|
971
|
-
]),
|
|
972
|
-
let t = new Set((Array.isArray(e) ? e : []).map((e) =>
|
|
1622
|
+
]), ne = t((e) => {
|
|
1623
|
+
let t = new Set((Array.isArray(e) ? e : []).map((e) => X(e, i)));
|
|
973
1624
|
h((e) => {
|
|
974
1625
|
let n = /* @__PURE__ */ new Set();
|
|
975
1626
|
return e.selectedIds.forEach((e) => {
|
|
976
1627
|
t.has(e) && n.add(e);
|
|
977
|
-
}),
|
|
1628
|
+
}), Z(p, n, s, f);
|
|
978
1629
|
});
|
|
979
1630
|
}, [
|
|
980
|
-
|
|
1631
|
+
i,
|
|
981
1632
|
p,
|
|
982
1633
|
s,
|
|
983
1634
|
f
|
|
984
|
-
]),
|
|
1635
|
+
]), re = t(() => {
|
|
985
1636
|
h((e) => {
|
|
986
1637
|
let t = /* @__PURE__ */ new Set();
|
|
987
1638
|
for (let n of p.entries) {
|
|
988
1639
|
let r = p.childIdsByParentId.get(n.id);
|
|
989
|
-
(!r || r.length === 0) &&
|
|
1640
|
+
(!r || r.length === 0) && Y(n.id, s) && (e.selectedIds.has(n.id) || t.add(n.id));
|
|
990
1641
|
}
|
|
991
|
-
return
|
|
1642
|
+
return Z(p, t, s, f);
|
|
992
1643
|
});
|
|
993
1644
|
}, [
|
|
994
1645
|
p,
|
|
995
1646
|
s,
|
|
996
1647
|
f
|
|
997
|
-
]),
|
|
998
|
-
let t =
|
|
1648
|
+
]), F = t((e) => {
|
|
1649
|
+
let t = X(e, i);
|
|
999
1650
|
return p.entryById.get(t)?.parentId;
|
|
1000
|
-
}, [p,
|
|
1001
|
-
let t =
|
|
1651
|
+
}, [p, i]), I = t((e) => {
|
|
1652
|
+
let t = X(e, i), n = [], r = p.entryById.get(t)?.parentId;
|
|
1002
1653
|
for (; r !== void 0;) n.push(r), r = p.entryById.get(r)?.parentId;
|
|
1003
1654
|
return n;
|
|
1004
|
-
}, [p,
|
|
1005
|
-
let t =
|
|
1655
|
+
}, [p, i]), ie = t((e) => {
|
|
1656
|
+
let t = X(e, i), n = [], r = [...p.childIdsByParentId.get(t) ?? []];
|
|
1006
1657
|
for (; r.length > 0;) {
|
|
1007
1658
|
let e = r.pop();
|
|
1008
1659
|
n.push(e);
|
|
@@ -1010,7 +1661,7 @@ function P(e) {
|
|
|
1010
1661
|
t && r.push(...t);
|
|
1011
1662
|
}
|
|
1012
1663
|
return n;
|
|
1013
|
-
}, [p,
|
|
1664
|
+
}, [p, i]);
|
|
1014
1665
|
return {
|
|
1015
1666
|
selectedIds: _,
|
|
1016
1667
|
selectedLeafIds: v,
|
|
@@ -1024,21 +1675,134 @@ function P(e) {
|
|
|
1024
1675
|
isSelected: T,
|
|
1025
1676
|
isIndeterminate: E,
|
|
1026
1677
|
select: D,
|
|
1027
|
-
deselect:
|
|
1028
|
-
toggle:
|
|
1029
|
-
reset:
|
|
1030
|
-
replaceSelection:
|
|
1031
|
-
selectAll:
|
|
1032
|
-
deselectAll:
|
|
1033
|
-
toggleAll:
|
|
1034
|
-
selectMultiple:
|
|
1035
|
-
deselectMultiple:
|
|
1036
|
-
retainOnly:
|
|
1037
|
-
invertSelection:
|
|
1038
|
-
getParentId:
|
|
1039
|
-
getAncestorIds:
|
|
1040
|
-
getDescendantIds:
|
|
1678
|
+
deselect: O,
|
|
1679
|
+
toggle: k,
|
|
1680
|
+
reset: A,
|
|
1681
|
+
replaceSelection: j,
|
|
1682
|
+
selectAll: M,
|
|
1683
|
+
deselectAll: N,
|
|
1684
|
+
toggleAll: P,
|
|
1685
|
+
selectMultiple: ee,
|
|
1686
|
+
deselectMultiple: te,
|
|
1687
|
+
retainOnly: ne,
|
|
1688
|
+
invertSelection: re,
|
|
1689
|
+
getParentId: F,
|
|
1690
|
+
getAncestorIds: I,
|
|
1691
|
+
getDescendantIds: ie
|
|
1692
|
+
};
|
|
1693
|
+
}
|
|
1694
|
+
//#endregion
|
|
1695
|
+
//#region src/state/useVisibility/validation.ts
|
|
1696
|
+
var $e = globalThis.process?.env?.NODE_ENV !== "production";
|
|
1697
|
+
function Q(e, t, n) {
|
|
1698
|
+
if (w(e)) return !0;
|
|
1699
|
+
if (!t) {
|
|
1700
|
+
if ($e) throw console.warn(`[useVisibility] ${n}: received an object item but no "field" option is configured to resolve its id. Every such item would collapse onto the same visibility id.`), Error(`[useVisibility] ${n}: received an object item but no "field" option is configured to resolve its id.`);
|
|
1701
|
+
return !1;
|
|
1702
|
+
}
|
|
1703
|
+
return !0;
|
|
1704
|
+
}
|
|
1705
|
+
function $(t, n, r) {
|
|
1706
|
+
if (w(t)) return t;
|
|
1707
|
+
if (!n) return;
|
|
1708
|
+
let i = e(t, n);
|
|
1709
|
+
return i === void 0 && $e && console.warn(`[useVisibility] ${r}: could not resolve an id from the given item using field "${n}".`), i;
|
|
1710
|
+
}
|
|
1711
|
+
//#endregion
|
|
1712
|
+
//#region src/state/useVisibility/useVisibility.ts
|
|
1713
|
+
function et(e = {}) {
|
|
1714
|
+
let n = e, o = n.field, s = r(() => Array.isArray(n.items) ? n.items : [], [n.items]), c = r(() => Array.isArray(n.initialVisibleIds) ? n.initialVisibleIds : [], [n.initialVisibleIds]), l = i(c), [u, d] = a(() => new Set(c)), f = t((e) => {
|
|
1715
|
+
if (!Q(e, o, "isVisible")) return !1;
|
|
1716
|
+
let t = $(e, o, "isVisible");
|
|
1717
|
+
return t !== void 0 && u.has(t);
|
|
1718
|
+
}, [u, o]), p = t((e) => {
|
|
1719
|
+
Q(e, o, "show") && d((t) => {
|
|
1720
|
+
let n = $(e, o, "show");
|
|
1721
|
+
if (n === void 0 || t.has(n)) return t;
|
|
1722
|
+
let r = new Set(t);
|
|
1723
|
+
return r.add(n), r;
|
|
1724
|
+
});
|
|
1725
|
+
}, [o]), m = t((e) => {
|
|
1726
|
+
Q(e, o, "hide") && d((t) => {
|
|
1727
|
+
let n = $(e, o, "hide");
|
|
1728
|
+
if (n === void 0 || !t.has(n)) return t;
|
|
1729
|
+
let r = new Set(t);
|
|
1730
|
+
return r.delete(n), r;
|
|
1731
|
+
});
|
|
1732
|
+
}, [o]), h = t((e) => {
|
|
1733
|
+
Q(e, o, "toggleVisibility") && d((t) => {
|
|
1734
|
+
let n = $(e, o, "toggleVisibility");
|
|
1735
|
+
if (n === void 0) return t;
|
|
1736
|
+
let r = new Set(t);
|
|
1737
|
+
return r.has(n) ? r.delete(n) : r.add(n), r;
|
|
1738
|
+
});
|
|
1739
|
+
}, [o]), g = t((e) => {
|
|
1740
|
+
let t = Array.isArray(e) ? e : s;
|
|
1741
|
+
d((e) => {
|
|
1742
|
+
let n = new Set(e);
|
|
1743
|
+
for (let e of t) {
|
|
1744
|
+
if (!Q(e, o, "showAll")) continue;
|
|
1745
|
+
let t = $(e, o, "showAll");
|
|
1746
|
+
t !== void 0 && n.add(t);
|
|
1747
|
+
}
|
|
1748
|
+
return n;
|
|
1749
|
+
});
|
|
1750
|
+
}, [s, o]), _ = t((e) => {
|
|
1751
|
+
if (e === void 0) {
|
|
1752
|
+
d((e) => e.size === 0 ? e : /* @__PURE__ */ new Set());
|
|
1753
|
+
return;
|
|
1754
|
+
}
|
|
1755
|
+
let t = Array.isArray(e) ? e : [];
|
|
1756
|
+
d((e) => {
|
|
1757
|
+
let n = new Set(e);
|
|
1758
|
+
for (let e of t) {
|
|
1759
|
+
if (!Q(e, o, "hideAll")) continue;
|
|
1760
|
+
let t = $(e, o, "hideAll");
|
|
1761
|
+
t !== void 0 && n.delete(t);
|
|
1762
|
+
}
|
|
1763
|
+
return n;
|
|
1764
|
+
});
|
|
1765
|
+
}, [o]), v = t(() => {
|
|
1766
|
+
d(new Set(l.current));
|
|
1767
|
+
}, []), y = t((e) => {
|
|
1768
|
+
let t = Array.isArray(e) ? e : [], n = [];
|
|
1769
|
+
for (let e of t) {
|
|
1770
|
+
if (!Q(e, o, "replaceVisibility")) continue;
|
|
1771
|
+
let t = $(e, o, "replaceVisibility");
|
|
1772
|
+
t !== void 0 && n.push(t);
|
|
1773
|
+
}
|
|
1774
|
+
d(new Set(n));
|
|
1775
|
+
}, [o]), b = r(() => [...u], [u]), { visibleItems: x, hiddenItems: S } = r(() => {
|
|
1776
|
+
let e = [], t = [];
|
|
1777
|
+
for (let n of s) {
|
|
1778
|
+
let r = $(n, o, "visibleItems");
|
|
1779
|
+
r !== void 0 && u.has(r) ? e.push(n) : t.push(n);
|
|
1780
|
+
}
|
|
1781
|
+
return {
|
|
1782
|
+
visibleItems: e,
|
|
1783
|
+
hiddenItems: t
|
|
1784
|
+
};
|
|
1785
|
+
}, [
|
|
1786
|
+
s,
|
|
1787
|
+
o,
|
|
1788
|
+
u
|
|
1789
|
+
]);
|
|
1790
|
+
return {
|
|
1791
|
+
visibleIds: b,
|
|
1792
|
+
visibleItems: x,
|
|
1793
|
+
hiddenItems: S,
|
|
1794
|
+
visibleCount: u.size,
|
|
1795
|
+
hiddenCount: S.length,
|
|
1796
|
+
hasVisible: u.size > 0,
|
|
1797
|
+
isVisible: f,
|
|
1798
|
+
show: p,
|
|
1799
|
+
hide: m,
|
|
1800
|
+
toggleVisibility: h,
|
|
1801
|
+
showAll: g,
|
|
1802
|
+
hideAll: _,
|
|
1803
|
+
resetVisibility: v,
|
|
1804
|
+
replaceVisibility: y
|
|
1041
1805
|
};
|
|
1042
1806
|
}
|
|
1043
1807
|
//#endregion
|
|
1044
|
-
export {
|
|
1808
|
+
export { Ne as a, Ee as c, te as d, Pe as i, we as l, Qe as n, ke as o, Ke as r, Oe as s, et as t, se as u };
|