mig-schema-table 5.0.11 → 5.0.12
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/mig-schema-table.es.js +901 -860
- package/dist/mig-schema-table.umd.js +1 -1
- package/package.json +2 -1
|
@@ -1,36 +1,37 @@
|
|
|
1
|
-
import { jsx as n, jsxs as
|
|
1
|
+
import { jsx as n, jsxs as F, Fragment as jt } from "react/jsx-runtime";
|
|
2
2
|
import * as Ft from "react";
|
|
3
3
|
import e from "react";
|
|
4
|
-
import { createPortal as
|
|
5
|
-
import { VariableSizeGrid as lt, VariableSizeList as
|
|
6
|
-
import { format as
|
|
4
|
+
import { createPortal as Bt } from "react-dom";
|
|
5
|
+
import { VariableSizeGrid as lt, VariableSizeList as Qt } from "react-window";
|
|
6
|
+
import { format as zt, endOfDay as Ut, differenceInSeconds as Pt } from "date-fns";
|
|
7
7
|
import { nl as Jt } from "date-fns/locale";
|
|
8
8
|
import { unCamel as Vt, emptyFn as ve, timeZone as Te, localeFormatInTimeZone as wt, parseLocationHash as ct, serializeLocationHash as ze } from "mig-data-tools";
|
|
9
|
-
import { range as
|
|
9
|
+
import { range as Zt, debounce as qt, difference as Gt, isEqual as et, isFinite as Xt, sum as Yt } from "lodash";
|
|
10
10
|
import ut from "react-datepicker";
|
|
11
|
-
import
|
|
11
|
+
import dt from "react-select";
|
|
12
|
+
import { nl as mt } from "date-fns/locale/nl";
|
|
12
13
|
import { TZDate as Ue } from "@date-fns/tz";
|
|
13
|
-
import { useFloating as
|
|
14
|
+
import { useFloating as ht, flip as ft } from "@floating-ui/react-dom";
|
|
14
15
|
import Ht from "react-window-infinite-loader";
|
|
15
|
-
import { saveAs as
|
|
16
|
-
const tt = (t,
|
|
16
|
+
import { saveAs as Kt } from "file-saver";
|
|
17
|
+
const tt = (t, s) => (
|
|
17
18
|
// replace jan. with jan
|
|
18
|
-
|
|
19
|
-
),
|
|
19
|
+
zt(t, s, { locale: Jt }).replace(".", "")
|
|
20
|
+
), en = {
|
|
20
21
|
"Europe/Amsterdam": "AMS",
|
|
21
22
|
"Europe/Berlin": "AMS",
|
|
22
23
|
"Asia/Jakarta": "JKT",
|
|
23
24
|
"Asia/Bangkok": "JKT",
|
|
24
25
|
showingFilteredCountOfTotalCount: "Showing {0} of {1}"
|
|
25
26
|
};
|
|
26
|
-
function
|
|
27
|
-
let u =
|
|
28
|
-
return
|
|
29
|
-
u = u.replace(`{${
|
|
27
|
+
function bt(t, ...s) {
|
|
28
|
+
let u = en[t] || Vt(t);
|
|
29
|
+
return s.forEach((g, p) => {
|
|
30
|
+
u = u.replace(`{${p}}`, `${g}`);
|
|
30
31
|
}), u;
|
|
31
32
|
}
|
|
32
|
-
const
|
|
33
|
-
var
|
|
33
|
+
const K = "SELECT_ALL_COLUMN_NAME", gt = 40, vt = "dd MMM yyyy", Pe = "dd MMM yyyy HH:mm", kt = 25, pt = 50, tn = 3;
|
|
34
|
+
var ge = /* @__PURE__ */ ((t) => (t.GT = "GT", t.LT = "LT", t.EQ = "EQ", t))(ge || {}), $e = /* @__PURE__ */ ((t) => (t.UNAVAILABLE = "UNAVAILABLE", t.AVAILABLE = "AVAILABLE", t.ACTIVE = "ACTIVE", t))($e || {});
|
|
34
35
|
const Me = Ft.createContext({
|
|
35
36
|
checkedIndexes: [],
|
|
36
37
|
columnNames: [],
|
|
@@ -56,324 +57,324 @@ const Me = Ft.createContext({
|
|
|
56
57
|
sortAsc: !1
|
|
57
58
|
},
|
|
58
59
|
translate: ve
|
|
59
|
-
}),
|
|
60
|
+
}), nn = { type: "boolean" }, rn = ({ columnIndex: t, rowIndex: s, style: u }) => {
|
|
60
61
|
const {
|
|
61
|
-
checkedIndexes:
|
|
62
|
-
columnNames:
|
|
63
|
-
config:
|
|
64
|
-
disabledCheckedIndexes:
|
|
65
|
-
displayTimezone:
|
|
62
|
+
checkedIndexes: g,
|
|
63
|
+
columnNames: p,
|
|
64
|
+
config: d,
|
|
65
|
+
disabledCheckedIndexes: I,
|
|
66
|
+
displayTimezone: C,
|
|
66
67
|
getRowClassName: R,
|
|
67
|
-
getRowSelected:
|
|
68
|
-
isItemLoaded:
|
|
69
|
-
lastCheckChangedRowIndex:
|
|
70
|
-
onRowClick:
|
|
71
|
-
onRowDoubleClick:
|
|
72
|
-
properties:
|
|
68
|
+
getRowSelected: S,
|
|
69
|
+
isItemLoaded: A,
|
|
70
|
+
lastCheckChangedRowIndex: O,
|
|
71
|
+
onRowClick: D,
|
|
72
|
+
onRowDoubleClick: w,
|
|
73
|
+
properties: $,
|
|
73
74
|
setCheckedIndexes: Z,
|
|
74
|
-
setLastCheckChangedRowIndex:
|
|
75
|
-
sortedRenderData:
|
|
76
|
-
sourceData:
|
|
77
|
-
translate:
|
|
78
|
-
} = e.useContext(Me),
|
|
75
|
+
setLastCheckChangedRowIndex: ee,
|
|
76
|
+
sortedRenderData: T,
|
|
77
|
+
sourceData: c,
|
|
78
|
+
translate: a
|
|
79
|
+
} = e.useContext(Me), o = p[t], _ = o === K ? nn : $[o], B = d ? d[o] : void 0, te = e.useCallback(
|
|
79
80
|
(v) => {
|
|
80
|
-
Z && Z((
|
|
81
|
+
Z && Z((N) => N && N.includes(v) ? N.filter((M) => M !== v) : N ? [...N, v] : [v]);
|
|
81
82
|
},
|
|
82
83
|
[Z]
|
|
83
|
-
), le =
|
|
84
|
+
), le = A(s), ne = e.useCallback(
|
|
84
85
|
(v) => {
|
|
85
|
-
if (!
|
|
86
|
+
if (!c || !T || !D || !le)
|
|
86
87
|
return;
|
|
87
|
-
const { rowIndex:
|
|
88
|
-
if (!
|
|
88
|
+
const { rowIndex: N } = v.currentTarget.dataset;
|
|
89
|
+
if (!N)
|
|
89
90
|
return;
|
|
90
|
-
const k =
|
|
91
|
-
|
|
91
|
+
const k = T[parseInt(N, 10)];
|
|
92
|
+
D(c[k._index], k._index, v);
|
|
92
93
|
},
|
|
93
|
-
[le,
|
|
94
|
-
),
|
|
94
|
+
[le, D, T, c]
|
|
95
|
+
), y = e.useCallback(
|
|
95
96
|
(v) => {
|
|
96
|
-
if (!
|
|
97
|
+
if (!c || !T || !w || !A)
|
|
97
98
|
return;
|
|
98
|
-
const { rowIndex:
|
|
99
|
-
if (!
|
|
99
|
+
const { rowIndex: N } = v.currentTarget.dataset;
|
|
100
|
+
if (!N)
|
|
100
101
|
return;
|
|
101
|
-
const k =
|
|
102
|
-
|
|
102
|
+
const k = T[parseInt(N, 10)];
|
|
103
|
+
w(c[k._index], k._index, v);
|
|
103
104
|
},
|
|
104
|
-
[
|
|
105
|
-
), L =
|
|
106
|
-
if (!L || !
|
|
105
|
+
[A, w, T, c]
|
|
106
|
+
), L = T ? T[s] : void 0, { showTimezones: oe, TdBody: G } = B || {}, re = e.useMemo(() => C ? null : Te.startsWith("Europe/") ? "Asia/Jakarta" : "Europe/Amsterdam", [C]), Q = e.useMemo(() => {
|
|
107
|
+
if (!L || !T)
|
|
107
108
|
return;
|
|
108
|
-
let v =
|
|
109
|
-
if (
|
|
110
|
-
const k =
|
|
109
|
+
let v = o === K ? void 0 : L[o];
|
|
110
|
+
if (_?.format && _.format === "date-time" && oe !== !1) {
|
|
111
|
+
const k = c ? c[L._index] : void 0, M = k ? k[o] : void 0, ce = M ? new Date(M) : void 0;
|
|
111
112
|
ce && re && (v = `${wt(
|
|
112
113
|
ce,
|
|
113
114
|
re,
|
|
114
|
-
|
|
115
|
-
)} (${
|
|
115
|
+
Pe
|
|
116
|
+
)} (${a(re)})`);
|
|
116
117
|
}
|
|
117
|
-
const
|
|
118
|
+
const N = [
|
|
118
119
|
"mig-schema-table__td",
|
|
119
|
-
`mig-schema-table__td--${
|
|
120
|
-
`mig-schema-table__td--prop-${
|
|
120
|
+
`mig-schema-table__td--${s % 2 ? "odd" : "even"}`,
|
|
121
|
+
`mig-schema-table__td--prop-${o}`
|
|
121
122
|
];
|
|
122
|
-
switch (
|
|
123
|
-
R(
|
|
124
|
-
),
|
|
123
|
+
switch (c && S && S(c[L._index], L._index) && N.push("mig-schema-table__td--selected"), c && R && N.push(
|
|
124
|
+
R(c[L._index], L._index, T)
|
|
125
|
+
), _?.type) {
|
|
125
126
|
case "boolean":
|
|
126
|
-
|
|
127
|
+
N.push(`text-${B?.align || "center"}`);
|
|
127
128
|
break;
|
|
128
129
|
case "number":
|
|
129
130
|
case "integer":
|
|
130
|
-
|
|
131
|
+
N.push(`text-${B?.align || "end"}`);
|
|
131
132
|
break;
|
|
132
133
|
default:
|
|
133
|
-
|
|
134
|
+
B?.align && N.push(`text-${B.align}`);
|
|
134
135
|
}
|
|
135
136
|
return {
|
|
136
|
-
"data-row-index":
|
|
137
|
+
"data-row-index": s,
|
|
137
138
|
"data-column-index": t,
|
|
138
139
|
style: u,
|
|
139
|
-
className:
|
|
140
|
+
className: N.join(" "),
|
|
140
141
|
title: v,
|
|
141
|
-
onClick:
|
|
142
|
-
onDoubleClick:
|
|
142
|
+
onClick: o === K ? void 0 : ne,
|
|
143
|
+
onDoubleClick: o === K ? void 0 : y
|
|
143
144
|
};
|
|
144
145
|
}, [
|
|
145
146
|
L,
|
|
146
|
-
|
|
147
|
-
b,
|
|
148
|
-
w,
|
|
149
|
-
se,
|
|
147
|
+
T,
|
|
150
148
|
o,
|
|
149
|
+
_,
|
|
150
|
+
oe,
|
|
151
151
|
s,
|
|
152
|
-
|
|
152
|
+
c,
|
|
153
|
+
S,
|
|
153
154
|
R,
|
|
154
155
|
t,
|
|
155
156
|
u,
|
|
156
157
|
ne,
|
|
157
|
-
|
|
158
|
+
y,
|
|
158
159
|
re,
|
|
159
|
-
|
|
160
|
-
|
|
160
|
+
a,
|
|
161
|
+
B
|
|
161
162
|
]), V = e.useCallback(
|
|
162
163
|
(v) => {
|
|
163
164
|
if (!te || !L)
|
|
164
165
|
return;
|
|
165
|
-
const
|
|
166
|
-
if (v.shiftKey &&
|
|
167
|
-
const k =
|
|
168
|
-
if (k !== void 0 &&
|
|
169
|
-
const
|
|
170
|
-
for (const ce of
|
|
171
|
-
|
|
172
|
-
|
|
166
|
+
const N = parseInt(v.currentTarget.dataset.rowIndex);
|
|
167
|
+
if (v.shiftKey && O !== void 0) {
|
|
168
|
+
const k = g?.includes(O) ? O : void 0;
|
|
169
|
+
if (k !== void 0 && T) {
|
|
170
|
+
const M = s;
|
|
171
|
+
for (const ce of Zt(
|
|
172
|
+
M > k ? k + 1 : M,
|
|
173
|
+
M > k ? M + 1 : k
|
|
173
174
|
)) {
|
|
174
|
-
const me =
|
|
175
|
-
(!
|
|
175
|
+
const me = T[ce]._index;
|
|
176
|
+
(!I || !I.includes(me)) && te(me);
|
|
176
177
|
}
|
|
177
178
|
}
|
|
178
179
|
} else
|
|
179
180
|
te(L._index);
|
|
180
|
-
|
|
181
|
+
ee(N), Ce.current?.focus();
|
|
181
182
|
},
|
|
182
183
|
[
|
|
183
|
-
|
|
184
|
+
g,
|
|
185
|
+
I,
|
|
184
186
|
O,
|
|
185
|
-
$,
|
|
186
187
|
te,
|
|
187
188
|
L,
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
189
|
+
s,
|
|
190
|
+
ee,
|
|
191
|
+
T
|
|
191
192
|
]
|
|
192
|
-
),
|
|
193
|
-
if (!L || !
|
|
193
|
+
), Ce = e.useRef(null);
|
|
194
|
+
if (!L || !Q)
|
|
194
195
|
return null;
|
|
195
|
-
if (!
|
|
196
|
-
return /* @__PURE__ */ n("div", { ...
|
|
197
|
-
if (
|
|
198
|
-
return /* @__PURE__ */ n("div", { ...
|
|
196
|
+
if (!A || c && !c[L._index])
|
|
197
|
+
return /* @__PURE__ */ n("div", { ...Q, children: "loading" });
|
|
198
|
+
if (o === K)
|
|
199
|
+
return /* @__PURE__ */ n("div", { ...Q, onMouseDown: V, children: /* @__PURE__ */ n("div", { style: { textAlign: "center" }, children: /* @__PURE__ */ n(
|
|
199
200
|
"input",
|
|
200
201
|
{
|
|
201
|
-
ref:
|
|
202
|
+
ref: Ce,
|
|
202
203
|
type: "checkbox",
|
|
203
204
|
readOnly: !0,
|
|
204
|
-
checked:
|
|
205
|
-
disabled:
|
|
205
|
+
checked: g?.includes(L._index),
|
|
206
|
+
disabled: I?.includes(L._index)
|
|
206
207
|
}
|
|
207
208
|
) }) });
|
|
208
|
-
if (G &&
|
|
209
|
-
return /* @__PURE__ */ n("div", { ...
|
|
209
|
+
if (G && c)
|
|
210
|
+
return /* @__PURE__ */ n("div", { ...Q, children: /* @__PURE__ */ n(
|
|
210
211
|
G,
|
|
211
212
|
{
|
|
212
213
|
dataIndex: L._index,
|
|
213
|
-
rowData:
|
|
214
|
-
rowIndex:
|
|
215
|
-
...
|
|
214
|
+
rowData: c[L._index],
|
|
215
|
+
rowIndex: s,
|
|
216
|
+
...B?.tdBodyProps
|
|
216
217
|
}
|
|
217
218
|
) });
|
|
218
|
-
const q = L[
|
|
219
|
-
return
|
|
219
|
+
const q = L[o];
|
|
220
|
+
return _?.format === "url" && q ? /* @__PURE__ */ n(
|
|
220
221
|
"a",
|
|
221
222
|
{
|
|
222
223
|
href: q,
|
|
223
224
|
target: "_blank",
|
|
224
225
|
rel: "noopener noreferrer",
|
|
225
|
-
...
|
|
226
|
+
...Q,
|
|
226
227
|
children: q
|
|
227
228
|
}
|
|
228
|
-
) : /* @__PURE__ */ n("div", { ...
|
|
229
|
-
},
|
|
230
|
-
function
|
|
231
|
-
const { checkedIndexes: t, disabledCheckedIndexes:
|
|
229
|
+
) : /* @__PURE__ */ n("div", { ...Q, children: q });
|
|
230
|
+
}, _t = e.memo(rn);
|
|
231
|
+
function sn() {
|
|
232
|
+
const { checkedIndexes: t, disabledCheckedIndexes: s, sortedRenderData: u } = e.useContext(Me);
|
|
232
233
|
return e.useMemo(() => {
|
|
233
|
-
const
|
|
234
|
-
(
|
|
234
|
+
const g = [...u || []].filter(
|
|
235
|
+
(p) => (t ? t.includes(p._index) : !0) || (s ? !s.includes(p._index) : !0)
|
|
235
236
|
);
|
|
236
|
-
return t?.length !== 0 &&
|
|
237
|
-
}, [t,
|
|
237
|
+
return t?.length !== 0 && g.length === t?.length;
|
|
238
|
+
}, [t, s, u]);
|
|
238
239
|
}
|
|
239
|
-
function
|
|
240
|
-
return !!(t && u?.isSortable !== !1 && (
|
|
240
|
+
function xt(t, s, u) {
|
|
241
|
+
return !!(t && u?.isSortable !== !1 && (s || u?.renderData || u?.sort));
|
|
241
242
|
}
|
|
242
|
-
function
|
|
243
|
-
const { setCustomColumnWidths: t, settingsStorageKey:
|
|
243
|
+
function Dt() {
|
|
244
|
+
const { setCustomColumnWidths: t, settingsStorageKey: s } = e.useContext(Me);
|
|
244
245
|
return e.useCallback(
|
|
245
246
|
(u) => {
|
|
246
|
-
|
|
247
|
-
`${
|
|
247
|
+
s && localStorage.setItem(
|
|
248
|
+
`${s}.columnWidths`,
|
|
248
249
|
JSON.stringify(Array.from(u))
|
|
249
250
|
), t(u);
|
|
250
251
|
},
|
|
251
|
-
[t,
|
|
252
|
+
[t, s]
|
|
252
253
|
);
|
|
253
254
|
}
|
|
254
|
-
const on = ({ index: t, style:
|
|
255
|
+
const on = ({ index: t, style: s }) => {
|
|
255
256
|
const {
|
|
256
257
|
checkedIndexes: u,
|
|
257
|
-
columnNames:
|
|
258
|
-
columnWidths:
|
|
259
|
-
config:
|
|
260
|
-
disabledCheckedIndexes:
|
|
261
|
-
dropTargetIndex:
|
|
258
|
+
columnNames: g,
|
|
259
|
+
columnWidths: p,
|
|
260
|
+
config: d,
|
|
261
|
+
disabledCheckedIndexes: I,
|
|
262
|
+
dropTargetIndex: C,
|
|
262
263
|
isColumnFilterable: R,
|
|
263
|
-
isSortable:
|
|
264
|
-
setCheckedIndexes:
|
|
265
|
-
properties:
|
|
266
|
-
required:
|
|
267
|
-
setCustomColumnNames:
|
|
268
|
-
setDropTargetIndex:
|
|
264
|
+
isSortable: S,
|
|
265
|
+
setCheckedIndexes: A,
|
|
266
|
+
properties: O,
|
|
267
|
+
required: D,
|
|
268
|
+
setCustomColumnNames: w,
|
|
269
|
+
setDropTargetIndex: $,
|
|
269
270
|
setFilterSortColumn: Z,
|
|
270
|
-
setMenuConfig:
|
|
271
|
-
settingsStorageKey:
|
|
272
|
-
tableDataState:
|
|
273
|
-
sortedRenderData:
|
|
274
|
-
translate:
|
|
275
|
-
displayTimezone:
|
|
276
|
-
} = e.useContext(Me), [
|
|
271
|
+
setMenuConfig: ee,
|
|
272
|
+
settingsStorageKey: T,
|
|
273
|
+
tableDataState: c,
|
|
274
|
+
sortedRenderData: a,
|
|
275
|
+
translate: o,
|
|
276
|
+
displayTimezone: _
|
|
277
|
+
} = e.useContext(Me), [B, te] = e.useState(!1), le = t === C, ne = Dt(), y = g[t], L = y === K ? { type: "boolean" } : O[y], oe = c.sortColumn === y ? c.sortAsc : void 0, G = d ? d[y] : void 0;
|
|
277
278
|
let re = R && (L || G?.FilterMenu) && G?.isFilterable !== !1 ? $e.AVAILABLE : $e.UNAVAILABLE;
|
|
278
|
-
|
|
279
|
-
const
|
|
280
|
-
|
|
279
|
+
c.columnFilterMap && c.columnFilterMap[y] !== void 0 && (re = $e.ACTIVE);
|
|
280
|
+
const Q = xt(
|
|
281
|
+
S,
|
|
281
282
|
L,
|
|
282
283
|
G
|
|
283
284
|
), V = [
|
|
284
285
|
"mig-schema-table__th",
|
|
285
286
|
`mig-schema-table__th--filter-${re}`,
|
|
286
|
-
`mig-schema-table__th--prop-${
|
|
287
|
+
`mig-schema-table__th--prop-${y}`
|
|
287
288
|
];
|
|
288
289
|
V.push(
|
|
289
|
-
|
|
290
|
-
),
|
|
291
|
-
const { format:
|
|
290
|
+
Q ? "mig-schema-table__th--sortable" : "mig-schema-table__th--unsortable"
|
|
291
|
+
), oe !== void 0 && V.push("mig-schema-table__th--sorted"), B && V.push("mig-schema-table__th--dragging"), le && V.push("mig-schema-table__th--drop-target");
|
|
292
|
+
const { format: Ce } = L || {}, {
|
|
292
293
|
align: q,
|
|
293
294
|
defaultSortDesc: v,
|
|
294
|
-
showTimezones:
|
|
295
|
+
showTimezones: N = !_,
|
|
295
296
|
title: k
|
|
296
|
-
} = G || {},
|
|
297
|
-
if (
|
|
298
|
-
if (
|
|
299
|
-
Z(
|
|
297
|
+
} = G || {}, M = e.useCallback(() => {
|
|
298
|
+
if (Q) {
|
|
299
|
+
if (oe === void 0) {
|
|
300
|
+
Z(y, !v);
|
|
300
301
|
return;
|
|
301
302
|
}
|
|
302
|
-
Z(
|
|
303
|
+
Z(y, !oe);
|
|
303
304
|
}
|
|
304
305
|
}, [
|
|
305
|
-
|
|
306
|
+
Q,
|
|
306
307
|
v,
|
|
307
|
-
|
|
308
|
+
y,
|
|
308
309
|
Z,
|
|
309
|
-
|
|
310
|
-
]), ce =
|
|
310
|
+
oe
|
|
311
|
+
]), ce = D.includes(y), me = e.useCallback(
|
|
311
312
|
(j) => {
|
|
312
313
|
const he = j.currentTarget;
|
|
313
|
-
|
|
314
|
-
if (we?.propName !==
|
|
314
|
+
ee((we) => {
|
|
315
|
+
if (we?.propName !== y)
|
|
315
316
|
return {
|
|
316
317
|
propConfig: G,
|
|
317
318
|
propIsRequired: ce,
|
|
318
|
-
propName:
|
|
319
|
+
propName: y,
|
|
319
320
|
referenceElement: he
|
|
320
321
|
};
|
|
321
322
|
});
|
|
322
323
|
},
|
|
323
|
-
[G, ce,
|
|
324
|
-
),
|
|
324
|
+
[G, ce, y, ee]
|
|
325
|
+
), ye = e.useMemo(() => k !== void 0 ? k : Ce === "date-time" && N ? `${o(y)} (${o(_ || Te)})` : o(y), [k, Ce, N, o, y, _]), se = e.useCallback(
|
|
325
326
|
(j, he) => {
|
|
326
|
-
if (!
|
|
327
|
+
if (!g || !p)
|
|
327
328
|
return;
|
|
328
|
-
const we =
|
|
329
|
+
const we = g.indexOf(j), J = [...g];
|
|
329
330
|
J.splice(we, 1);
|
|
330
331
|
const x = J.indexOf(he);
|
|
331
|
-
J.splice(x + 1, 0, j),
|
|
332
|
-
const
|
|
333
|
-
|
|
334
|
-
`${
|
|
332
|
+
J.splice(x + 1, 0, j), w(J);
|
|
333
|
+
const pe = [...p], fe = pe[we];
|
|
334
|
+
pe.splice(we, 1), pe.splice(x + 1, 0, fe), ne(new Uint16Array(pe)), T && localStorage.setItem(
|
|
335
|
+
`${T}.columnNames`,
|
|
335
336
|
JSON.stringify(J)
|
|
336
337
|
);
|
|
337
338
|
},
|
|
338
339
|
[
|
|
340
|
+
g,
|
|
339
341
|
p,
|
|
340
|
-
f,
|
|
341
342
|
ne,
|
|
342
|
-
|
|
343
|
-
|
|
343
|
+
T,
|
|
344
|
+
w
|
|
344
345
|
]
|
|
345
|
-
),
|
|
346
|
+
), Ae = e.useCallback(
|
|
346
347
|
(j) => {
|
|
347
|
-
|
|
348
|
+
se && (te(!0), j.dataTransfer.effectAllowed = "move", j.dataTransfer.dropEffect = "move", j.dataTransfer.setData("text/plain", y));
|
|
348
349
|
},
|
|
349
|
-
[
|
|
350
|
+
[se, y]
|
|
350
351
|
), Oe = e.useCallback(() => {
|
|
351
|
-
|
|
352
|
-
}, [
|
|
352
|
+
se && (te(!1), $(-1));
|
|
353
|
+
}, [se, $]), Je = e.useCallback(
|
|
353
354
|
(j) => {
|
|
354
|
-
|
|
355
|
+
se && (j.preventDefault(), $(t));
|
|
355
356
|
},
|
|
356
|
-
[t,
|
|
357
|
-
),
|
|
357
|
+
[t, se, $]
|
|
358
|
+
), Ve = e.useCallback(
|
|
358
359
|
(j) => {
|
|
359
|
-
if (
|
|
360
|
+
if ($(-1), !se || !y)
|
|
360
361
|
return;
|
|
361
362
|
const he = j.dataTransfer.getData("text/plain");
|
|
362
|
-
!he || he ===
|
|
363
|
+
!he || he === y || se(he, y);
|
|
363
364
|
},
|
|
364
|
-
[
|
|
365
|
-
),
|
|
366
|
-
!
|
|
367
|
-
|
|
365
|
+
[se, y, $]
|
|
366
|
+
), Ee = sn(), Ze = e.useCallback(() => {
|
|
367
|
+
!A || !a || A(
|
|
368
|
+
Ee ? [] : a.map((j) => j._index).filter((j) => !I?.includes(j))
|
|
368
369
|
);
|
|
369
370
|
}, [
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
371
|
+
A,
|
|
372
|
+
a,
|
|
373
|
+
Ee,
|
|
374
|
+
I
|
|
374
375
|
]);
|
|
375
|
-
if (
|
|
376
|
-
return /* @__PURE__ */ n("div", { style:
|
|
376
|
+
if (y === K)
|
|
377
|
+
return /* @__PURE__ */ n("div", { style: s, className: V.join(" "), children: /* @__PURE__ */ n(
|
|
377
378
|
"div",
|
|
378
379
|
{
|
|
379
380
|
style: {
|
|
@@ -386,7 +387,7 @@ const on = ({ index: t, style: o }) => {
|
|
|
386
387
|
{
|
|
387
388
|
type: "checkbox",
|
|
388
389
|
name: "selectAll",
|
|
389
|
-
checked:
|
|
390
|
+
checked: Ee,
|
|
390
391
|
onChange: Ze
|
|
391
392
|
}
|
|
392
393
|
)
|
|
@@ -409,32 +410,32 @@ const on = ({ index: t, style: o }) => {
|
|
|
409
410
|
default:
|
|
410
411
|
q && V.push(`text-${q}`);
|
|
411
412
|
}
|
|
412
|
-
let
|
|
413
|
-
return !
|
|
413
|
+
let z = G?.hoverTitle;
|
|
414
|
+
return !z && typeof ye == "string" && (z = ye), /* @__PURE__ */ F(
|
|
414
415
|
"div",
|
|
415
416
|
{
|
|
416
417
|
className: V.join(" "),
|
|
417
|
-
style:
|
|
418
|
-
title:
|
|
418
|
+
style: s,
|
|
419
|
+
title: z,
|
|
419
420
|
draggable: !0,
|
|
420
|
-
onDragStart:
|
|
421
|
+
onDragStart: Ae,
|
|
421
422
|
onDragEnd: Oe,
|
|
422
|
-
onDragOver:
|
|
423
|
-
onDrop:
|
|
423
|
+
onDragOver: Je,
|
|
424
|
+
onDrop: Ve,
|
|
424
425
|
children: [
|
|
425
|
-
/* @__PURE__ */
|
|
426
|
+
/* @__PURE__ */ F(
|
|
426
427
|
"div",
|
|
427
428
|
{
|
|
428
429
|
className: "mig-schema-table__th__label-body",
|
|
429
430
|
style: { lineHeight: "44px" },
|
|
430
|
-
onClick:
|
|
431
|
+
onClick: M,
|
|
431
432
|
children: [
|
|
432
|
-
/* @__PURE__ */ n("span", { className: "mig-schema-table__th__label-body-text", children:
|
|
433
|
-
|
|
433
|
+
/* @__PURE__ */ n("span", { className: "mig-schema-table__th__label-body-text", children: ye }),
|
|
434
|
+
oe === void 0 ? null : /* @__PURE__ */ n("span", { className: "mig-schema-table__th__sort-icon", children: oe ? "↓" : "↑" })
|
|
434
435
|
]
|
|
435
436
|
}
|
|
436
437
|
),
|
|
437
|
-
|
|
438
|
+
Q || re !== $e.UNAVAILABLE ? /* @__PURE__ */ n(
|
|
438
439
|
"button",
|
|
439
440
|
{
|
|
440
441
|
className: "mig-schema-table__th__trigger-el",
|
|
@@ -459,49 +460,49 @@ const on = ({ index: t, style: o }) => {
|
|
|
459
460
|
]
|
|
460
461
|
}
|
|
461
462
|
);
|
|
462
|
-
},
|
|
463
|
-
[
|
|
464
|
-
[
|
|
465
|
-
[
|
|
466
|
-
},
|
|
463
|
+
}, an = e.memo(on), ln = {
|
|
464
|
+
[ge.GT]: ">",
|
|
465
|
+
[ge.LT]: "<",
|
|
466
|
+
[ge.EQ]: "="
|
|
467
|
+
}, cn = e.memo(
|
|
467
468
|
({
|
|
468
469
|
columnFilterValue: t,
|
|
469
|
-
onChange:
|
|
470
|
+
onChange: s,
|
|
470
471
|
onInputKeyDown: u,
|
|
471
|
-
propIsRequired:
|
|
472
|
-
propName:
|
|
473
|
-
propSchema:
|
|
474
|
-
translate:
|
|
472
|
+
propIsRequired: g,
|
|
473
|
+
propName: p,
|
|
474
|
+
propSchema: d,
|
|
475
|
+
translate: I
|
|
475
476
|
}) => {
|
|
476
|
-
const { displayTimezone:
|
|
477
|
-
let
|
|
477
|
+
const { displayTimezone: C } = e.useContext(Me), { type: R, format: S, minimum: A, maximum: O } = d || {}, D = t, w = S === "date-time";
|
|
478
|
+
let $, Z;
|
|
478
479
|
switch (R) {
|
|
479
480
|
case "number":
|
|
480
481
|
case "integer":
|
|
481
|
-
return
|
|
482
|
-
const
|
|
483
|
-
|
|
484
|
-
[
|
|
485
|
-
},
|
|
482
|
+
return $ = D || {}, Z = (c, a, o) => {
|
|
483
|
+
const _ = {
|
|
484
|
+
...$,
|
|
485
|
+
[c]: a.value === "" ? void 0 : parseInt(a.value)
|
|
486
|
+
}, B = Object.values(_).find(
|
|
486
487
|
(te) => isFinite(te)
|
|
487
488
|
);
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
489
|
+
s(
|
|
490
|
+
B !== void 0 && (A === void 0 || B >= A) ? _ : void 0,
|
|
491
|
+
o
|
|
491
492
|
);
|
|
492
|
-
}, /* @__PURE__ */
|
|
493
|
-
|
|
494
|
-
/* @__PURE__ */
|
|
493
|
+
}, /* @__PURE__ */ F("ol", { className: "mig-schema-table-menu mig-schema-table__th-menu__filter-menu-component", children: [
|
|
494
|
+
g ? null : /* @__PURE__ */ F("li", { style: { padding: 8 }, children: [
|
|
495
|
+
/* @__PURE__ */ F("label", { className: "d-flex", children: [
|
|
495
496
|
/* @__PURE__ */ n(
|
|
496
497
|
"input",
|
|
497
498
|
{
|
|
498
499
|
type: "checkbox",
|
|
499
500
|
style: { marginRight: 14 },
|
|
500
|
-
checked:
|
|
501
|
+
checked: !!$.filterEmpty,
|
|
501
502
|
onChange: () => {
|
|
502
|
-
const { filterEmpty:
|
|
503
|
-
|
|
504
|
-
Object.keys(
|
|
503
|
+
const { filterEmpty: c, ...a } = $;
|
|
504
|
+
c || (a.filterEmpty = !0), s(
|
|
505
|
+
Object.keys(a).length ? a : void 0,
|
|
505
506
|
!0
|
|
506
507
|
);
|
|
507
508
|
}
|
|
@@ -511,120 +512,140 @@ const on = ({ index: t, style: o }) => {
|
|
|
511
512
|
] }),
|
|
512
513
|
/* @__PURE__ */ n("hr", {})
|
|
513
514
|
] }),
|
|
514
|
-
Object.keys(
|
|
515
|
-
const
|
|
516
|
-
return /* @__PURE__ */
|
|
517
|
-
/* @__PURE__ */ n("label", { style: { width: 40, paddingLeft: 16 }, children:
|
|
515
|
+
Object.keys(ge).map((c) => {
|
|
516
|
+
const a = $[c];
|
|
517
|
+
return /* @__PURE__ */ F("li", { children: [
|
|
518
|
+
/* @__PURE__ */ n("label", { style: { width: 40, paddingLeft: 16 }, children: ln[c] }),
|
|
518
519
|
/* @__PURE__ */ n(
|
|
519
520
|
"input",
|
|
520
521
|
{
|
|
521
522
|
className: "form-control",
|
|
522
523
|
style: { width: 120 },
|
|
523
524
|
type: "number",
|
|
524
|
-
value:
|
|
525
|
-
"data-prop-name":
|
|
526
|
-
onChange: (
|
|
525
|
+
value: a !== void 0 ? a : "",
|
|
526
|
+
"data-prop-name": p,
|
|
527
|
+
onChange: (o) => {
|
|
527
528
|
Z(
|
|
528
|
-
|
|
529
|
-
|
|
529
|
+
c,
|
|
530
|
+
o.currentTarget,
|
|
530
531
|
!1
|
|
531
532
|
);
|
|
532
533
|
},
|
|
533
|
-
onBlur: (
|
|
534
|
+
onBlur: (o) => {
|
|
534
535
|
Z(
|
|
535
|
-
|
|
536
|
-
|
|
536
|
+
c,
|
|
537
|
+
o.currentTarget,
|
|
537
538
|
!0
|
|
538
539
|
);
|
|
539
540
|
},
|
|
540
541
|
onKeyDown: u,
|
|
541
|
-
min:
|
|
542
|
-
max:
|
|
542
|
+
min: A,
|
|
543
|
+
max: O
|
|
543
544
|
}
|
|
544
545
|
)
|
|
545
|
-
] },
|
|
546
|
+
] }, c);
|
|
546
547
|
})
|
|
547
548
|
] });
|
|
548
549
|
case "boolean":
|
|
549
|
-
|
|
550
|
-
"
|
|
550
|
+
const ee = [
|
|
551
|
+
{ value: "✓", label: "✓" },
|
|
552
|
+
{ value: "✕", label: "✕" }
|
|
553
|
+
];
|
|
554
|
+
g || ee.push({ value: "?", label: "?" });
|
|
555
|
+
let T = null;
|
|
556
|
+
return D === !0 ? T = { value: "✓", label: "✓" } : D === !1 ? T = { value: "✕", label: "✕" } : D === null && (T = { value: "?", label: "?" }), /* @__PURE__ */ n("ol", { className: "mig-schema-table-menu mig-schema-table__th-menu__filter-menu-component", children: /* @__PURE__ */ n("li", { children: /* @__PURE__ */ n(
|
|
557
|
+
dt,
|
|
551
558
|
{
|
|
552
559
|
autoFocus: !0,
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
"
|
|
556
|
-
|
|
557
|
-
|
|
560
|
+
menuIsOpen: !0,
|
|
561
|
+
isClearable: !0,
|
|
562
|
+
placeholder: I("All"),
|
|
563
|
+
className: "react-select-container",
|
|
564
|
+
classNamePrefix: "react-select",
|
|
565
|
+
value: T,
|
|
566
|
+
options: ee,
|
|
567
|
+
styles: {
|
|
568
|
+
menu: (c) => ({
|
|
569
|
+
...c,
|
|
570
|
+
marginTop: 0
|
|
571
|
+
})
|
|
572
|
+
},
|
|
573
|
+
onChange: (c) => {
|
|
574
|
+
if (!c) {
|
|
575
|
+
s(void 0, !0);
|
|
576
|
+
return;
|
|
577
|
+
}
|
|
578
|
+
switch (c.value) {
|
|
558
579
|
case "✓":
|
|
559
|
-
|
|
580
|
+
s(!0, !0);
|
|
560
581
|
break;
|
|
561
582
|
case "✕":
|
|
562
|
-
|
|
583
|
+
s(!1, !0);
|
|
563
584
|
break;
|
|
564
585
|
case "?":
|
|
565
|
-
|
|
586
|
+
s(null, !0);
|
|
566
587
|
break;
|
|
567
588
|
default:
|
|
568
|
-
|
|
589
|
+
s(void 0, !0);
|
|
569
590
|
}
|
|
570
591
|
},
|
|
571
|
-
|
|
572
|
-
/* @__PURE__ */ n("option", { value: "", children: "All" }, "all"),
|
|
573
|
-
Y.map((s) => /* @__PURE__ */ n(
|
|
574
|
-
"option",
|
|
575
|
-
{
|
|
576
|
-
value: s,
|
|
577
|
-
children: s
|
|
578
|
-
},
|
|
579
|
-
`column-filter-select-${s}`
|
|
580
|
-
))
|
|
581
|
-
]
|
|
592
|
+
onKeyDown: u
|
|
582
593
|
}
|
|
583
594
|
) }) });
|
|
584
595
|
// @ts-expect-error falls through
|
|
585
596
|
case "string":
|
|
586
|
-
if (
|
|
587
|
-
|
|
588
|
-
|
|
597
|
+
if (d?.enum) {
|
|
598
|
+
const c = d.enum.map((o) => ({
|
|
599
|
+
value: o,
|
|
600
|
+
label: I(o)
|
|
601
|
+
})), a = c.filter(
|
|
602
|
+
(o) => (D || []).includes(o.value)
|
|
603
|
+
);
|
|
604
|
+
return /* @__PURE__ */ n("ol", { className: "mig-schema-table-menu mig-schema-table__th-menu__filter-menu-component", children: /* @__PURE__ */ n("li", { children: /* @__PURE__ */ n(
|
|
605
|
+
dt,
|
|
589
606
|
{
|
|
607
|
+
isMulti: !0,
|
|
590
608
|
autoFocus: !0,
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
"
|
|
594
|
-
|
|
595
|
-
|
|
609
|
+
menuIsOpen: !0,
|
|
610
|
+
className: "react-select-container",
|
|
611
|
+
classNamePrefix: "react-select",
|
|
612
|
+
value: a,
|
|
613
|
+
options: c,
|
|
614
|
+
styles: {
|
|
615
|
+
menu: (o) => ({
|
|
616
|
+
...o,
|
|
617
|
+
marginTop: 0
|
|
618
|
+
})
|
|
596
619
|
},
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
`column-filter-select-${s}`
|
|
606
|
-
))
|
|
607
|
-
]
|
|
620
|
+
onChange: (o) => {
|
|
621
|
+
const _ = o ? o.map(
|
|
622
|
+
(B) => B.value
|
|
623
|
+
) : [];
|
|
624
|
+
s(_.length ? _ : void 0, !0);
|
|
625
|
+
},
|
|
626
|
+
onKeyDown: u,
|
|
627
|
+
placeholder: I("Select...")
|
|
608
628
|
}
|
|
609
629
|
) }) });
|
|
610
|
-
|
|
611
|
-
|
|
630
|
+
}
|
|
631
|
+
if (w || S === "date") {
|
|
632
|
+
const c = w ? Pe : vt, a = t || {
|
|
612
633
|
from: void 0,
|
|
613
634
|
to: void 0,
|
|
614
635
|
filterEmpty: void 0
|
|
615
636
|
};
|
|
616
|
-
return /* @__PURE__ */
|
|
617
|
-
|
|
618
|
-
/* @__PURE__ */
|
|
637
|
+
return /* @__PURE__ */ F("ol", { className: "mig-schema-table-menu mig-schema-table__th-menu__filter-menu-component", children: [
|
|
638
|
+
g ? null : /* @__PURE__ */ F("li", { style: { padding: 8 }, children: [
|
|
639
|
+
/* @__PURE__ */ F("label", { className: "d-flex", children: [
|
|
619
640
|
/* @__PURE__ */ n(
|
|
620
641
|
"input",
|
|
621
642
|
{
|
|
622
643
|
type: "checkbox",
|
|
623
|
-
checked: !!
|
|
644
|
+
checked: !!a.filterEmpty,
|
|
624
645
|
onChange: () => {
|
|
625
|
-
const { filterEmpty:
|
|
626
|
-
|
|
627
|
-
Object.keys(
|
|
646
|
+
const { filterEmpty: o, ..._ } = a;
|
|
647
|
+
o || (_.filterEmpty = !0), s(
|
|
648
|
+
Object.keys(_).length ? _ : void 0,
|
|
628
649
|
!0
|
|
629
650
|
);
|
|
630
651
|
}
|
|
@@ -634,82 +655,82 @@ const on = ({ index: t, style: o }) => {
|
|
|
634
655
|
] }),
|
|
635
656
|
/* @__PURE__ */ n("hr", {})
|
|
636
657
|
] }),
|
|
637
|
-
/* @__PURE__ */
|
|
658
|
+
/* @__PURE__ */ F("li", { style: { padding: 8 }, children: [
|
|
638
659
|
/* @__PURE__ */ n("label", { style: { width: 120, paddingLeft: 4 }, children: "After" }),
|
|
639
660
|
/* @__PURE__ */ n(
|
|
640
661
|
ut,
|
|
641
662
|
{
|
|
642
|
-
dateFormat:
|
|
643
|
-
"data-prop-name":
|
|
644
|
-
locale:
|
|
645
|
-
selected:
|
|
646
|
-
|
|
663
|
+
dateFormat: c,
|
|
664
|
+
"data-prop-name": p,
|
|
665
|
+
locale: mt,
|
|
666
|
+
selected: a.from ? new Ue(a.from).withTimeZone(
|
|
667
|
+
C || Te
|
|
647
668
|
) : null,
|
|
648
|
-
onChange: (
|
|
649
|
-
if (!
|
|
650
|
-
|
|
669
|
+
onChange: (o) => {
|
|
670
|
+
if (!o && !a.to) {
|
|
671
|
+
s(void 0, !0);
|
|
651
672
|
return;
|
|
652
673
|
}
|
|
653
|
-
if (
|
|
674
|
+
if (a.to && o && o > a.to)
|
|
654
675
|
return;
|
|
655
|
-
const
|
|
656
|
-
|
|
676
|
+
const _ = o ? Ue.tz(C || Te, o) : void 0;
|
|
677
|
+
s(
|
|
657
678
|
{
|
|
658
679
|
...t,
|
|
659
|
-
from:
|
|
680
|
+
from: _
|
|
660
681
|
},
|
|
661
682
|
!0
|
|
662
683
|
);
|
|
663
684
|
},
|
|
664
|
-
placeholderText:
|
|
685
|
+
placeholderText: c,
|
|
665
686
|
isClearable: !0,
|
|
666
687
|
selectsStart: !0,
|
|
667
|
-
showTimeSelect:
|
|
668
|
-
showTimeInput:
|
|
688
|
+
showTimeSelect: w,
|
|
689
|
+
showTimeInput: w,
|
|
669
690
|
showMonthDropdown: !0,
|
|
670
691
|
showYearDropdown: !0,
|
|
671
692
|
timeIntervals: 15,
|
|
672
|
-
shouldCloseOnSelect: !
|
|
693
|
+
shouldCloseOnSelect: !w
|
|
673
694
|
}
|
|
674
695
|
)
|
|
675
696
|
] }),
|
|
676
|
-
/* @__PURE__ */
|
|
697
|
+
/* @__PURE__ */ F("li", { style: { padding: 8 }, children: [
|
|
677
698
|
/* @__PURE__ */ n("label", { style: { width: 120, paddingLeft: 4 }, children: "Before" }),
|
|
678
699
|
/* @__PURE__ */ n(
|
|
679
700
|
ut,
|
|
680
701
|
{
|
|
681
702
|
id: "filter-date",
|
|
682
|
-
dateFormat:
|
|
683
|
-
"data-prop-name":
|
|
684
|
-
locale:
|
|
703
|
+
dateFormat: c,
|
|
704
|
+
"data-prop-name": p,
|
|
705
|
+
locale: mt,
|
|
685
706
|
selectsEnd: !0,
|
|
686
|
-
selected:
|
|
687
|
-
|
|
707
|
+
selected: a.to ? new Ue(a.to).withTimeZone(
|
|
708
|
+
C || Te
|
|
688
709
|
) : null,
|
|
689
710
|
showMonthDropdown: !0,
|
|
690
711
|
showYearDropdown: !0,
|
|
691
|
-
onChange: (
|
|
692
|
-
if (!
|
|
693
|
-
|
|
712
|
+
onChange: (o) => {
|
|
713
|
+
if (!o && !a.from) {
|
|
714
|
+
s(void 0, !0);
|
|
694
715
|
return;
|
|
695
716
|
}
|
|
696
|
-
const
|
|
697
|
-
|
|
717
|
+
const _ = o ? w ? Ue.tz(C || Te, o) : Ut(o) : void 0;
|
|
718
|
+
a.from && _ && _ < a.from || s(
|
|
698
719
|
{
|
|
699
720
|
...t,
|
|
700
|
-
to:
|
|
721
|
+
to: _
|
|
701
722
|
},
|
|
702
723
|
!0
|
|
703
724
|
);
|
|
704
725
|
},
|
|
705
|
-
placeholderText:
|
|
726
|
+
placeholderText: c,
|
|
706
727
|
isClearable: !0,
|
|
707
|
-
startDate:
|
|
708
|
-
endDate:
|
|
709
|
-
showTimeInput:
|
|
710
|
-
showTimeSelect:
|
|
728
|
+
startDate: a.from,
|
|
729
|
+
endDate: a.to,
|
|
730
|
+
showTimeInput: w,
|
|
731
|
+
showTimeSelect: w,
|
|
711
732
|
timeIntervals: 15,
|
|
712
|
-
shouldCloseOnSelect: !
|
|
733
|
+
shouldCloseOnSelect: !w
|
|
713
734
|
}
|
|
714
735
|
)
|
|
715
736
|
] })
|
|
@@ -723,103 +744,111 @@ const on = ({ index: t, style: o }) => {
|
|
|
723
744
|
autoFocus: !0,
|
|
724
745
|
type: "search",
|
|
725
746
|
className: "form-control",
|
|
726
|
-
placeholder: `Search ${
|
|
727
|
-
"aria-label": `Search ${
|
|
728
|
-
value:
|
|
729
|
-
"data-prop-name":
|
|
730
|
-
onChange: (
|
|
731
|
-
|
|
747
|
+
placeholder: `Search ${p}`,
|
|
748
|
+
"aria-label": `Search ${p}`,
|
|
749
|
+
value: Array.isArray(D) ? D.join(", ") : D || "",
|
|
750
|
+
"data-prop-name": p,
|
|
751
|
+
onChange: (c) => {
|
|
752
|
+
const a = c.currentTarget.value, o = a ? a.split(",").map((_) => _.trim()) : [];
|
|
753
|
+
s(
|
|
754
|
+
(o.length > 1 ? o : o[0]) || void 0,
|
|
755
|
+
!1
|
|
756
|
+
);
|
|
732
757
|
},
|
|
733
758
|
onKeyDown: u,
|
|
734
|
-
onBlur: (
|
|
735
|
-
|
|
759
|
+
onBlur: (c) => {
|
|
760
|
+
const a = c.currentTarget.value, o = a ? a.split(",").map((_) => _.trim()) : [];
|
|
761
|
+
s(
|
|
762
|
+
(o.length > 1 ? o : o[0]) || void 0,
|
|
763
|
+
!0
|
|
764
|
+
);
|
|
736
765
|
}
|
|
737
766
|
}
|
|
738
767
|
) }) });
|
|
739
768
|
}
|
|
740
769
|
}
|
|
741
|
-
),
|
|
770
|
+
), un = ({
|
|
742
771
|
isSortable: t,
|
|
743
|
-
isFilterable:
|
|
772
|
+
isFilterable: s,
|
|
744
773
|
onChange: u,
|
|
745
|
-
onClose:
|
|
746
|
-
onInputKeyDown:
|
|
747
|
-
propConfig:
|
|
748
|
-
propIsRequired:
|
|
749
|
-
propName:
|
|
774
|
+
onClose: g,
|
|
775
|
+
onInputKeyDown: p,
|
|
776
|
+
propConfig: d,
|
|
777
|
+
propIsRequired: I,
|
|
778
|
+
propName: C,
|
|
750
779
|
propSchema: R,
|
|
751
|
-
referenceElement:
|
|
752
|
-
setFilterSortColumn:
|
|
753
|
-
translate:
|
|
754
|
-
value:
|
|
780
|
+
referenceElement: S,
|
|
781
|
+
setFilterSortColumn: A,
|
|
782
|
+
translate: O,
|
|
783
|
+
value: D
|
|
755
784
|
}) => {
|
|
756
|
-
const
|
|
785
|
+
const w = ht({
|
|
757
786
|
placement: "bottom-start",
|
|
758
787
|
elements: {
|
|
759
|
-
reference:
|
|
788
|
+
reference: S
|
|
760
789
|
},
|
|
761
|
-
middleware: [
|
|
762
|
-
}),
|
|
790
|
+
middleware: [ft()]
|
|
791
|
+
}), $ = ht({
|
|
763
792
|
placement: "right-start",
|
|
764
|
-
middleware: [
|
|
793
|
+
middleware: [ft()]
|
|
765
794
|
});
|
|
766
795
|
e.useEffect(() => {
|
|
767
|
-
const
|
|
768
|
-
if (!
|
|
796
|
+
const a = (o) => {
|
|
797
|
+
if (!w.elements.floating)
|
|
769
798
|
return;
|
|
770
|
-
let
|
|
771
|
-
for (;
|
|
772
|
-
if (
|
|
799
|
+
let _ = o.target;
|
|
800
|
+
for (; _ && w.elements.floating; ) {
|
|
801
|
+
if (_ === w.elements.floating || _ === $.elements.floating)
|
|
773
802
|
return;
|
|
774
|
-
|
|
803
|
+
_ = _.parentNode === window.document ? null : _.parentNode;
|
|
775
804
|
}
|
|
776
|
-
|
|
805
|
+
g(o);
|
|
777
806
|
};
|
|
778
|
-
return window.addEventListener("click",
|
|
779
|
-
window.removeEventListener("click",
|
|
807
|
+
return window.addEventListener("click", a, { capture: !0 }), () => {
|
|
808
|
+
window.removeEventListener("click", a, { capture: !0 });
|
|
780
809
|
};
|
|
781
810
|
}, [
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
|
|
811
|
+
w.elements.floating,
|
|
812
|
+
g,
|
|
813
|
+
$.elements.floating
|
|
785
814
|
]);
|
|
786
|
-
const Z =
|
|
787
|
-
(
|
|
788
|
-
|
|
815
|
+
const Z = d?.FilterMenu || cn, ee = e.useCallback(
|
|
816
|
+
(a) => {
|
|
817
|
+
A(C, !0), g(a);
|
|
789
818
|
},
|
|
790
|
-
[
|
|
791
|
-
),
|
|
792
|
-
(
|
|
793
|
-
|
|
819
|
+
[g, C, A]
|
|
820
|
+
), T = e.useCallback(
|
|
821
|
+
(a) => {
|
|
822
|
+
A(C, !1), g(a);
|
|
794
823
|
},
|
|
795
|
-
[
|
|
796
|
-
),
|
|
824
|
+
[g, C, A]
|
|
825
|
+
), c = e.useCallback(() => {
|
|
797
826
|
u(void 0, !0);
|
|
798
827
|
}, [u]);
|
|
799
|
-
return !t && !
|
|
828
|
+
return !t && !s ? null : /* @__PURE__ */ F(jt, { children: [
|
|
800
829
|
/* @__PURE__ */ n(
|
|
801
830
|
"div",
|
|
802
831
|
{
|
|
803
832
|
className: "mig-schema-table mig-schema-table__th-menu",
|
|
804
|
-
ref:
|
|
805
|
-
style:
|
|
806
|
-
children: /* @__PURE__ */
|
|
807
|
-
t ? /* @__PURE__ */
|
|
833
|
+
ref: w.refs.setFloating,
|
|
834
|
+
style: w.floatingStyles,
|
|
835
|
+
children: /* @__PURE__ */ F("ol", { className: "mig-schema-table-menu", children: [
|
|
836
|
+
t ? /* @__PURE__ */ F("li", { onClick: ee, style: { padding: 8 }, children: [
|
|
808
837
|
/* @__PURE__ */ n("span", { className: "mig-schema-table__th-menu__icon", children: "↓" }),
|
|
809
838
|
" ",
|
|
810
|
-
|
|
839
|
+
O("sortAscending")
|
|
811
840
|
] }) : null,
|
|
812
|
-
t ? /* @__PURE__ */
|
|
841
|
+
t ? /* @__PURE__ */ F("li", { onClick: T, style: { padding: 8 }, children: [
|
|
813
842
|
/* @__PURE__ */ n("span", { className: "mig-schema-table__th-menu__icon", children: "↑" }),
|
|
814
843
|
" ",
|
|
815
|
-
|
|
844
|
+
O("sortDescending")
|
|
816
845
|
] }) : null,
|
|
817
|
-
|
|
846
|
+
s ? /* @__PURE__ */ F(
|
|
818
847
|
"li",
|
|
819
848
|
{
|
|
820
849
|
style: { padding: 8 },
|
|
821
|
-
onMouseOver: (
|
|
822
|
-
|
|
850
|
+
onMouseOver: (a) => {
|
|
851
|
+
$.refs.setReference(a.currentTarget);
|
|
823
852
|
},
|
|
824
853
|
children: [
|
|
825
854
|
/* @__PURE__ */ n("span", { className: "mig-schema-table__th-menu__icon", children: /* @__PURE__ */ n(
|
|
@@ -827,12 +856,12 @@ const on = ({ index: t, style: o }) => {
|
|
|
827
856
|
{
|
|
828
857
|
type: "checkbox",
|
|
829
858
|
id: "mig-schema-table__th-menu__filters",
|
|
830
|
-
checked:
|
|
831
|
-
disabled:
|
|
832
|
-
onChange:
|
|
859
|
+
checked: D !== void 0,
|
|
860
|
+
disabled: D === void 0,
|
|
861
|
+
onChange: c
|
|
833
862
|
}
|
|
834
863
|
) }),
|
|
835
|
-
/* @__PURE__ */ n("label", { htmlFor: "mig-schema-table__th-menu__filters", children:
|
|
864
|
+
/* @__PURE__ */ n("label", { htmlFor: "mig-schema-table__th-menu__filters", children: O("filters") }),
|
|
836
865
|
/* @__PURE__ */ n("div", { className: "mig-schema-table__th-menu__sub-menu-indicator" })
|
|
837
866
|
]
|
|
838
867
|
}
|
|
@@ -840,91 +869,91 @@ const on = ({ index: t, style: o }) => {
|
|
|
840
869
|
] })
|
|
841
870
|
}
|
|
842
871
|
),
|
|
843
|
-
|
|
872
|
+
$.elements.reference ? /* @__PURE__ */ n(
|
|
844
873
|
"div",
|
|
845
874
|
{
|
|
846
875
|
className: "mig-schema-table mig-schema-table__th-menu__sub-menu",
|
|
847
|
-
ref:
|
|
848
|
-
style:
|
|
876
|
+
ref: $.refs.setFloating,
|
|
877
|
+
style: $.floatingStyles,
|
|
849
878
|
children: /* @__PURE__ */ n(
|
|
850
879
|
Z,
|
|
851
880
|
{
|
|
852
|
-
columnFilterValue:
|
|
881
|
+
columnFilterValue: D,
|
|
853
882
|
onChange: u,
|
|
854
|
-
onInputKeyDown:
|
|
855
|
-
propIsRequired:
|
|
856
|
-
propName:
|
|
883
|
+
onInputKeyDown: p,
|
|
884
|
+
propIsRequired: I,
|
|
885
|
+
propName: C,
|
|
857
886
|
propSchema: R,
|
|
858
|
-
translate:
|
|
887
|
+
translate: O
|
|
859
888
|
}
|
|
860
889
|
)
|
|
861
890
|
}
|
|
862
891
|
) : null
|
|
863
892
|
] });
|
|
864
|
-
},
|
|
893
|
+
}, dn = e.memo(un), mn = ({
|
|
865
894
|
columnWidths: t,
|
|
866
|
-
resizeColumnIndex:
|
|
895
|
+
resizeColumnIndex: s,
|
|
867
896
|
setResizeColumnIndex: u,
|
|
868
|
-
tableBodyHeight:
|
|
897
|
+
tableBodyHeight: g
|
|
869
898
|
}) => {
|
|
870
|
-
const [
|
|
871
|
-
(
|
|
872
|
-
const
|
|
873
|
-
(
|
|
899
|
+
const [p, d] = e.useState(0), I = Dt(), C = e.useCallback(
|
|
900
|
+
(O) => {
|
|
901
|
+
const D = t.map(
|
|
902
|
+
(w, $) => $ === s ? Math.max(w + O, kt) : w
|
|
874
903
|
);
|
|
875
|
-
|
|
904
|
+
I(D);
|
|
876
905
|
},
|
|
877
|
-
[t,
|
|
906
|
+
[t, s, I]
|
|
878
907
|
);
|
|
879
908
|
let R = 0;
|
|
880
|
-
const
|
|
881
|
-
(
|
|
882
|
-
u(parseInt(
|
|
909
|
+
const S = e.useCallback(
|
|
910
|
+
(O) => {
|
|
911
|
+
u(parseInt(O.currentTarget.dataset.columnIndex)), d(O.clientX);
|
|
883
912
|
},
|
|
884
913
|
[u]
|
|
885
|
-
),
|
|
886
|
-
(
|
|
887
|
-
|
|
914
|
+
), A = e.useCallback(
|
|
915
|
+
(O) => {
|
|
916
|
+
C(O.clientX - p), d(0), u(-1);
|
|
888
917
|
},
|
|
889
|
-
[
|
|
918
|
+
[p, C, u]
|
|
890
919
|
);
|
|
891
|
-
return /* @__PURE__ */ n("div", { children: [...t].map((
|
|
892
|
-
R +=
|
|
893
|
-
const
|
|
894
|
-
return
|
|
920
|
+
return /* @__PURE__ */ n("div", { children: [...t].map((O, D) => {
|
|
921
|
+
R += O;
|
|
922
|
+
const w = ["mig-schema-table__column_resizer"];
|
|
923
|
+
return D === s && w.push("mig-schema-table__column_resizer--dragged"), /* @__PURE__ */ n(
|
|
895
924
|
"div",
|
|
896
925
|
{
|
|
897
|
-
style: { left: R -
|
|
898
|
-
className:
|
|
926
|
+
style: { left: R - tn, bottom: g },
|
|
927
|
+
className: w.join(" "),
|
|
899
928
|
draggable: "true",
|
|
900
|
-
"data-column-index":
|
|
901
|
-
onDragStart:
|
|
902
|
-
onDragEnd:
|
|
929
|
+
"data-column-index": D,
|
|
930
|
+
onDragStart: S,
|
|
931
|
+
onDragEnd: A
|
|
903
932
|
},
|
|
904
|
-
|
|
933
|
+
D
|
|
905
934
|
);
|
|
906
935
|
}) });
|
|
907
|
-
},
|
|
908
|
-
const [
|
|
909
|
-
() =>
|
|
936
|
+
}, Ct = (t) => {
|
|
937
|
+
const [s, u] = e.useState({ width: 0, height: 0 }), g = e.useMemo(
|
|
938
|
+
() => qt(u, 100),
|
|
910
939
|
[]
|
|
911
940
|
);
|
|
912
941
|
return e.useEffect(() => {
|
|
913
942
|
if (!t)
|
|
914
943
|
return;
|
|
915
|
-
const
|
|
916
|
-
for (const
|
|
917
|
-
const { blockSize:
|
|
918
|
-
|
|
919
|
-
(
|
|
944
|
+
const p = new ResizeObserver((d) => {
|
|
945
|
+
for (const I of d) {
|
|
946
|
+
const { blockSize: C, inlineSize: R } = I.borderBoxSize[0];
|
|
947
|
+
g(
|
|
948
|
+
(S) => R && C && (S.width !== R || S.height !== C) ? { width: R, height: C } : S
|
|
920
949
|
);
|
|
921
950
|
}
|
|
922
951
|
});
|
|
923
|
-
return
|
|
924
|
-
|
|
952
|
+
return p.observe(t), () => {
|
|
953
|
+
p.disconnect();
|
|
925
954
|
};
|
|
926
|
-
}, [
|
|
927
|
-
},
|
|
955
|
+
}, [g, t]), s;
|
|
956
|
+
}, hn = () => new Promise((t, s) => {
|
|
928
957
|
if (window.ExcelJS) {
|
|
929
958
|
t(window.ExcelJS);
|
|
930
959
|
return;
|
|
@@ -933,453 +962,465 @@ const on = ({ index: t, style: o }) => {
|
|
|
933
962
|
u.src = "https://cdnjs.cloudflare.com/ajax/libs/exceljs/4.4.0/exceljs.bare.min.js", u.onload = () => {
|
|
934
963
|
t(window.ExcelJS);
|
|
935
964
|
}, u.onerror = () => {
|
|
936
|
-
|
|
965
|
+
s(new Error("Failed to load ExcelJS library"));
|
|
937
966
|
}, document.head.appendChild(u);
|
|
938
|
-
}),
|
|
939
|
-
const { Workbook:
|
|
940
|
-
t.length && (
|
|
941
|
-
|
|
967
|
+
}), fn = async (t) => {
|
|
968
|
+
const { Workbook: s } = await hn(), u = new s(), g = u.addWorksheet("Data");
|
|
969
|
+
t.length && (g.addRow(
|
|
970
|
+
Gt(Object.keys(t[0]), [
|
|
942
971
|
"_index",
|
|
943
972
|
"SELECT_ALL_COLUMN_NAME"
|
|
944
973
|
])
|
|
945
|
-
),
|
|
946
|
-
t.map((
|
|
947
|
-
const { _index:
|
|
948
|
-
return Object.values(
|
|
974
|
+
), g.getRow(1).font = { bold: !0 }, g.addRows(
|
|
975
|
+
t.map((p) => {
|
|
976
|
+
const { _index: d, SELECT_ALL_COLUMN_NAME: I, ...C } = p;
|
|
977
|
+
return Object.values(C);
|
|
949
978
|
})
|
|
950
|
-
), u.xlsx.writeBuffer().then((
|
|
951
|
-
const
|
|
979
|
+
), u.xlsx.writeBuffer().then((p) => {
|
|
980
|
+
const d = new Blob([p], {
|
|
952
981
|
type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
|
|
953
982
|
});
|
|
954
|
-
|
|
955
|
-
}).catch((
|
|
956
|
-
console.error("Error generating Excel file:",
|
|
983
|
+
Kt(d, "export.xlsx");
|
|
984
|
+
}).catch((p) => {
|
|
985
|
+
console.error("Error generating Excel file:", p);
|
|
957
986
|
}));
|
|
958
|
-
},
|
|
987
|
+
}, yt = /* @__PURE__ */ new Date("1000-01-01 00:00:00Z"), bn = new Intl.NumberFormat("nl-NL"), gn = new Intl.NumberFormat("nl-NL", {
|
|
959
988
|
style: "currency",
|
|
960
989
|
currency: "EUR"
|
|
961
990
|
});
|
|
962
|
-
function
|
|
963
|
-
const { TdBody: u, sortByValue:
|
|
964
|
-
if (
|
|
965
|
-
return
|
|
991
|
+
function pn(t, s) {
|
|
992
|
+
const { TdBody: u, sortByValue: g } = s || {};
|
|
993
|
+
if (g !== void 0)
|
|
994
|
+
return g;
|
|
966
995
|
if (!t)
|
|
967
996
|
return !1;
|
|
968
|
-
const { format:
|
|
969
|
-
return
|
|
997
|
+
const { format: p, type: d } = t;
|
|
998
|
+
return p?.startsWith("date") || d === "boolean" || d === "integer" || d === "number" || !!u;
|
|
970
999
|
}
|
|
971
|
-
const
|
|
1000
|
+
const _n = ({
|
|
972
1001
|
CustomElement: t,
|
|
973
|
-
CustomSearchInput:
|
|
974
|
-
Heading: u =
|
|
975
|
-
autoRender:
|
|
976
|
-
checkedIndexes:
|
|
977
|
-
config:
|
|
978
|
-
customElementProps:
|
|
979
|
-
data:
|
|
1002
|
+
CustomSearchInput: s,
|
|
1003
|
+
Heading: u = Qt,
|
|
1004
|
+
autoRender: g,
|
|
1005
|
+
checkedIndexes: p,
|
|
1006
|
+
config: d,
|
|
1007
|
+
customElementProps: I,
|
|
1008
|
+
data: C,
|
|
980
1009
|
defaultColumnFilters: R,
|
|
981
|
-
defaultSortAsc:
|
|
982
|
-
defaultSortColumn:
|
|
983
|
-
disabledCheckedIndexes:
|
|
984
|
-
displayTimezone:
|
|
985
|
-
enableAutoFocus:
|
|
986
|
-
enableRowCounter:
|
|
1010
|
+
defaultSortAsc: S = !1,
|
|
1011
|
+
defaultSortColumn: A,
|
|
1012
|
+
disabledCheckedIndexes: O,
|
|
1013
|
+
displayTimezone: D,
|
|
1014
|
+
enableAutoFocus: w = !0,
|
|
1015
|
+
enableRowCounter: $ = !0,
|
|
987
1016
|
getRowClassName: Z,
|
|
988
|
-
getRowSelected:
|
|
989
|
-
getSearchQueryFilterResult:
|
|
990
|
-
infiniteLoaderRef:
|
|
991
|
-
isColumnFilterable:
|
|
992
|
-
isExportable:
|
|
993
|
-
isResizable:
|
|
994
|
-
isSearchable:
|
|
1017
|
+
getRowSelected: ee,
|
|
1018
|
+
getSearchQueryFilterResult: T,
|
|
1019
|
+
infiniteLoaderRef: c,
|
|
1020
|
+
isColumnFilterable: a = !0,
|
|
1021
|
+
isExportable: o = !0,
|
|
1022
|
+
isResizable: _ = !0,
|
|
1023
|
+
isSearchable: B = !0,
|
|
995
1024
|
isSortable: te = !0,
|
|
996
1025
|
itemCount: le,
|
|
997
1026
|
loadMoreItems: ne,
|
|
998
|
-
maxHeight:
|
|
1027
|
+
maxHeight: y,
|
|
999
1028
|
onRowClick: L,
|
|
1000
|
-
onRowDoubleClick:
|
|
1029
|
+
onRowDoubleClick: oe,
|
|
1001
1030
|
onSearchEnter: G,
|
|
1002
1031
|
onTableDataStateChange: re,
|
|
1003
|
-
rowHeight:
|
|
1032
|
+
rowHeight: Q = 36,
|
|
1004
1033
|
schema: V,
|
|
1005
|
-
searchPlaceholder:
|
|
1034
|
+
searchPlaceholder: Ce,
|
|
1006
1035
|
setCheckedIndexes: q,
|
|
1007
1036
|
settingsStorageKey: v,
|
|
1008
|
-
style:
|
|
1009
|
-
translate: k =
|
|
1010
|
-
useFilterStateHash:
|
|
1037
|
+
style: N,
|
|
1038
|
+
translate: k = bt,
|
|
1039
|
+
useFilterStateHash: M,
|
|
1011
1040
|
variableSizeGridRef: ce,
|
|
1012
1041
|
width: me
|
|
1013
1042
|
}) => {
|
|
1014
|
-
const [
|
|
1015
|
-
J ? void 0 :
|
|
1016
|
-
), [fe, qe] = e.useState(), [
|
|
1043
|
+
const [ye, se] = e.useState(), [Ae, Oe] = e.useState(), [Je, Ve] = e.useState(-1), [Ee, Ze] = e.useState(-1), [z, j] = e.useState(), [he, we] = e.useState(), J = C instanceof Function, [x, pe] = e.useState(
|
|
1044
|
+
J ? void 0 : C
|
|
1045
|
+
), [fe, qe] = e.useState(), [i, ke] = e.useState({
|
|
1017
1046
|
searchQuery: "",
|
|
1018
1047
|
columnFilterMap: R || {},
|
|
1019
|
-
sortColumn:
|
|
1020
|
-
sortAsc:
|
|
1021
|
-
}), [
|
|
1022
|
-
|
|
1048
|
+
sortColumn: A,
|
|
1049
|
+
sortAsc: S
|
|
1050
|
+
}), [U, Tt] = e.useState(
|
|
1051
|
+
M ? ct(window.location.hash) : null
|
|
1023
1052
|
);
|
|
1024
1053
|
e.useEffect(() => {
|
|
1025
|
-
J ||
|
|
1026
|
-
}, [
|
|
1027
|
-
!J || x !== void 0 ||
|
|
1028
|
-
|
|
1029
|
-
...
|
|
1030
|
-
columnFilterMap:
|
|
1031
|
-
} :
|
|
1032
|
-
).then(
|
|
1033
|
-
}, [
|
|
1034
|
-
fe || qe(
|
|
1035
|
-
}, [
|
|
1036
|
-
if (!
|
|
1054
|
+
J || pe(C);
|
|
1055
|
+
}, [C, J]), e.useEffect(() => {
|
|
1056
|
+
!J || x !== void 0 || C(
|
|
1057
|
+
U && Object.keys(U).length !== 0 ? {
|
|
1058
|
+
...U,
|
|
1059
|
+
columnFilterMap: U.columnFilterMap || {}
|
|
1060
|
+
} : i
|
|
1061
|
+
).then(pe);
|
|
1062
|
+
}, [C, J, U, x, i]), e.useEffect(() => {
|
|
1063
|
+
fe || qe(i);
|
|
1064
|
+
}, [i, fe]), e.useEffect(() => {
|
|
1065
|
+
if (!M)
|
|
1037
1066
|
return;
|
|
1038
1067
|
const r = () => {
|
|
1039
|
-
|
|
1068
|
+
Tt(ct(window.location.hash));
|
|
1040
1069
|
};
|
|
1041
1070
|
return window.addEventListener("hashchange", r), () => {
|
|
1042
1071
|
window.removeEventListener("hashchange", r);
|
|
1043
1072
|
};
|
|
1044
|
-
}, [
|
|
1045
|
-
if (!
|
|
1073
|
+
}, [M]), e.useEffect(() => {
|
|
1074
|
+
if (!M)
|
|
1046
1075
|
return;
|
|
1047
|
-
const { columnFilterMap: r, searchQuery:
|
|
1048
|
-
searchQuery:
|
|
1076
|
+
const { columnFilterMap: r, searchQuery: m, sortAsc: h, sortColumn: l } = U || {}, f = {
|
|
1077
|
+
searchQuery: m || "",
|
|
1049
1078
|
columnFilterMap: r || R || {},
|
|
1050
|
-
sortAsc:
|
|
1051
|
-
sortColumn:
|
|
1079
|
+
sortAsc: h === void 0 ? S : h,
|
|
1080
|
+
sortColumn: l === void 0 ? A : l
|
|
1052
1081
|
};
|
|
1053
1082
|
ke(
|
|
1054
|
-
(
|
|
1083
|
+
(E) => et(f, E) ? E : f
|
|
1055
1084
|
);
|
|
1056
1085
|
}, [
|
|
1057
|
-
|
|
1058
|
-
|
|
1086
|
+
U,
|
|
1087
|
+
M,
|
|
1059
1088
|
R,
|
|
1060
|
-
|
|
1061
|
-
|
|
1089
|
+
S,
|
|
1090
|
+
A
|
|
1062
1091
|
]), e.useEffect(() => {
|
|
1063
|
-
re && re(
|
|
1064
|
-
}, [re,
|
|
1065
|
-
const nt = e.useRef(null), rt = e.useRef(null), Re =
|
|
1092
|
+
re && re(i);
|
|
1093
|
+
}, [re, i]);
|
|
1094
|
+
const nt = e.useRef(null), rt = e.useRef(null), Re = Ct(nt.current), st = Ct(
|
|
1066
1095
|
rt.current
|
|
1067
|
-
),
|
|
1096
|
+
), Le = e.useMemo(
|
|
1068
1097
|
() => me || Math.floor(Re.width || 0),
|
|
1069
1098
|
[Re.width, me]
|
|
1070
|
-
), Ne = e.useMemo(() => !et(
|
|
1099
|
+
), Ne = e.useMemo(() => !et(i, fe) && J, [i, fe, J]), { properties: ae, required: Mt } = e.useMemo(
|
|
1071
1100
|
() => ({
|
|
1072
1101
|
properties: {},
|
|
1073
1102
|
required: [],
|
|
1074
1103
|
...V
|
|
1075
1104
|
}),
|
|
1076
1105
|
[V]
|
|
1077
|
-
), We = v ? localStorage.getItem(`${v}.columnNames`) : null,
|
|
1078
|
-
if (
|
|
1079
|
-
return
|
|
1106
|
+
), We = v ? localStorage.getItem(`${v}.columnNames`) : null, je = v ? localStorage.getItem(`${v}.columnWidths`) : null, H = e.useMemo(() => {
|
|
1107
|
+
if (ye)
|
|
1108
|
+
return ye;
|
|
1080
1109
|
const r = We ? JSON.parse(We) : void 0;
|
|
1081
|
-
let
|
|
1082
|
-
if (q &&
|
|
1083
|
-
Object.keys(
|
|
1084
|
-
|
|
1110
|
+
let m = Object.keys(ae);
|
|
1111
|
+
if (q && m.unshift(K), d) {
|
|
1112
|
+
Object.keys(d).forEach((l) => {
|
|
1113
|
+
m.includes(l) || m.push(l);
|
|
1085
1114
|
});
|
|
1086
|
-
const
|
|
1087
|
-
(
|
|
1115
|
+
const h = Object.entries(d).reduce(
|
|
1116
|
+
(l, [f, E]) => (E.hidden && l.push(f), l),
|
|
1088
1117
|
[]
|
|
1089
1118
|
);
|
|
1090
|
-
|
|
1091
|
-
let
|
|
1092
|
-
|
|
1093
|
-
(
|
|
1119
|
+
m = m.filter((l) => !h.includes(l)).sort((l, f) => {
|
|
1120
|
+
let E = d[l] ? d[l].order : void 0;
|
|
1121
|
+
E === void 0 && (E = Object.keys(ae).findIndex(
|
|
1122
|
+
(Y) => Y === l
|
|
1094
1123
|
));
|
|
1095
|
-
let
|
|
1096
|
-
return
|
|
1097
|
-
(
|
|
1098
|
-
)),
|
|
1124
|
+
let b = d[f] ? d[f].order : void 0;
|
|
1125
|
+
return b === void 0 && (b = Object.keys(ae).findIndex(
|
|
1126
|
+
(Y) => Y === f
|
|
1127
|
+
)), f === K || l === K ? 0 : E === -1 ? 1 : b === -1 ? -1 : E - b;
|
|
1099
1128
|
});
|
|
1100
1129
|
}
|
|
1101
|
-
return r?.length ===
|
|
1130
|
+
return r?.length === m.length ? r : m;
|
|
1102
1131
|
}, [
|
|
1103
|
-
|
|
1104
|
-
|
|
1132
|
+
d,
|
|
1133
|
+
ye,
|
|
1105
1134
|
q,
|
|
1106
1135
|
ae,
|
|
1107
1136
|
We
|
|
1108
|
-
]),
|
|
1109
|
-
() => x &&
|
|
1110
|
-
(r,
|
|
1111
|
-
(
|
|
1112
|
-
const
|
|
1113
|
-
if (
|
|
1114
|
-
return
|
|
1115
|
-
if (!
|
|
1116
|
-
return
|
|
1117
|
-
const
|
|
1118
|
-
switch (
|
|
1137
|
+
]), Fe = e.useMemo(
|
|
1138
|
+
() => x && H ? x.map(
|
|
1139
|
+
(r, m) => H.reduce(
|
|
1140
|
+
(h, l) => {
|
|
1141
|
+
const f = ae[l], E = d ? d[l] : void 0;
|
|
1142
|
+
if (E?.renderData)
|
|
1143
|
+
return h[l] = E.renderData(r, m), h;
|
|
1144
|
+
if (!f || l === K)
|
|
1145
|
+
return h[l] = "", h;
|
|
1146
|
+
const b = r ? r[l] : "";
|
|
1147
|
+
switch (f.type) {
|
|
1119
1148
|
case "array":
|
|
1120
|
-
return
|
|
1149
|
+
return h[l] = f.items?.type === "string" && b ? b.map((Y) => k(Y)).join(", ") : JSON.stringify(b), h;
|
|
1121
1150
|
case "boolean":
|
|
1122
|
-
return
|
|
1151
|
+
return h[l] = b === void 0 ? "?" : b ? "✓" : "✕", h;
|
|
1123
1152
|
case "number":
|
|
1124
1153
|
case "integer":
|
|
1125
|
-
return
|
|
1154
|
+
return b === void 0 ? (h[l] = "", h) : (h[l] = f.format === "currency" ? gn.format(b) : bn.format(b), h);
|
|
1126
1155
|
// @ts-expect-error investigate
|
|
1127
1156
|
case "string":
|
|
1128
|
-
if (
|
|
1129
|
-
return
|
|
1130
|
-
|
|
1157
|
+
if (f.format === "date" && b)
|
|
1158
|
+
return h[l] = ["2999-12-31", "1970-01-01"].includes(
|
|
1159
|
+
b
|
|
1131
1160
|
) ? "-" : tt(
|
|
1132
|
-
new Date(
|
|
1133
|
-
|
|
1134
|
-
),
|
|
1135
|
-
if (
|
|
1136
|
-
return
|
|
1137
|
-
new Date(
|
|
1138
|
-
|
|
1139
|
-
|
|
1161
|
+
new Date(b),
|
|
1162
|
+
E?.dateFormat || vt
|
|
1163
|
+
), h;
|
|
1164
|
+
if (f.format === "date-time" && b)
|
|
1165
|
+
return h[l] = D ? wt(
|
|
1166
|
+
new Date(b),
|
|
1167
|
+
D,
|
|
1168
|
+
Pe
|
|
1140
1169
|
) : tt(
|
|
1141
|
-
new Date(
|
|
1142
|
-
|
|
1143
|
-
),
|
|
1144
|
-
if (
|
|
1145
|
-
return
|
|
1170
|
+
new Date(b),
|
|
1171
|
+
E?.dateFormat || Pe
|
|
1172
|
+
), h;
|
|
1173
|
+
if (f.enum)
|
|
1174
|
+
return h[l] = b ? k(b) : "", h;
|
|
1146
1175
|
// fallthrough
|
|
1147
1176
|
default:
|
|
1148
|
-
return
|
|
1177
|
+
return h[l] = b ? `${b}` : "", h;
|
|
1149
1178
|
}
|
|
1150
1179
|
},
|
|
1151
|
-
{ _index:
|
|
1180
|
+
{ _index: m }
|
|
1152
1181
|
)
|
|
1153
1182
|
) : void 0,
|
|
1154
|
-
[x,
|
|
1155
|
-
), xe =
|
|
1156
|
-
let r = 0,
|
|
1157
|
-
return (
|
|
1158
|
-
if (
|
|
1159
|
-
r +=
|
|
1183
|
+
[x, H, ae, d, k, D]
|
|
1184
|
+
), xe = H ? H.length : 0, { dynamicWidthColumnCount: Ge, fixedWidthColumnsWidth: Xe } = e.useMemo(() => {
|
|
1185
|
+
let r = 0, m = 0;
|
|
1186
|
+
return (H || []).forEach((h) => {
|
|
1187
|
+
if (h === K) {
|
|
1188
|
+
r += gt;
|
|
1160
1189
|
return;
|
|
1161
1190
|
}
|
|
1162
|
-
const
|
|
1163
|
-
|
|
1164
|
-
}, 0), { dynamicWidthColumnCount:
|
|
1165
|
-
}, [
|
|
1166
|
-
if (
|
|
1167
|
-
return new Uint16Array(
|
|
1168
|
-
const r =
|
|
1191
|
+
const l = d ? d[h] : void 0;
|
|
1192
|
+
l?.width ? r += l.width : m += 1;
|
|
1193
|
+
}, 0), { dynamicWidthColumnCount: m, fixedWidthColumnsWidth: r };
|
|
1194
|
+
}, [H, d]), ie = e.useMemo(() => {
|
|
1195
|
+
if (Ae)
|
|
1196
|
+
return new Uint16Array(Ae);
|
|
1197
|
+
const r = je ? new Uint16Array(JSON.parse(je)) : void 0, m = Math.max(
|
|
1169
1198
|
Math.floor(
|
|
1170
|
-
(
|
|
1199
|
+
(Le - Xe) / Ge
|
|
1171
1200
|
),
|
|
1172
|
-
|
|
1201
|
+
kt
|
|
1173
1202
|
);
|
|
1174
|
-
let
|
|
1175
|
-
const
|
|
1176
|
-
|
|
1177
|
-
if (
|
|
1178
|
-
return
|
|
1179
|
-
const
|
|
1180
|
-
return
|
|
1203
|
+
let h = (Le - Xe) % Ge;
|
|
1204
|
+
const l = new Uint16Array(
|
|
1205
|
+
H.map((f) => {
|
|
1206
|
+
if (f === K)
|
|
1207
|
+
return gt;
|
|
1208
|
+
const E = d ? d[f] : void 0;
|
|
1209
|
+
return E?.width ? E?.width : h ? (h -= 1, m + 1) : m;
|
|
1181
1210
|
})
|
|
1182
1211
|
);
|
|
1183
|
-
return r?.length ===
|
|
1212
|
+
return r?.length === l.length ? r : l;
|
|
1184
1213
|
}, [
|
|
1185
|
-
|
|
1186
|
-
|
|
1187
|
-
|
|
1214
|
+
H,
|
|
1215
|
+
d,
|
|
1216
|
+
Ae,
|
|
1188
1217
|
Ge,
|
|
1189
1218
|
Xe,
|
|
1190
|
-
|
|
1191
|
-
|
|
1219
|
+
je,
|
|
1220
|
+
Le
|
|
1192
1221
|
]), Be = e.useCallback(
|
|
1193
1222
|
(r) => ie ? ie[r] : 1,
|
|
1194
1223
|
[ie]
|
|
1195
1224
|
), Ie = e.useMemo(() => {
|
|
1196
|
-
if (!
|
|
1197
|
-
return
|
|
1198
|
-
const { searchQuery: r } =
|
|
1199
|
-
(
|
|
1225
|
+
if (!Fe || !a && !B || J)
|
|
1226
|
+
return Fe;
|
|
1227
|
+
const { searchQuery: r } = i, m = r.toLowerCase() || "", h = (l) => x && T ? T(x[l._index], r) : !(H && !H.find(
|
|
1228
|
+
(f) => `${l[f]}`.toLowerCase().includes(m)
|
|
1200
1229
|
));
|
|
1201
|
-
return
|
|
1202
|
-
let
|
|
1203
|
-
return !
|
|
1204
|
-
([
|
|
1205
|
-
if (!
|
|
1230
|
+
return Fe.filter((l) => {
|
|
1231
|
+
let f = h(l);
|
|
1232
|
+
return !f || !i.columnFilterMap ? !1 : (Object.entries(i.columnFilterMap).forEach(
|
|
1233
|
+
([E, b]) => {
|
|
1234
|
+
if (!f || b === void 0)
|
|
1206
1235
|
return;
|
|
1207
|
-
const
|
|
1208
|
-
if (x &&
|
|
1209
|
-
|
|
1210
|
-
x[
|
|
1211
|
-
|
|
1236
|
+
const Y = d ? d[E] : void 0;
|
|
1237
|
+
if (x && Y?.filter) {
|
|
1238
|
+
f = Y.filter(
|
|
1239
|
+
x[l._index],
|
|
1240
|
+
b
|
|
1212
1241
|
);
|
|
1213
1242
|
return;
|
|
1214
1243
|
}
|
|
1215
|
-
const de = ae[
|
|
1244
|
+
const de = ae[E], W = x[l._index]?.[E];
|
|
1216
1245
|
switch (de?.type) {
|
|
1217
1246
|
case "boolean":
|
|
1218
1247
|
case "number":
|
|
1219
1248
|
case "integer":
|
|
1220
|
-
if (
|
|
1221
|
-
|
|
1249
|
+
if (b && typeof b == "object") {
|
|
1250
|
+
b.filterEmpty && W === void 0 && (f = !1);
|
|
1222
1251
|
for (const P of Object.keys(
|
|
1223
|
-
|
|
1252
|
+
ge
|
|
1224
1253
|
)) {
|
|
1225
|
-
const
|
|
1226
|
-
if (
|
|
1254
|
+
const be = b[P];
|
|
1255
|
+
if (f && Xt(be))
|
|
1227
1256
|
switch (P) {
|
|
1228
|
-
case
|
|
1229
|
-
|
|
1257
|
+
case ge.EQ:
|
|
1258
|
+
W !== be && (f = !1);
|
|
1230
1259
|
break;
|
|
1231
|
-
case
|
|
1232
|
-
|
|
1260
|
+
case ge.GT:
|
|
1261
|
+
W <= be && (f = !1);
|
|
1233
1262
|
break;
|
|
1234
|
-
case
|
|
1235
|
-
|
|
1263
|
+
case ge.LT:
|
|
1264
|
+
W >= be && (f = !1);
|
|
1236
1265
|
break;
|
|
1237
1266
|
}
|
|
1238
1267
|
}
|
|
1239
1268
|
} else {
|
|
1240
|
-
if (
|
|
1269
|
+
if (W === void 0 && b === null)
|
|
1241
1270
|
return !0;
|
|
1242
|
-
|
|
1271
|
+
f = W === b;
|
|
1243
1272
|
}
|
|
1244
1273
|
break;
|
|
1245
1274
|
// @ts-expect-error investigate
|
|
1246
1275
|
case "string":
|
|
1247
|
-
if (typeof
|
|
1248
|
-
const { from: P, to:
|
|
1249
|
-
if (!
|
|
1250
|
-
|
|
1276
|
+
if (typeof b == "object" && !Array.isArray(b) && (de.format === "date" || de.format === "date-time")) {
|
|
1277
|
+
const { from: P, to: be, filterEmpty: it } = b;
|
|
1278
|
+
if (!W)
|
|
1279
|
+
f = !it;
|
|
1251
1280
|
else {
|
|
1252
|
-
const Qe =
|
|
1253
|
-
(it === !1 || P && (!Qe || Qe < P) ||
|
|
1281
|
+
const Qe = W ? new Date(W) : void 0;
|
|
1282
|
+
(it === !1 || P && (!Qe || Qe < P) || be && (!Qe || Qe > be)) && (f = !1);
|
|
1254
1283
|
}
|
|
1255
1284
|
return;
|
|
1256
1285
|
}
|
|
1257
1286
|
// fall through
|
|
1258
1287
|
default:
|
|
1259
1288
|
if (de?.enum) {
|
|
1260
|
-
|
|
1289
|
+
Array.isArray(b) ? f = b.includes(W) : f = W === b;
|
|
1261
1290
|
return;
|
|
1262
1291
|
}
|
|
1263
|
-
|
|
1292
|
+
if (Array.isArray(b)) {
|
|
1293
|
+
const P = `${l[E]}`.toLowerCase();
|
|
1294
|
+
f = b.some(
|
|
1295
|
+
(be) => P.includes(`${be}`.toLowerCase())
|
|
1296
|
+
);
|
|
1297
|
+
} else
|
|
1298
|
+
f = `${l[E]}`.toLowerCase().includes(`${b}`.toLowerCase());
|
|
1264
1299
|
}
|
|
1265
1300
|
}
|
|
1266
|
-
),
|
|
1301
|
+
), f);
|
|
1267
1302
|
});
|
|
1268
1303
|
}, [
|
|
1269
|
-
|
|
1270
|
-
m,
|
|
1271
|
-
U,
|
|
1272
|
-
J,
|
|
1304
|
+
Fe,
|
|
1273
1305
|
a,
|
|
1274
|
-
|
|
1275
|
-
|
|
1276
|
-
|
|
1306
|
+
B,
|
|
1307
|
+
J,
|
|
1308
|
+
i,
|
|
1309
|
+
T,
|
|
1310
|
+
H,
|
|
1311
|
+
d,
|
|
1277
1312
|
x,
|
|
1278
1313
|
ae
|
|
1279
1314
|
]), X = e.useMemo(() => {
|
|
1280
|
-
const { sortAsc: r, sortColumn:
|
|
1281
|
-
if (!
|
|
1315
|
+
const { sortAsc: r, sortColumn: m } = i;
|
|
1316
|
+
if (!m || !Ie || !x || J)
|
|
1282
1317
|
return Ie;
|
|
1283
|
-
const
|
|
1284
|
-
if (
|
|
1285
|
-
return Ie.sort((
|
|
1286
|
-
const
|
|
1287
|
-
return
|
|
1288
|
-
|
|
1318
|
+
const h = ae[m], l = d ? d[m] : void 0, f = l?.sort;
|
|
1319
|
+
if (f)
|
|
1320
|
+
return Ie.sort((Y, de) => {
|
|
1321
|
+
const W = x[Y._index], P = x[de._index];
|
|
1322
|
+
return W ? P ? f(
|
|
1323
|
+
W,
|
|
1289
1324
|
P,
|
|
1290
|
-
r === void 0 ?
|
|
1325
|
+
r === void 0 ? S : r
|
|
1291
1326
|
) : -1 : 1;
|
|
1292
1327
|
});
|
|
1293
|
-
const
|
|
1294
|
-
return Ie.sort((
|
|
1295
|
-
let
|
|
1296
|
-
return
|
|
1328
|
+
const E = h && h.format?.startsWith("date"), b = pn(h, l);
|
|
1329
|
+
return Ie.sort((Y, de) => {
|
|
1330
|
+
let W = b && x[Y._index] ? x[Y._index][m] : `${Y[m]}`.toLowerCase(), P = b && x[de._index] ? x[de._index][m] : `${de[m]}`.toLowerCase();
|
|
1331
|
+
return b && E && (W = new Date(W), isNaN(W.getTime()) && (W = yt), P = new Date(P), isNaN(P.getTime()) && (P = yt)), W === P ? 0 : W ? P ? (W < P ? 1 : -1) * (r ? -1 : 1) : r ? 1 : -1 : r ? -1 : 1;
|
|
1297
1332
|
});
|
|
1298
1333
|
}, [
|
|
1299
|
-
|
|
1300
|
-
|
|
1334
|
+
d,
|
|
1335
|
+
S,
|
|
1301
1336
|
Ie,
|
|
1302
1337
|
J,
|
|
1303
1338
|
ae,
|
|
1304
1339
|
x,
|
|
1305
|
-
|
|
1306
|
-
]),
|
|
1340
|
+
i
|
|
1341
|
+
]), ot = e.useCallback(
|
|
1307
1342
|
(r) => {
|
|
1308
|
-
const
|
|
1309
|
-
delete
|
|
1310
|
-
...
|
|
1311
|
-
columnFilterMap:
|
|
1343
|
+
const m = { ...i.columnFilterMap };
|
|
1344
|
+
delete m[r], ke({
|
|
1345
|
+
...i,
|
|
1346
|
+
columnFilterMap: m
|
|
1312
1347
|
});
|
|
1313
1348
|
},
|
|
1314
|
-
[
|
|
1315
|
-
),
|
|
1316
|
-
(r,
|
|
1317
|
-
if (
|
|
1349
|
+
[i]
|
|
1350
|
+
), Ye = e.useCallback(
|
|
1351
|
+
(r, m) => {
|
|
1352
|
+
if (M) {
|
|
1318
1353
|
window.location.hash = ze({
|
|
1319
|
-
...
|
|
1354
|
+
...U,
|
|
1320
1355
|
sortColumn: r,
|
|
1321
|
-
sortAsc:
|
|
1356
|
+
sortAsc: m
|
|
1322
1357
|
});
|
|
1323
1358
|
return;
|
|
1324
1359
|
}
|
|
1325
|
-
ke({ ...
|
|
1360
|
+
ke({ ...i, sortColumn: r, sortAsc: m });
|
|
1326
1361
|
},
|
|
1327
|
-
[
|
|
1328
|
-
),
|
|
1362
|
+
[i, U, M]
|
|
1363
|
+
), At = e.useCallback(
|
|
1329
1364
|
(r) => {
|
|
1330
1365
|
ke({
|
|
1331
|
-
...
|
|
1366
|
+
...i,
|
|
1332
1367
|
searchQuery: r.currentTarget.value
|
|
1333
1368
|
});
|
|
1334
1369
|
},
|
|
1335
|
-
[
|
|
1370
|
+
[i]
|
|
1336
1371
|
), De = e.useCallback(() => {
|
|
1337
|
-
qe(
|
|
1338
|
-
}, [
|
|
1372
|
+
qe(i), pe(void 0);
|
|
1373
|
+
}, [i]);
|
|
1339
1374
|
e.useEffect(() => {
|
|
1340
|
-
if (!
|
|
1375
|
+
if (!g || !U || !fe || !M)
|
|
1341
1376
|
return;
|
|
1342
|
-
const r = Object.keys(
|
|
1343
|
-
let
|
|
1344
|
-
for (const
|
|
1345
|
-
const
|
|
1346
|
-
if (typeof
|
|
1347
|
-
|
|
1377
|
+
const r = Object.keys(U);
|
|
1378
|
+
let m = !1;
|
|
1379
|
+
for (const h of r) {
|
|
1380
|
+
const l = U[h], f = fe[h];
|
|
1381
|
+
if (typeof l == "string" && l !== f) {
|
|
1382
|
+
m = !0;
|
|
1348
1383
|
break;
|
|
1349
1384
|
}
|
|
1350
|
-
if (typeof
|
|
1351
|
-
|
|
1385
|
+
if (typeof l == "object" && !et(l, f)) {
|
|
1386
|
+
m = !0;
|
|
1352
1387
|
break;
|
|
1353
1388
|
}
|
|
1354
1389
|
}
|
|
1355
|
-
|
|
1390
|
+
m && De();
|
|
1356
1391
|
}, [
|
|
1357
|
-
|
|
1358
|
-
|
|
1392
|
+
g,
|
|
1393
|
+
U,
|
|
1359
1394
|
fe,
|
|
1360
1395
|
De,
|
|
1361
|
-
|
|
1396
|
+
M
|
|
1362
1397
|
]);
|
|
1363
1398
|
const at = e.useCallback(
|
|
1364
1399
|
(r) => {
|
|
1365
|
-
r.key === "Enter" && (j(void 0), Ne && !
|
|
1400
|
+
r.key === "Enter" && (j(void 0), Ne && !M && De(), G && r.currentTarget.className === "mig-schema-table__search" && G(i.searchQuery || ""));
|
|
1366
1401
|
},
|
|
1367
|
-
[
|
|
1368
|
-
|
|
1402
|
+
[
|
|
1403
|
+
Ne,
|
|
1404
|
+
i.searchQuery,
|
|
1405
|
+
G,
|
|
1406
|
+
De,
|
|
1407
|
+
M
|
|
1408
|
+
]
|
|
1409
|
+
), He = e.useCallback(() => Q, [Q]), ue = e.useMemo(() => Yt(ie), [ie]), Se = e.useMemo(
|
|
1369
1410
|
() => X ? X.length : 0,
|
|
1370
1411
|
[X]
|
|
1371
|
-
),
|
|
1372
|
-
const r =
|
|
1373
|
-
let
|
|
1374
|
-
if (
|
|
1412
|
+
), _e = e.useMemo(() => {
|
|
1413
|
+
const r = Q * Se;
|
|
1414
|
+
let m;
|
|
1415
|
+
if (y && (m = y === "100%" ? Re.height : y, !m))
|
|
1375
1416
|
return 0;
|
|
1376
|
-
const
|
|
1377
|
-
return
|
|
1417
|
+
const h = m ? m - st.height - pt : 0;
|
|
1418
|
+
return h && h < r ? h : r;
|
|
1378
1419
|
}, [
|
|
1379
|
-
|
|
1420
|
+
Q,
|
|
1380
1421
|
Se,
|
|
1381
|
-
|
|
1382
|
-
|
|
1422
|
+
y,
|
|
1423
|
+
st,
|
|
1383
1424
|
Re.height
|
|
1384
1425
|
]), Et = e.useCallback(
|
|
1385
1426
|
(r) => {
|
|
@@ -1387,76 +1428,76 @@ const pn = ({
|
|
|
1387
1428
|
},
|
|
1388
1429
|
[]
|
|
1389
1430
|
), Lt = e.useCallback(
|
|
1390
|
-
(r,
|
|
1391
|
-
if (!
|
|
1431
|
+
(r, m) => {
|
|
1432
|
+
if (!z)
|
|
1392
1433
|
return;
|
|
1393
|
-
if (
|
|
1434
|
+
if (M && m !== !1) {
|
|
1394
1435
|
window.location.hash = ze({
|
|
1395
|
-
...
|
|
1436
|
+
...U,
|
|
1396
1437
|
columnFilterMap: {
|
|
1397
|
-
...
|
|
1398
|
-
[
|
|
1438
|
+
...i.columnFilterMap,
|
|
1439
|
+
[z.propName]: r
|
|
1399
1440
|
}
|
|
1400
1441
|
});
|
|
1401
1442
|
return;
|
|
1402
1443
|
}
|
|
1403
1444
|
if (r === void 0) {
|
|
1404
|
-
|
|
1445
|
+
ot(z.propName);
|
|
1405
1446
|
return;
|
|
1406
1447
|
}
|
|
1407
|
-
const
|
|
1408
|
-
...
|
|
1409
|
-
[
|
|
1448
|
+
const h = {
|
|
1449
|
+
...i.columnFilterMap,
|
|
1450
|
+
[z.propName]: r
|
|
1410
1451
|
};
|
|
1411
1452
|
ke({
|
|
1412
|
-
...
|
|
1413
|
-
columnFilterMap:
|
|
1453
|
+
...i,
|
|
1454
|
+
columnFilterMap: h
|
|
1414
1455
|
});
|
|
1415
1456
|
},
|
|
1416
1457
|
[
|
|
1417
|
-
|
|
1418
|
-
|
|
1458
|
+
ot,
|
|
1459
|
+
i,
|
|
1460
|
+
U,
|
|
1419
1461
|
z,
|
|
1420
|
-
|
|
1421
|
-
T
|
|
1462
|
+
M
|
|
1422
1463
|
]
|
|
1423
|
-
),
|
|
1464
|
+
), Nt = e.useCallback(() => {
|
|
1424
1465
|
const r = {
|
|
1425
1466
|
searchQuery: "",
|
|
1426
1467
|
columnFilterMap: {},
|
|
1427
1468
|
// Clear button should clear _ALL_ filters, do _NOT_ revert to defaultColumnFilters
|
|
1428
|
-
sortColumn:
|
|
1429
|
-
sortAsc:
|
|
1469
|
+
sortColumn: A,
|
|
1470
|
+
sortAsc: S
|
|
1430
1471
|
};
|
|
1431
|
-
|
|
1432
|
-
}, [
|
|
1433
|
-
const r =
|
|
1434
|
-
|
|
1435
|
-
(
|
|
1436
|
-
...
|
|
1437
|
-
searchQuery:
|
|
1472
|
+
M && (window.location.hash = ze(r)), qe(r), ke(r);
|
|
1473
|
+
}, [M, S, A]), It = e.useCallback(() => {
|
|
1474
|
+
const r = U?.searchQuery || "";
|
|
1475
|
+
M && // prevent hash change for undefined vs empty string compare
|
|
1476
|
+
(i.searchQuery || r) && i.searchQuery !== r && (window.location.hash = ze({
|
|
1477
|
+
...U,
|
|
1478
|
+
searchQuery: i.searchQuery
|
|
1438
1479
|
}));
|
|
1439
|
-
}, [
|
|
1480
|
+
}, [U, i.searchQuery, M]), St = e.useCallback(
|
|
1440
1481
|
async (r) => {
|
|
1441
|
-
r.preventDefault(), r.stopPropagation(), X && await
|
|
1482
|
+
r.preventDefault(), r.stopPropagation(), X && await fn(X);
|
|
1442
1483
|
},
|
|
1443
1484
|
[X]
|
|
1444
|
-
),
|
|
1445
|
-
v && (localStorage.removeItem(`${v}.columnNames`), localStorage.removeItem(`${v}.columnWidths`),
|
|
1485
|
+
), $t = e.useCallback(() => {
|
|
1486
|
+
v && (localStorage.removeItem(`${v}.columnNames`), localStorage.removeItem(`${v}.columnWidths`), se(void 0), Oe(void 0));
|
|
1446
1487
|
}, [v]), Ke = e.useCallback(
|
|
1447
1488
|
(r) => {
|
|
1448
1489
|
if (!X || !x || !ne || !le)
|
|
1449
1490
|
return !0;
|
|
1450
|
-
const
|
|
1451
|
-
return
|
|
1491
|
+
const m = X[r];
|
|
1492
|
+
return m && x[m._index] !== void 0;
|
|
1452
1493
|
},
|
|
1453
1494
|
[le, ne, X, x]
|
|
1454
|
-
),
|
|
1495
|
+
), Ot = e.useMemo(() => _e ? !(x && !Ne) && !ne ? /* @__PURE__ */ n(
|
|
1455
1496
|
"div",
|
|
1456
1497
|
{
|
|
1457
1498
|
style: {
|
|
1458
1499
|
width: ue,
|
|
1459
|
-
height: Math.max(50,
|
|
1500
|
+
height: Math.max(50, _e),
|
|
1460
1501
|
border: "1px solid #BBB",
|
|
1461
1502
|
textAlign: "center",
|
|
1462
1503
|
display: "flex",
|
|
@@ -1469,36 +1510,36 @@ const pn = ({
|
|
|
1469
1510
|
) : ne && le ? /* @__PURE__ */ n(
|
|
1470
1511
|
Ht,
|
|
1471
1512
|
{
|
|
1472
|
-
ref:
|
|
1513
|
+
ref: c,
|
|
1473
1514
|
isItemLoaded: Ke,
|
|
1474
1515
|
itemCount: le,
|
|
1475
1516
|
loadMoreItems: ne,
|
|
1476
|
-
children: ({ onItemsRendered:
|
|
1517
|
+
children: ({ onItemsRendered: m, ref: h }) => /* @__PURE__ */ n(
|
|
1477
1518
|
lt,
|
|
1478
1519
|
{
|
|
1479
1520
|
className: "mig-schema-table__tbody",
|
|
1480
|
-
estimatedRowHeight:
|
|
1481
|
-
height:
|
|
1521
|
+
estimatedRowHeight: Q,
|
|
1522
|
+
height: _e,
|
|
1482
1523
|
width: ue,
|
|
1483
1524
|
columnWidth: Be,
|
|
1484
|
-
rowHeight:
|
|
1525
|
+
rowHeight: He,
|
|
1485
1526
|
columnCount: xe,
|
|
1486
1527
|
rowCount: Se,
|
|
1487
|
-
ref:
|
|
1528
|
+
ref: h,
|
|
1488
1529
|
onItemsRendered: ({
|
|
1489
|
-
overscanRowStartIndex:
|
|
1490
|
-
overscanRowStopIndex:
|
|
1491
|
-
visibleRowStartIndex:
|
|
1492
|
-
visibleRowStopIndex:
|
|
1493
|
-
}) =>
|
|
1494
|
-
overscanStartIndex:
|
|
1495
|
-
overscanStopIndex:
|
|
1496
|
-
visibleStartIndex:
|
|
1497
|
-
visibleStopIndex:
|
|
1530
|
+
overscanRowStartIndex: l,
|
|
1531
|
+
overscanRowStopIndex: f,
|
|
1532
|
+
visibleRowStartIndex: E,
|
|
1533
|
+
visibleRowStopIndex: b
|
|
1534
|
+
}) => m({
|
|
1535
|
+
overscanStartIndex: l,
|
|
1536
|
+
overscanStopIndex: f,
|
|
1537
|
+
visibleStartIndex: E,
|
|
1538
|
+
visibleStopIndex: b
|
|
1498
1539
|
}),
|
|
1499
|
-
children:
|
|
1540
|
+
children: _t
|
|
1500
1541
|
},
|
|
1501
|
-
`tbody_${
|
|
1542
|
+
`tbody_${_e}_${ue}_${i.sortColumn}_${i.sortAsc}_${i.searchQuery}_${xe}_${ie.join(
|
|
1502
1543
|
" "
|
|
1503
1544
|
)}`
|
|
1504
1545
|
)
|
|
@@ -1507,206 +1548,206 @@ const pn = ({
|
|
|
1507
1548
|
lt,
|
|
1508
1549
|
{
|
|
1509
1550
|
className: "mig-schema-table__tbody",
|
|
1510
|
-
estimatedRowHeight:
|
|
1511
|
-
height:
|
|
1551
|
+
estimatedRowHeight: Q,
|
|
1552
|
+
height: _e,
|
|
1512
1553
|
width: ue,
|
|
1513
1554
|
columnWidth: Be,
|
|
1514
|
-
rowHeight:
|
|
1555
|
+
rowHeight: He,
|
|
1515
1556
|
columnCount: xe,
|
|
1516
1557
|
rowCount: Se,
|
|
1517
1558
|
ref: ce,
|
|
1518
|
-
children:
|
|
1559
|
+
children: _t
|
|
1519
1560
|
},
|
|
1520
|
-
`tbody_${
|
|
1561
|
+
`tbody_${_e}_${ue}_${i.sortColumn}_${i.sortAsc}_${i.searchQuery}_${xe}_${ie.join(
|
|
1521
1562
|
" "
|
|
1522
1563
|
)}`
|
|
1523
1564
|
) : null, [
|
|
1524
1565
|
xe,
|
|
1525
1566
|
ie,
|
|
1526
1567
|
Be,
|
|
1527
|
-
|
|
1528
|
-
|
|
1568
|
+
He,
|
|
1569
|
+
c,
|
|
1529
1570
|
Ne,
|
|
1530
1571
|
Ke,
|
|
1531
1572
|
le,
|
|
1532
1573
|
ne,
|
|
1533
1574
|
De,
|
|
1534
1575
|
Se,
|
|
1535
|
-
|
|
1576
|
+
Q,
|
|
1536
1577
|
ue,
|
|
1537
|
-
|
|
1538
|
-
|
|
1539
|
-
|
|
1578
|
+
i.searchQuery,
|
|
1579
|
+
i.sortAsc,
|
|
1580
|
+
i.sortColumn,
|
|
1540
1581
|
x,
|
|
1541
|
-
|
|
1582
|
+
_e,
|
|
1542
1583
|
ce
|
|
1543
|
-
]),
|
|
1584
|
+
]), Rt = e.useMemo(
|
|
1544
1585
|
() => ({
|
|
1545
|
-
...
|
|
1546
|
-
width: me ? Math.min(ue,
|
|
1547
|
-
height:
|
|
1548
|
-
maxHeight:
|
|
1586
|
+
...N,
|
|
1587
|
+
width: me ? Math.min(ue, Le) : void 0,
|
|
1588
|
+
height: y === "100%" ? "100%" : void 0,
|
|
1589
|
+
maxHeight: y === "100%" ? "100%" : void 0
|
|
1549
1590
|
}),
|
|
1550
|
-
[
|
|
1551
|
-
),
|
|
1591
|
+
[y, ue, N, Le, me]
|
|
1592
|
+
), Wt = s || "input";
|
|
1552
1593
|
return /* @__PURE__ */ n(
|
|
1553
1594
|
Me.Provider,
|
|
1554
1595
|
{
|
|
1555
1596
|
value: {
|
|
1556
|
-
checkedIndexes:
|
|
1557
|
-
columnNames:
|
|
1597
|
+
checkedIndexes: p,
|
|
1598
|
+
columnNames: H,
|
|
1558
1599
|
columnWidths: ie,
|
|
1559
|
-
config:
|
|
1560
|
-
disabledCheckedIndexes:
|
|
1561
|
-
displayTimezone:
|
|
1562
|
-
dropTargetIndex:
|
|
1600
|
+
config: d,
|
|
1601
|
+
disabledCheckedIndexes: O,
|
|
1602
|
+
displayTimezone: D,
|
|
1603
|
+
dropTargetIndex: Ee,
|
|
1563
1604
|
getRowClassName: Z,
|
|
1564
|
-
getRowSelected:
|
|
1565
|
-
isColumnFilterable:
|
|
1605
|
+
getRowSelected: ee,
|
|
1606
|
+
isColumnFilterable: a,
|
|
1566
1607
|
isItemLoaded: Ke,
|
|
1567
1608
|
isSortable: te,
|
|
1568
1609
|
lastCheckChangedRowIndex: he,
|
|
1569
1610
|
onRowClick: L,
|
|
1570
|
-
onRowDoubleClick:
|
|
1611
|
+
onRowDoubleClick: oe,
|
|
1571
1612
|
properties: ae,
|
|
1572
|
-
required:
|
|
1613
|
+
required: Mt,
|
|
1573
1614
|
setCheckedIndexes: q,
|
|
1574
|
-
setCustomColumnNames:
|
|
1615
|
+
setCustomColumnNames: se,
|
|
1575
1616
|
setCustomColumnWidths: Oe,
|
|
1576
1617
|
setDropTargetIndex: Ze,
|
|
1577
|
-
setFilterSortColumn:
|
|
1618
|
+
setFilterSortColumn: Ye,
|
|
1578
1619
|
setLastCheckChangedRowIndex: we,
|
|
1579
1620
|
setMenuConfig: j,
|
|
1580
1621
|
settingsStorageKey: v,
|
|
1581
1622
|
sortedRenderData: X,
|
|
1582
1623
|
sourceData: x,
|
|
1583
|
-
tableDataState:
|
|
1584
|
-
translate: k ||
|
|
1624
|
+
tableDataState: i,
|
|
1625
|
+
translate: k || bt
|
|
1585
1626
|
},
|
|
1586
|
-
children: /* @__PURE__ */
|
|
1627
|
+
children: /* @__PURE__ */ F(
|
|
1587
1628
|
"div",
|
|
1588
1629
|
{
|
|
1589
1630
|
className: `mig-schema-table${L ? " mig-schema-table--clickable-rows" : ""}`,
|
|
1590
1631
|
ref: nt,
|
|
1591
|
-
style:
|
|
1632
|
+
style: Rt,
|
|
1592
1633
|
role: "table",
|
|
1593
1634
|
children: [
|
|
1594
|
-
/* @__PURE__ */
|
|
1635
|
+
/* @__PURE__ */ F(
|
|
1595
1636
|
"div",
|
|
1596
1637
|
{
|
|
1597
1638
|
className: "mig-schema-table__action-container",
|
|
1598
1639
|
ref: rt,
|
|
1599
1640
|
children: [
|
|
1600
|
-
/* @__PURE__ */ n("div", { children:
|
|
1601
|
-
|
|
1641
|
+
/* @__PURE__ */ n("div", { children: B ? /* @__PURE__ */ n(
|
|
1642
|
+
Wt,
|
|
1602
1643
|
{
|
|
1603
1644
|
className: "mig-schema-table__search",
|
|
1604
1645
|
type: "search",
|
|
1605
1646
|
name: "search",
|
|
1606
1647
|
autoComplete: "off",
|
|
1607
|
-
placeholder:
|
|
1608
|
-
value:
|
|
1609
|
-
onChange:
|
|
1648
|
+
placeholder: Ce || k("search..."),
|
|
1649
|
+
value: i.searchQuery,
|
|
1650
|
+
onChange: At,
|
|
1610
1651
|
onKeyDown: at,
|
|
1611
|
-
autoFocus:
|
|
1612
|
-
onBlur:
|
|
1652
|
+
autoFocus: w,
|
|
1653
|
+
onBlur: It
|
|
1613
1654
|
}
|
|
1614
1655
|
) : null }),
|
|
1615
1656
|
t ? /* @__PURE__ */ n(
|
|
1616
1657
|
t,
|
|
1617
1658
|
{
|
|
1618
|
-
...
|
|
1659
|
+
...I,
|
|
1619
1660
|
renderData: X
|
|
1620
1661
|
}
|
|
1621
1662
|
) : /* @__PURE__ */ n("div", { className: "mig-schema-table__custom_element_placeholder" }),
|
|
1622
|
-
|
|
1663
|
+
$ && Array.isArray(C) ? /* @__PURE__ */ n("span", { className: "mig-schema-table__row_counter", children: k(
|
|
1623
1664
|
"showingFilteredCountOfTotalCount",
|
|
1624
1665
|
X?.length || 0,
|
|
1625
|
-
|
|
1666
|
+
C.length
|
|
1626
1667
|
) }) : null,
|
|
1627
|
-
|
|
1668
|
+
o ? /* @__PURE__ */ n(
|
|
1628
1669
|
"button",
|
|
1629
1670
|
{
|
|
1630
|
-
onClick:
|
|
1671
|
+
onClick: St,
|
|
1631
1672
|
style: { marginLeft: 8 },
|
|
1632
1673
|
disabled: !X?.length,
|
|
1633
1674
|
children: k("exportData")
|
|
1634
1675
|
}
|
|
1635
1676
|
) : null,
|
|
1636
|
-
|
|
1677
|
+
B || a ? /* @__PURE__ */ n(
|
|
1637
1678
|
"button",
|
|
1638
1679
|
{
|
|
1639
|
-
onClick:
|
|
1680
|
+
onClick: Nt,
|
|
1640
1681
|
style: { marginLeft: 8 },
|
|
1641
|
-
disabled:
|
|
1682
|
+
disabled: i.columnFilterMap && i.searchQuery ? Object.keys(i.columnFilterMap).length + i.searchQuery.length === 0 : !1,
|
|
1642
1683
|
children: k("clearFilters")
|
|
1643
1684
|
}
|
|
1644
1685
|
) : null,
|
|
1645
1686
|
v ? /* @__PURE__ */ n(
|
|
1646
1687
|
"button",
|
|
1647
1688
|
{
|
|
1648
|
-
onClick:
|
|
1689
|
+
onClick: $t,
|
|
1649
1690
|
style: { marginLeft: 8 },
|
|
1650
|
-
disabled: !We && !
|
|
1691
|
+
disabled: !We && !je,
|
|
1651
1692
|
children: k("clearSettings")
|
|
1652
1693
|
}
|
|
1653
1694
|
) : null
|
|
1654
1695
|
]
|
|
1655
1696
|
}
|
|
1656
1697
|
),
|
|
1657
|
-
/* @__PURE__ */
|
|
1698
|
+
/* @__PURE__ */ F("div", { className: "mig-schema-table__column_resize_container", children: [
|
|
1658
1699
|
/* @__PURE__ */ n(
|
|
1659
1700
|
u,
|
|
1660
1701
|
{
|
|
1661
|
-
height:
|
|
1702
|
+
height: pt,
|
|
1662
1703
|
itemCount: xe,
|
|
1663
1704
|
itemSize: Be,
|
|
1664
1705
|
layout: "horizontal",
|
|
1665
1706
|
width: ue,
|
|
1666
|
-
sortAsc:
|
|
1667
|
-
setFilterSortColumn:
|
|
1668
|
-
sortColumn:
|
|
1707
|
+
sortAsc: i.sortAsc,
|
|
1708
|
+
setFilterSortColumn: Ye,
|
|
1709
|
+
sortColumn: i.sortColumn,
|
|
1669
1710
|
sortedRenderData: X,
|
|
1670
1711
|
className: "mig-schema-table__th-row",
|
|
1671
|
-
children:
|
|
1712
|
+
children: an
|
|
1672
1713
|
},
|
|
1673
|
-
`thead_${ue}_${
|
|
1714
|
+
`thead_${ue}_${i.sortColumn}_${i.sortAsc}_${i.searchQuery}_${ie.join(
|
|
1674
1715
|
" "
|
|
1675
1716
|
)}`
|
|
1676
1717
|
),
|
|
1677
|
-
|
|
1678
|
-
|
|
1679
|
-
|
|
1718
|
+
Ot,
|
|
1719
|
+
_ ? /* @__PURE__ */ n(
|
|
1720
|
+
mn,
|
|
1680
1721
|
{
|
|
1681
1722
|
columnWidths: ie,
|
|
1682
|
-
resizeColumnIndex:
|
|
1683
|
-
setResizeColumnIndex:
|
|
1684
|
-
tableBodyHeight:
|
|
1723
|
+
resizeColumnIndex: Je,
|
|
1724
|
+
setResizeColumnIndex: Ve,
|
|
1725
|
+
tableBodyHeight: _e
|
|
1685
1726
|
}
|
|
1686
1727
|
) : null
|
|
1687
1728
|
] }),
|
|
1688
1729
|
x && x.length === 0 ? /* @__PURE__ */ n("div", { className: "mig-schema-table__no_data", children: "No data found" }) : null,
|
|
1689
|
-
|
|
1730
|
+
z ? Bt(
|
|
1690
1731
|
/* @__PURE__ */ n(
|
|
1691
|
-
|
|
1732
|
+
dn,
|
|
1692
1733
|
{
|
|
1693
|
-
isFilterable:
|
|
1694
|
-
isSortable:
|
|
1734
|
+
isFilterable: a && z.propConfig?.isFilterable !== !1,
|
|
1735
|
+
isSortable: xt(
|
|
1695
1736
|
te,
|
|
1696
|
-
V.properties[
|
|
1697
|
-
|
|
1737
|
+
V.properties[z.propName],
|
|
1738
|
+
z.propConfig
|
|
1698
1739
|
),
|
|
1699
1740
|
onChange: Lt,
|
|
1700
1741
|
onClose: Et,
|
|
1701
1742
|
onInputKeyDown: at,
|
|
1702
|
-
propConfig:
|
|
1703
|
-
propIsRequired:
|
|
1704
|
-
propName:
|
|
1705
|
-
propSchema: V.properties[
|
|
1706
|
-
referenceElement:
|
|
1707
|
-
setFilterSortColumn:
|
|
1743
|
+
propConfig: z.propConfig,
|
|
1744
|
+
propIsRequired: z.propIsRequired,
|
|
1745
|
+
propName: z.propName,
|
|
1746
|
+
propSchema: V.properties[z.propName],
|
|
1747
|
+
referenceElement: z.referenceElement,
|
|
1748
|
+
setFilterSortColumn: Ye,
|
|
1708
1749
|
translate: k,
|
|
1709
|
-
value:
|
|
1750
|
+
value: i.columnFilterMap ? i.columnFilterMap[z.propName] : null
|
|
1710
1751
|
}
|
|
1711
1752
|
),
|
|
1712
1753
|
document.body
|
|
@@ -1716,43 +1757,43 @@ const pn = ({
|
|
|
1716
1757
|
)
|
|
1717
1758
|
}
|
|
1718
1759
|
);
|
|
1719
|
-
},
|
|
1720
|
-
const [u,
|
|
1721
|
-
|
|
1722
|
-
}, [t]),
|
|
1723
|
-
() =>
|
|
1724
|
-
[u,
|
|
1760
|
+
}, $n = e.memo(_n), On = e.memo(({ refresh: t, period: s = 60 }) => {
|
|
1761
|
+
const [u, g] = e.useState(/* @__PURE__ */ new Date()), [p, d] = e.useState(/* @__PURE__ */ new Date()), I = e.useCallback(() => {
|
|
1762
|
+
d(/* @__PURE__ */ new Date()), t();
|
|
1763
|
+
}, [t]), C = e.useMemo(
|
|
1764
|
+
() => Pt(u, p),
|
|
1765
|
+
[u, p]
|
|
1725
1766
|
);
|
|
1726
1767
|
e.useEffect(() => {
|
|
1727
|
-
|
|
1728
|
-
}, [
|
|
1729
|
-
const
|
|
1730
|
-
|
|
1768
|
+
C > s && I();
|
|
1769
|
+
}, [C, u, p, s, I]), e.useEffect(() => {
|
|
1770
|
+
const A = setInterval(() => {
|
|
1771
|
+
g(/* @__PURE__ */ new Date());
|
|
1731
1772
|
}, 1e3);
|
|
1732
1773
|
return () => {
|
|
1733
|
-
clearInterval(
|
|
1774
|
+
clearInterval(A);
|
|
1734
1775
|
};
|
|
1735
1776
|
}, []);
|
|
1736
|
-
const R =
|
|
1737
|
-
return /* @__PURE__ */
|
|
1777
|
+
const R = s - C;
|
|
1778
|
+
return /* @__PURE__ */ F(
|
|
1738
1779
|
"div",
|
|
1739
1780
|
{
|
|
1740
1781
|
className: "mx-auto",
|
|
1741
1782
|
title: `Refresh ${R > 0 ? `in ${R} seconds` : "NOW"}`,
|
|
1742
1783
|
children: [
|
|
1743
1784
|
"Last update ",
|
|
1744
|
-
tt(
|
|
1785
|
+
tt(p, "HH:mm")
|
|
1745
1786
|
]
|
|
1746
1787
|
}
|
|
1747
1788
|
);
|
|
1748
1789
|
});
|
|
1749
1790
|
export {
|
|
1750
|
-
|
|
1751
|
-
|
|
1791
|
+
vt as DEFAULT_DATE_FORMAT,
|
|
1792
|
+
Pe as DEFAULT_DATE_TIME_FORMAT,
|
|
1752
1793
|
$e as EColumnFilterStatus,
|
|
1753
|
-
|
|
1754
|
-
|
|
1755
|
-
|
|
1756
|
-
|
|
1757
|
-
|
|
1794
|
+
kt as MINIMUM_COLUMN_WIDTH,
|
|
1795
|
+
tn as RESIZER_WIDTH,
|
|
1796
|
+
On as Refresher,
|
|
1797
|
+
$n as SchemaTable,
|
|
1798
|
+
an as Th
|
|
1758
1799
|
};
|