@progress/kendo-react-grid 9.4.0-develop.14 → 9.4.0-develop.15
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/GridComponent.js +1 -1
- package/GridComponent.mjs +337 -327
- package/cells/GridCell.js +1 -1
- package/cells/GridCell.mjs +24 -20
- package/dist/cdn/js/kendo-react-grid.js +1 -1
- package/index.d.mts +42 -1
- package/index.d.ts +42 -1
- package/package-metadata.js +1 -1
- package/package-metadata.mjs +2 -2
- package/package.json +13 -13
- package/utils/index.js +1 -1
- package/utils/index.mjs +122 -116
package/GridComponent.mjs
CHANGED
|
@@ -6,96 +6,96 @@
|
|
|
6
6
|
*-------------------------------------------------------------------------------------------
|
|
7
7
|
*/
|
|
8
8
|
import * as l from "react";
|
|
9
|
-
import { validatePackage as
|
|
10
|
-
import { process as
|
|
11
|
-
import { combineFilters as
|
|
12
|
-
import { GridSelectionCell as
|
|
13
|
-
import { GridHierarchyCell as
|
|
14
|
-
import { GridEditCell as
|
|
15
|
-
import { Header as
|
|
16
|
-
import { HeaderRow as
|
|
17
|
-
import { FilterRow as
|
|
18
|
-
import { GroupPanel as
|
|
19
|
-
import { Footer as
|
|
20
|
-
import { getColumnWidth as
|
|
21
|
-
import { GridCell as
|
|
22
|
-
import { GridGroupCell as
|
|
23
|
-
import { GridRow as
|
|
24
|
-
import { GridHeaderSelectionCell as
|
|
25
|
-
import { GridNoRecords as
|
|
26
|
-
import { operators as
|
|
27
|
-
import { FooterRow as
|
|
28
|
-
import { normalize as
|
|
29
|
-
import { packageMetadata as
|
|
30
|
-
import { GridDetailCell as
|
|
31
|
-
import { GridDetailHierarchyCell as
|
|
32
|
-
import { GridNoRecordsContainer as
|
|
33
|
-
import { GridWatermarkOverlay as
|
|
34
|
-
import { GridClientWrapper as
|
|
35
|
-
import { GridColGroup as
|
|
36
|
-
import { GridTable as
|
|
37
|
-
import { GridDropClue as
|
|
38
|
-
import { GridDragClue as
|
|
39
|
-
import { GridTableBody as
|
|
40
|
-
import { PagerContainer as
|
|
41
|
-
import { GridTableScrollable as
|
|
42
|
-
import { GridElementContainer as
|
|
43
|
-
import { GridContainerElementContainer as
|
|
44
|
-
import { VirtualScrollHeightContainer as
|
|
45
|
-
import { LocalizationService as
|
|
46
|
-
import { gridAriaLabel as
|
|
9
|
+
import { validatePackage as ht, uGrid as Ct, getter as K, classNames as u, canUseDOM as wt } from "@progress/kendo-react-common";
|
|
10
|
+
import { process as Et } from "@progress/kendo-data-query";
|
|
11
|
+
import { combineFilters as It, getDetailExpandableOptions as vt, getGroupExpandableOptions as Rt, getSelectionOptions as St, tableKeyboardNavigationTools as p, Pager as xt, tableKeyboardNavigationBodyAttributes as Gt, tableKeyboardNavigationScopeAttributes as He, tableColumnsVirtualization as kt } from "@progress/kendo-react-data-tools";
|
|
12
|
+
import { GridSelectionCell as Nt } from "./cells/GridSelectionCell.mjs";
|
|
13
|
+
import { GridHierarchyCell as Ft } from "./cells/GridHierarchyCell.mjs";
|
|
14
|
+
import { GridEditCell as Dt } from "./cells/GridEditCell.mjs";
|
|
15
|
+
import { Header as Tt } from "./header/Header.mjs";
|
|
16
|
+
import { HeaderRow as Kt } from "./header/HeaderRow.mjs";
|
|
17
|
+
import { FilterRow as Ht } from "./header/FilterRow.mjs";
|
|
18
|
+
import { GroupPanel as At } from "./header/GroupPanel.mjs";
|
|
19
|
+
import { Footer as Pt } from "./footer/Footer.mjs";
|
|
20
|
+
import { getRowSpanOptions as Ae, getColumnWidth as ee, isSorted as Pe, flatData as Bt, autoGenerateColumns as Vt, mapColumns as Lt, clientColumn as Ot, getNestedValue as Be, getColSpan as Ve, resolveCells as zt, isClientReference as _t, sanitizeColumns as Mt, readColumns as Wt } from "./utils/index.mjs";
|
|
21
|
+
import { GridCell as jt } from "./cells/GridCell.mjs";
|
|
22
|
+
import { GridGroupCell as Le } from "./cells/GridGroupCell.mjs";
|
|
23
|
+
import { GridRow as $t } from "./rows/GridRow.mjs";
|
|
24
|
+
import { GridHeaderSelectionCell as Ut } from "./header/GridHeaderSelectionCell.mjs";
|
|
25
|
+
import { GridNoRecords as Oe } from "./components/noRecords/GridNoRecords.mjs";
|
|
26
|
+
import { operators as ze } from "./filterCommon.mjs";
|
|
27
|
+
import { FooterRow as Jt } from "./footer/FooterRow.mjs";
|
|
28
|
+
import { normalize as Qt } from "./paging/GridPagerSettings.mjs";
|
|
29
|
+
import { packageMetadata as Xt } from "./package-metadata.mjs";
|
|
30
|
+
import { GridDetailCell as Yt } from "./cells/GridDetailCell.mjs";
|
|
31
|
+
import { GridDetailHierarchyCell as Zt } from "./cells/GridDetailHierarchyCell.mjs";
|
|
32
|
+
import { GridNoRecordsContainer as _e } from "./components/noRecords/GridNoRecordsContainer.mjs";
|
|
33
|
+
import { GridWatermarkOverlay as qt } from "./GridWatermarkOverlay.mjs";
|
|
34
|
+
import { GridClientWrapper as Me } from "./GridClientWrapper.mjs";
|
|
35
|
+
import { GridColGroup as pt } from "./components/colGroup/GridColGroup.mjs";
|
|
36
|
+
import { GridTable as el } from "./components/table/GridTable.mjs";
|
|
37
|
+
import { GridDropClue as We } from "./components/GridDropClue.mjs";
|
|
38
|
+
import { GridDragClue as je } from "./components/GridDragClue.mjs";
|
|
39
|
+
import { GridTableBody as $e } from "./components/table/GridTableBody.mjs";
|
|
40
|
+
import { PagerContainer as tl } from "./components/PagerContainer.mjs";
|
|
41
|
+
import { GridTableScrollable as ll } from "./components/table/GridTableScrollable.mjs";
|
|
42
|
+
import { GridElementContainer as Ue } from "./components/GridElementContainer.mjs";
|
|
43
|
+
import { GridContainerElementContainer as al } from "./components/GridContainerElementContainer.mjs";
|
|
44
|
+
import { VirtualScrollHeightContainer as rl } from "./components/VirtualScrollHeightContainer.mjs";
|
|
45
|
+
import { LocalizationService as nl, IntlService as il } from "@progress/kendo-react-intl";
|
|
46
|
+
import { gridAriaLabel as Je, messages as ol } from "./messages/index.mjs";
|
|
47
47
|
import { VirtualScrollFixed as j } from "./VirtualScrollFixed.mjs";
|
|
48
|
-
import { VirtualScroll as
|
|
49
|
-
import { GridCustomCellClientContainer as
|
|
50
|
-
import { GridReorderableRowsContainer as
|
|
51
|
-
import { GridRowReorderCell as
|
|
52
|
-
import { GridHeaderRowReorderCell as
|
|
53
|
-
import { GridLoader as
|
|
54
|
-
const
|
|
55
|
-
var
|
|
56
|
-
const
|
|
57
|
-
|
|
58
|
-
const
|
|
59
|
-
const
|
|
60
|
-
|
|
48
|
+
import { VirtualScroll as dl } from "./VirtualScroll.mjs";
|
|
49
|
+
import { GridCustomCellClientContainer as cl } from "./components/GridCustomCellClientContainer.mjs";
|
|
50
|
+
import { GridReorderableRowsContainer as sl } from "./components/GridDraggableRowsContainer.mjs";
|
|
51
|
+
import { GridRowReorderCell as ml } from "./cells/GridRowReorderCell.mjs";
|
|
52
|
+
import { GridHeaderRowReorderCell as ul } from "./header/client/GridHeaderRowReorderCell.mjs";
|
|
53
|
+
import { GridLoader as Qe } from "./components/GridLoader.mjs";
|
|
54
|
+
const fl = l.forwardRef((e, te) => {
|
|
55
|
+
var Ie, ve, Re, Se, xe, Ge, ke;
|
|
56
|
+
const S = e.id + "-role-element-id", x = e.navigatable ? S : "";
|
|
57
|
+
ht(Xt);
|
|
58
|
+
const Xe = (t, n, s, o, i, a, d) => {
|
|
59
|
+
const c = [], y = Bt(
|
|
60
|
+
c,
|
|
61
61
|
C,
|
|
62
62
|
t,
|
|
63
|
-
{ index:
|
|
64
|
-
|
|
65
|
-
|
|
63
|
+
{ index: n },
|
|
64
|
+
s !== void 0,
|
|
65
|
+
o,
|
|
66
66
|
i,
|
|
67
67
|
a,
|
|
68
|
-
|
|
69
|
-
|
|
68
|
+
nt.defaultExpand,
|
|
69
|
+
d
|
|
70
70
|
);
|
|
71
|
-
return { flattedData:
|
|
72
|
-
},
|
|
73
|
-
const
|
|
71
|
+
return { flattedData: c, resolvedGroupsCount: y };
|
|
72
|
+
}, Ye = (t) => {
|
|
73
|
+
const n = t.filter(
|
|
74
74
|
(i) => i && i.type && i.type.displayName === "KendoReactGridColumn"
|
|
75
|
-
),
|
|
76
|
-
return
|
|
77
|
-
},
|
|
75
|
+
), s = f.current.filter((i) => i.declarationIndex >= 0 && i.parentIndex === -1), o = Mt(s);
|
|
76
|
+
return Wt(n, o, { prevId: 0, idPrefix: x });
|
|
77
|
+
}, Ze = (t) => t.filter((n) => wt && n && n.media ? window.matchMedia(n.media).matches : n), qe = (t, n) => {
|
|
78
78
|
var i;
|
|
79
|
-
const
|
|
80
|
-
|
|
79
|
+
const s = Ye(t), o = Ze(s);
|
|
80
|
+
f.current = o, f.current.length === 0 && (f.current = Vt(
|
|
81
81
|
C,
|
|
82
82
|
e.group,
|
|
83
83
|
{
|
|
84
|
-
column: (i =
|
|
84
|
+
column: (i = A.column) != null ? i : e.expandField
|
|
85
85
|
},
|
|
86
86
|
{
|
|
87
87
|
prevId: 0,
|
|
88
|
-
idPrefix:
|
|
88
|
+
idPrefix: x
|
|
89
89
|
}
|
|
90
|
-
)),
|
|
91
|
-
},
|
|
90
|
+
)), pe(f.current, n), G = Lt(f.current, !0), ae.current = f.current.map(Ot);
|
|
91
|
+
}, pe = (t, n) => {
|
|
92
92
|
var i;
|
|
93
93
|
t.filter((a) => e.selectedField && a.field === e.selectedField || a.columnType === "checkbox").forEach((a) => {
|
|
94
|
-
a.width = a.width || "50px", a.cell = a.cell ||
|
|
95
|
-
}),
|
|
96
|
-
a.width = a.width || "50px", a.cell = a.cell ||
|
|
94
|
+
a.width = a.width || "50px", a.cell = a.cell || Nt, a._type = "edit", a.headerCell = a.headerCell || Ut;
|
|
95
|
+
}), N !== void 0 && t.filter((a) => a.columnType === "reorder").forEach((a) => {
|
|
96
|
+
a.width = a.width || "50px", a.cell = a.cell || ml, a.headerCell = a.headerCell || ul, a.sortable = !1, a.filterable = !1, a.editable = !1;
|
|
97
97
|
});
|
|
98
|
-
const
|
|
98
|
+
const s = {
|
|
99
99
|
id: "",
|
|
100
100
|
resizable: !0,
|
|
101
101
|
width: "32px",
|
|
@@ -115,63 +115,65 @@ const nl = l.forwardRef((e, ee) => {
|
|
|
115
115
|
ariaColumnIndex: 0,
|
|
116
116
|
isAccessible: !0
|
|
117
117
|
};
|
|
118
|
-
let
|
|
119
|
-
(e.expandField ||
|
|
120
|
-
...
|
|
118
|
+
let o = 0;
|
|
119
|
+
(e.expandField || A.enabled) && e.detail && (t.unshift({
|
|
120
|
+
...s,
|
|
121
121
|
_type: "expand",
|
|
122
|
-
cell:
|
|
123
|
-
field: (i =
|
|
124
|
-
headerClassName: m
|
|
125
|
-
}),
|
|
126
|
-
for (let a = 0; a <
|
|
122
|
+
cell: Ft,
|
|
123
|
+
field: (i = A.column) != null ? i : e.expandField,
|
|
124
|
+
headerClassName: u(m.hierarchyCell({}))
|
|
125
|
+
}), o++);
|
|
126
|
+
for (let a = 0; a < n; a++)
|
|
127
127
|
t.unshift({
|
|
128
|
-
...
|
|
128
|
+
...s,
|
|
129
129
|
isAccessible: !1,
|
|
130
|
-
cell:
|
|
130
|
+
cell: Le,
|
|
131
131
|
field: "value",
|
|
132
132
|
locked: e.lockGroups
|
|
133
|
-
}),
|
|
134
|
-
t.slice(
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
133
|
+
}), o++;
|
|
134
|
+
t.slice(o).forEach((a) => {
|
|
135
|
+
a.parentIndex >= 0 && (a.parentIndex += o), a.rowSpannable = a.rowSpannable !== void 0 ? Ae(a.rowSpannable) : ne;
|
|
136
|
+
});
|
|
137
|
+
}, le = () => C.length === e.total, et = () => {
|
|
138
|
+
const { rowHeight: t, detailRowHeight: n, detail: s, expandField: o } = e, i = le(), a = t !== void 0 && t > 0, d = n !== void 0 && n > 0;
|
|
139
|
+
return !a || H && !i || !!(s && o) && (!d || !i) ? dl : j;
|
|
140
|
+
}, $ = () => e.isClient ? f : ae, tt = (t, n, s, o, i, a) => {
|
|
141
|
+
let d = Ve(t, n);
|
|
140
142
|
if (e.columnVirtualization && t.colSpan === 1)
|
|
141
143
|
return { colSpan: a, colsToSkip: i };
|
|
142
|
-
let
|
|
143
|
-
return e.columnVirtualization && (
|
|
144
|
+
let c = s.length - 1 === o, y = s.length - o;
|
|
145
|
+
return e.columnVirtualization && (c = b.length - 1 === o, y = b.length - o), d > 1 && !c ? i = d - 1 : d = 1, y <= d && !c && (d = y), { colSpan: d, colsToSkip: i };
|
|
144
146
|
};
|
|
145
|
-
let U,
|
|
146
|
-
const
|
|
147
|
-
let
|
|
148
|
-
const
|
|
147
|
+
let U, g = [], O;
|
|
148
|
+
const f = e.columnsRef || { current: [] }, ae = { current: [] };
|
|
149
|
+
let G = [[]];
|
|
150
|
+
const lt = e.scrollLeftRef || { current: 0 }, z = e.localization || new nl(), at = e.intl || new il("en"), k = e.unstyled, m = k && k.uGrid ? k.uGrid : Ct, N = typeof e.rowReorderable == "object" ? e.rowReorderable.enabled : e.rowReorderable, F = e.autoProcessData === !0 ? {
|
|
149
151
|
group: !0,
|
|
150
152
|
sort: !0,
|
|
151
153
|
filter: !0,
|
|
152
154
|
search: !0,
|
|
153
155
|
page: !0
|
|
154
156
|
} : e.autoProcessData;
|
|
155
|
-
let C,
|
|
156
|
-
if (Array.isArray(e.data) ? (C = e.data,
|
|
157
|
-
const { data: t, total:
|
|
158
|
-
group:
|
|
159
|
-
sort:
|
|
160
|
-
filter:
|
|
161
|
-
|
|
162
|
-
|
|
157
|
+
let C, R;
|
|
158
|
+
if (Array.isArray(e.data) ? (C = e.data, R = (Ie = e.total) != null ? Ie : C.length) : (C = ((ve = e.data) == null ? void 0 : ve.data) || [], R = (xe = (Se = e.total) != null ? Se : (Re = e.data) == null ? void 0 : Re.total) != null ? xe : C.length), F) {
|
|
159
|
+
const { data: t, total: n } = Et(C, {
|
|
160
|
+
group: F.group ? e.group : void 0,
|
|
161
|
+
sort: F.sort ? e.sort : void 0,
|
|
162
|
+
filter: It(
|
|
163
|
+
F.filter ? e.filter : void 0,
|
|
164
|
+
F.search ? e.search : void 0
|
|
163
165
|
),
|
|
164
|
-
...
|
|
166
|
+
...F.page ? {
|
|
165
167
|
take: e.take,
|
|
166
168
|
skip: e.skip
|
|
167
169
|
} : {}
|
|
168
170
|
});
|
|
169
|
-
C = t,
|
|
171
|
+
C = t, R = (Ge = e.total) != null ? Ge : n;
|
|
170
172
|
}
|
|
171
|
-
const { size:
|
|
173
|
+
const { size: E = "medium" } = e, rt = typeof e.groupable == "object" && e.groupable.footer || "none", D = e.scrollable === "virtual", H = e.groupable === !0 || typeof e.groupable == "object" && e.groupable.enabled !== !1, A = vt(!!e.detail), nt = Rt(
|
|
172
174
|
typeof e.groupable == "object" && e.groupable.enabled !== !1 ? e.groupable.expandable : e.groupable
|
|
173
|
-
), { resolvedGroupsCount:
|
|
174
|
-
|
|
175
|
+
), { resolvedGroupsCount: it, flattedData: ot } = Xe(
|
|
176
|
+
rt,
|
|
175
177
|
e.skip || 0,
|
|
176
178
|
e.group,
|
|
177
179
|
e.expandField,
|
|
@@ -179,218 +181,226 @@ const nl = l.forwardRef((e, ee) => {
|
|
|
179
181
|
e.groupExpand,
|
|
180
182
|
e.dataItemKey
|
|
181
183
|
);
|
|
182
|
-
|
|
183
|
-
const J =
|
|
184
|
-
J === j &&
|
|
184
|
+
g = ot;
|
|
185
|
+
const J = et();
|
|
186
|
+
J === j && le() && (O = g.slice(
|
|
185
187
|
e.skip || 0,
|
|
186
188
|
(e.skip || 0) + ((e.take !== void 0 ? e.take : e.pageSize) || 0)
|
|
187
189
|
));
|
|
188
|
-
const
|
|
189
|
-
|
|
190
|
-
const
|
|
190
|
+
const re = St(e.selectable || !!e.selectedField), ne = Ae(e.rowSpannable), dt = re && re.drag ? "none" : void 0, _ = l.Children.toArray(e.children);
|
|
191
|
+
qe(_, it);
|
|
192
|
+
const ie = _.map((t) => t && t.type && t.type.displayName === "KendoReactGridToolbar" ? l.cloneElement(t, { ...t.props, ariaControls: S }) : null), M = _.filter((t) => t && t.type && t.type.displayName === "KendoReactGridNoRecords"), oe = _.filter(
|
|
191
193
|
(t) => t && t.type && t.type.displayName === "KendoReactGridStatusBar"
|
|
192
|
-
),
|
|
193
|
-
|
|
194
|
+
), b = f.current.filter((t) => t.children.length === 0), de = H && /* @__PURE__ */ l.createElement(At, { columns: $().current, group: e.group || [], ariaControls: S }), ce = /* @__PURE__ */ l.createElement(
|
|
195
|
+
Tt,
|
|
194
196
|
{
|
|
195
|
-
size:
|
|
197
|
+
size: E,
|
|
196
198
|
staticHeaders: e.scrollable !== "none",
|
|
197
|
-
draggable: e.reorderable ||
|
|
199
|
+
draggable: e.reorderable || H,
|
|
198
200
|
headerRow: /* @__PURE__ */ l.createElement(
|
|
199
|
-
|
|
201
|
+
Kt,
|
|
200
202
|
{
|
|
201
203
|
cells: e.cells,
|
|
202
204
|
sort: e.sort,
|
|
203
205
|
sortable: e.sortable,
|
|
204
206
|
group: e.group || [],
|
|
205
|
-
groupable:
|
|
207
|
+
groupable: H,
|
|
206
208
|
filter: e.filter,
|
|
207
209
|
filterable: e.filterable,
|
|
208
|
-
filterOperators: e.filterOperators ||
|
|
210
|
+
filterOperators: e.filterOperators || ze,
|
|
209
211
|
columnMenu: e.columnMenu,
|
|
210
212
|
columnMenuIcon: e.columnMenuIcon,
|
|
211
|
-
columns:
|
|
212
|
-
columnsMap:
|
|
213
|
+
columns: f.current,
|
|
214
|
+
columnsMap: G,
|
|
213
215
|
cellRender: e.headerCellRender,
|
|
214
216
|
navigatable: !!e.navigatable,
|
|
215
|
-
localization:
|
|
216
|
-
unstyled:
|
|
217
|
-
headerSelectionValue: !!(e.select &&
|
|
218
|
-
(t) => e.select && e.dataItemKey &&
|
|
217
|
+
localization: z,
|
|
218
|
+
unstyled: k,
|
|
219
|
+
headerSelectionValue: !!(e.select && g.filter((t) => t.rowType === "data").every(
|
|
220
|
+
(t) => e.select && e.dataItemKey && K(e.dataItemKey)(t.dataItem) !== void 0 ? e.select[K(e.dataItemKey)(t.dataItem)] : void 0
|
|
219
221
|
))
|
|
220
222
|
}
|
|
221
223
|
),
|
|
222
224
|
filterRow: e.filterable && /* @__PURE__ */ l.createElement(
|
|
223
|
-
|
|
225
|
+
Ht,
|
|
224
226
|
{
|
|
225
227
|
cells: e.cells,
|
|
226
|
-
size:
|
|
227
|
-
columns:
|
|
228
|
+
size: E,
|
|
229
|
+
columns: f.current,
|
|
228
230
|
filter: e.filter,
|
|
229
|
-
filterOperators: e.filterOperators ||
|
|
231
|
+
filterOperators: e.filterOperators || ze,
|
|
230
232
|
sort: e.sort,
|
|
231
233
|
cellRender: e.filterCellRender,
|
|
232
234
|
navigatable: !!e.navigatable,
|
|
233
|
-
ariaRowIndex:
|
|
234
|
-
localization:
|
|
235
|
+
ariaRowIndex: G.length + 1,
|
|
236
|
+
localization: z
|
|
235
237
|
}
|
|
236
238
|
) || void 0,
|
|
237
|
-
cols:
|
|
239
|
+
cols: b.map((t, n) => /* @__PURE__ */ l.createElement("col", { key: n.toString(), width: ee(t) }))
|
|
238
240
|
}
|
|
239
|
-
),
|
|
240
|
-
let
|
|
241
|
-
const
|
|
241
|
+
), ct = lt.current || 0, st = parseFloat(((e.style || {}).width || "").toString()), mt = (t, n, s, o, i) => {
|
|
242
|
+
let a = !1;
|
|
243
|
+
const d = e.selectedField ? Be(e.selectedField, t.dataItem) : e.select && e.dataItemKey && K(e.dataItemKey)(t.dataItem) !== void 0 ? e.select[K(e.dataItemKey)(t.dataItem)] : void 0;
|
|
242
244
|
let c = 0;
|
|
243
|
-
const { colSpans:
|
|
245
|
+
const { colSpans: y, hiddenColumns: T } = kt({
|
|
244
246
|
enabled: e.columnVirtualization,
|
|
245
|
-
columns:
|
|
246
|
-
tableViewPortWidth:
|
|
247
|
-
scrollLeft:
|
|
248
|
-
getColSpan:
|
|
247
|
+
columns: b,
|
|
248
|
+
tableViewPortWidth: st,
|
|
249
|
+
scrollLeft: ct,
|
|
250
|
+
getColSpan: Ve,
|
|
249
251
|
dataItem: t.dataItem
|
|
250
|
-
}),
|
|
252
|
+
}), I = b.filter((r, h) => !T[h]);
|
|
251
253
|
return {
|
|
252
|
-
row:
|
|
253
|
-
|
|
254
|
+
row: b.map((r, h) => {
|
|
255
|
+
var Fe, De, Te, Ke;
|
|
256
|
+
if (T[h])
|
|
254
257
|
return null;
|
|
255
258
|
if (c > 0)
|
|
256
259
|
return c--, null;
|
|
257
|
-
|
|
258
|
-
|
|
260
|
+
let w;
|
|
261
|
+
if ((Fe = r.rowSpannable) != null && Fe.enabled && t.rowType === "data" && r.field && i) {
|
|
262
|
+
const v = r.field ? (Te = (De = r.rowSpannable).valueGetter) == null ? void 0 : Te.call(De, t.dataItem, r.field) : null;
|
|
263
|
+
w = { value: v, count: 1 }, i[r.field] && ((Ke = i[r.field]) == null ? void 0 : Ke.value) === v && i[r.field] !== null ? (i[r.field].count++, w.count = null) : i[r.field] = w;
|
|
264
|
+
}
|
|
265
|
+
const { colSpan: B, colsToSkip: Y } = tt(
|
|
266
|
+
r,
|
|
259
267
|
t.dataItem,
|
|
260
|
-
|
|
268
|
+
I,
|
|
261
269
|
h,
|
|
262
270
|
c,
|
|
263
|
-
|
|
271
|
+
y[h]
|
|
264
272
|
);
|
|
265
|
-
c =
|
|
266
|
-
const
|
|
267
|
-
let
|
|
268
|
-
if (
|
|
269
|
-
const
|
|
270
|
-
|
|
273
|
+
c = Y;
|
|
274
|
+
const V = r.id ? r.id : h, gt = u(m.contentSticky({ locked: r.locked }), r.className), bt = r.left !== void 0 ? { left: r.left, right: r.right } : {};
|
|
275
|
+
let Ne = !1;
|
|
276
|
+
if (r.editable && (e.editable || e.editField)) {
|
|
277
|
+
const v = e.editField ? Be(e.editField, t.dataItem) : e.edit && e.dataItemKey ? e.edit[K(e.dataItemKey)(t.dataItem)] : void 0, q = typeof v == "boolean" ? v : Array.isArray(v) ? v.indexOf(r.field) > -1 : r.field !== void 0 && v === r.field;
|
|
278
|
+
q && r.columnType === "data" && (q === !0 || q === r.field) && (a = !0, Ne = !0);
|
|
271
279
|
}
|
|
272
|
-
const
|
|
280
|
+
const Z = r.cell || Ne && Dt || jt, yt = e.expandField && e.detail && r.field === e.expandField || r._type === "expand", L = {
|
|
273
281
|
locked: e.lockGroups,
|
|
274
|
-
id:
|
|
275
|
-
`${
|
|
276
|
-
|
|
277
|
-
|
|
282
|
+
id: p.generateNavigatableId(
|
|
283
|
+
`${n}-${String(h)}`,
|
|
284
|
+
x,
|
|
285
|
+
yt || t.rowType === "groupHeader" || t.rowType === "groupFooter" || r.field === "value" ? "nodata" : "cell"
|
|
278
286
|
),
|
|
279
|
-
colSpan:
|
|
287
|
+
colSpan: B,
|
|
280
288
|
dataItem: t.dataItem,
|
|
281
|
-
field:
|
|
282
|
-
editor:
|
|
283
|
-
format:
|
|
284
|
-
columnType:
|
|
285
|
-
rowReorderable:
|
|
286
|
-
className:
|
|
289
|
+
field: r.field,
|
|
290
|
+
editor: r.editor,
|
|
291
|
+
format: r.format,
|
|
292
|
+
columnType: r.columnType,
|
|
293
|
+
rowReorderable: N,
|
|
294
|
+
className: gt,
|
|
287
295
|
render: e.cellRender,
|
|
288
|
-
cells:
|
|
296
|
+
cells: zt(e.cells, r.cells),
|
|
289
297
|
columnIndex: h,
|
|
290
|
-
columnsCount:
|
|
298
|
+
columnsCount: b.length,
|
|
291
299
|
rowType: t.rowType,
|
|
292
300
|
level: t.level,
|
|
293
301
|
expanded: t.expanded,
|
|
294
302
|
dataIndex: t.dataIndex,
|
|
295
|
-
rowDataIndex:
|
|
296
|
-
columnPosition:
|
|
303
|
+
rowDataIndex: s,
|
|
304
|
+
columnPosition: bt,
|
|
297
305
|
style: {},
|
|
298
|
-
ariaColumnIndex:
|
|
299
|
-
isSelected: (
|
|
300
|
-
isSorted: !!
|
|
301
|
-
isInEdit:
|
|
302
|
-
isAlt:
|
|
303
|
-
unstyled:
|
|
306
|
+
ariaColumnIndex: r.ariaColumnIndex,
|
|
307
|
+
isSelected: (r == null ? void 0 : r._type) === "edit" ? d : Array.isArray(d) && d.indexOf(h) > -1,
|
|
308
|
+
isSorted: !!Pe(r.field, e.sort),
|
|
309
|
+
isInEdit: a,
|
|
310
|
+
isAlt: o,
|
|
311
|
+
unstyled: k,
|
|
304
312
|
group: t.group,
|
|
305
|
-
localization:
|
|
306
|
-
intl:
|
|
313
|
+
localization: z,
|
|
314
|
+
intl: at,
|
|
315
|
+
_rowSpan: w
|
|
307
316
|
};
|
|
308
|
-
return
|
|
309
|
-
|
|
317
|
+
return r.cell ? /* @__PURE__ */ l.createElement(
|
|
318
|
+
cl,
|
|
310
319
|
{
|
|
311
|
-
key:
|
|
312
|
-
isClient:
|
|
313
|
-
dataItem:
|
|
314
|
-
rowDataIndex:
|
|
315
|
-
columnIndex:
|
|
320
|
+
key: V,
|
|
321
|
+
isClient: _t(Z),
|
|
322
|
+
dataItem: L.dataItem,
|
|
323
|
+
rowDataIndex: L.rowDataIndex,
|
|
324
|
+
columnIndex: L.columnIndex
|
|
316
325
|
},
|
|
317
|
-
/* @__PURE__ */ l.createElement(
|
|
318
|
-
) : /* @__PURE__ */ l.createElement(
|
|
326
|
+
/* @__PURE__ */ l.createElement(Z, { ...L })
|
|
327
|
+
) : /* @__PURE__ */ l.createElement(Z, { key: V, ...L });
|
|
319
328
|
}),
|
|
320
|
-
isInEdit:
|
|
321
|
-
isSelected: typeof
|
|
329
|
+
isInEdit: a,
|
|
330
|
+
isSelected: typeof d == "boolean" && d
|
|
322
331
|
};
|
|
323
332
|
};
|
|
324
|
-
let
|
|
325
|
-
if (
|
|
333
|
+
let se = 0;
|
|
334
|
+
if (D && U)
|
|
326
335
|
for (let t = 0; t < U.topCacheCount + U.attendedSkip - (e.skip || 0); t++) {
|
|
327
|
-
const
|
|
328
|
-
if (
|
|
329
|
-
|
|
336
|
+
const n = g.shift();
|
|
337
|
+
if (n)
|
|
338
|
+
g.push(n), se++, n.rowType === "groupHeader" && t--;
|
|
330
339
|
else
|
|
331
340
|
break;
|
|
332
341
|
}
|
|
333
|
-
const
|
|
334
|
-
let
|
|
335
|
-
const Q = [],
|
|
336
|
-
let
|
|
337
|
-
if (
|
|
338
|
-
let t = -1,
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
342
|
+
const me = (t) => t >= g.length - se;
|
|
343
|
+
let ue = e.skip || 0;
|
|
344
|
+
const Q = [], fe = !g.length, ge = G.length + (e.filterable ? 1 : 0) + 1;
|
|
345
|
+
let P = 0;
|
|
346
|
+
if (g.length) {
|
|
347
|
+
let t = -1, n = 0;
|
|
348
|
+
const s = ne.enabled ? {} : void 0;
|
|
349
|
+
(O || g).forEach((o, i) => {
|
|
350
|
+
o.rowType === "data" && (ue++, t++);
|
|
351
|
+
const a = ue % 2 === 0, d = e.dataItemKey && K(e.dataItemKey)(o.dataItem), c = i + (e.skip || 0), y = d || "ai" + c, T = y + "_1", I = mt(o, y, t, a, s);
|
|
352
|
+
if (P = c + ge + n, Q.push(
|
|
343
353
|
/* @__PURE__ */ l.createElement(
|
|
344
|
-
|
|
354
|
+
$t,
|
|
345
355
|
{
|
|
346
|
-
key:
|
|
356
|
+
key: y,
|
|
347
357
|
dataItem: o.dataItem,
|
|
348
|
-
isAltRow:
|
|
349
|
-
isInEdit:
|
|
358
|
+
isAltRow: a,
|
|
359
|
+
isInEdit: I.isInEdit,
|
|
350
360
|
rowType: o.rowType,
|
|
351
|
-
isRowReorderable:
|
|
352
|
-
isHidden:
|
|
361
|
+
isRowReorderable: N,
|
|
362
|
+
isHidden: me(i),
|
|
353
363
|
onClick: null,
|
|
354
364
|
onDoubleClick: null,
|
|
355
365
|
selectedField: e.selectedField,
|
|
356
366
|
rowHeight: e.rowHeight,
|
|
357
367
|
render: e.rowRender,
|
|
358
|
-
ariaRowIndex:
|
|
368
|
+
ariaRowIndex: P,
|
|
359
369
|
absoluteRowIndex: c,
|
|
360
|
-
dataIndex:
|
|
361
|
-
isSelected:
|
|
370
|
+
dataIndex: D && !e.groupable ? c : t,
|
|
371
|
+
isSelected: I.isSelected
|
|
362
372
|
},
|
|
363
|
-
|
|
373
|
+
I.row
|
|
364
374
|
)
|
|
365
375
|
), e.detail && o.rowType === "data" && o.expanded) {
|
|
366
|
-
const
|
|
367
|
-
|
|
376
|
+
const r = b.length - (e.expandField || A.enabled ? 1 : 0) - (e.group ? e.group.length : 0) || 1;
|
|
377
|
+
n++, P = c + ge + n, Q.push(
|
|
368
378
|
/* @__PURE__ */ l.createElement(
|
|
369
379
|
"tr",
|
|
370
380
|
{
|
|
371
|
-
key:
|
|
372
|
-
className: m
|
|
381
|
+
key: T,
|
|
382
|
+
className: u(m.detailTr({ isAlt: a })),
|
|
373
383
|
style: {
|
|
374
|
-
visibility:
|
|
384
|
+
visibility: me(i) ? "hidden" : "",
|
|
375
385
|
height: e.detailRowHeight
|
|
376
386
|
},
|
|
377
387
|
role: "row",
|
|
378
|
-
"aria-rowindex":
|
|
388
|
+
"aria-rowindex": P
|
|
379
389
|
},
|
|
380
|
-
e.group && e.group.map((h,
|
|
381
|
-
var
|
|
382
|
-
const
|
|
390
|
+
e.group && e.group.map((h, w) => {
|
|
391
|
+
var V;
|
|
392
|
+
const B = (V = I == null ? void 0 : I.row[w]) == null ? void 0 : V.props.style, Y = B ? { left: B.left, right: B.right } : {};
|
|
383
393
|
return /* @__PURE__ */ l.createElement(
|
|
384
|
-
|
|
394
|
+
Le,
|
|
385
395
|
{
|
|
386
396
|
id: "",
|
|
387
397
|
dataIndex: o.dataIndex,
|
|
388
398
|
field: h.field,
|
|
389
399
|
dataItem: o.dataItem,
|
|
390
|
-
key:
|
|
391
|
-
columnPosition:
|
|
400
|
+
key: w,
|
|
401
|
+
columnPosition: Y,
|
|
392
402
|
style: {},
|
|
393
|
-
ariaColumnIndex: 1 +
|
|
403
|
+
ariaColumnIndex: 1 + w,
|
|
394
404
|
isSelected: !1,
|
|
395
405
|
locked: e.lockGroups,
|
|
396
406
|
cells: e.cells,
|
|
@@ -398,22 +408,22 @@ const nl = l.forwardRef((e, ee) => {
|
|
|
398
408
|
}
|
|
399
409
|
);
|
|
400
410
|
}),
|
|
401
|
-
(e.expandField ||
|
|
402
|
-
|
|
411
|
+
(e.expandField || A.enabled) && /* @__PURE__ */ l.createElement(
|
|
412
|
+
Zt,
|
|
403
413
|
{
|
|
404
|
-
unstyled:
|
|
405
|
-
id:
|
|
414
|
+
unstyled: k,
|
|
415
|
+
id: p.generateNavigatableId(`${T}-dhcell`, x)
|
|
406
416
|
}
|
|
407
417
|
),
|
|
408
418
|
/* @__PURE__ */ l.createElement(
|
|
409
|
-
|
|
419
|
+
Yt,
|
|
410
420
|
{
|
|
411
421
|
dataItem: o.dataItem,
|
|
412
422
|
dataIndex: o.dataIndex,
|
|
413
|
-
colSpan:
|
|
423
|
+
colSpan: r,
|
|
414
424
|
ariaColIndex: 2 + (e.group ? e.group.length : 0),
|
|
415
425
|
detail: e.detail,
|
|
416
|
-
id:
|
|
426
|
+
id: p.generateNavigatableId(`${T}-dcell`, x)
|
|
417
427
|
}
|
|
418
428
|
)
|
|
419
429
|
)
|
|
@@ -421,174 +431,174 @@ const nl = l.forwardRef((e, ee) => {
|
|
|
421
431
|
}
|
|
422
432
|
});
|
|
423
433
|
}
|
|
424
|
-
const
|
|
425
|
-
size:
|
|
426
|
-
total:
|
|
434
|
+
const be = {
|
|
435
|
+
size: E,
|
|
436
|
+
total: R,
|
|
427
437
|
skip: e.skip || 0,
|
|
428
438
|
take: (e.take !== void 0 ? e.take : e.pageSize) || 10,
|
|
429
|
-
...
|
|
430
|
-
},
|
|
431
|
-
var
|
|
432
|
-
return !!(t.footerCell || (
|
|
439
|
+
...Qt(e.pageable || {})
|
|
440
|
+
}, ye = /* @__PURE__ */ l.createElement(tl, null, e.pager ? /* @__PURE__ */ l.createElement(e.pager, { ...be }) : /* @__PURE__ */ l.createElement(xt, { className: u(m.pager({})), ...be })), ut = (t, n) => /* @__PURE__ */ l.createElement("col", { key: n.toString(), width: ee(t) }), ft = (ke = e.cells) != null && ke.footerCell || f.current.some((t) => {
|
|
441
|
+
var n;
|
|
442
|
+
return !!(t.footerCell || (n = t.cells) != null && n.footerCell);
|
|
433
443
|
}) ? /* @__PURE__ */ l.createElement(
|
|
434
|
-
|
|
444
|
+
Pt,
|
|
435
445
|
{
|
|
436
|
-
size:
|
|
446
|
+
size: E,
|
|
437
447
|
staticHeaders: e.scrollable !== "none",
|
|
438
448
|
row: /* @__PURE__ */ l.createElement(
|
|
439
|
-
|
|
449
|
+
Jt,
|
|
440
450
|
{
|
|
441
451
|
cells: e.cells,
|
|
442
|
-
idPrefix:
|
|
443
|
-
columns:
|
|
444
|
-
ariaRowIndex:
|
|
452
|
+
idPrefix: x,
|
|
453
|
+
columns: f.current,
|
|
454
|
+
ariaRowIndex: P + 1
|
|
445
455
|
}
|
|
446
456
|
),
|
|
447
|
-
cols:
|
|
457
|
+
cols: b.map(ut)
|
|
448
458
|
}
|
|
449
|
-
) : null,
|
|
459
|
+
) : null, he = /* @__PURE__ */ l.createElement(pt, null, b.map((t, n) => /* @__PURE__ */ l.createElement(
|
|
450
460
|
"col",
|
|
451
461
|
{
|
|
452
|
-
key:
|
|
453
|
-
className:
|
|
454
|
-
width:
|
|
462
|
+
key: n.toString(),
|
|
463
|
+
className: Pe(t.field, e.sort) ? u(m.sorted({})) : void 0,
|
|
464
|
+
width: ee(t)
|
|
455
465
|
}
|
|
456
|
-
))),
|
|
466
|
+
))), Ce = e.reorderable || H, { detail: gl, cells: bl, ...we } = e, Ee = /* @__PURE__ */ l.createElement(
|
|
457
467
|
"tbody",
|
|
458
468
|
{
|
|
459
469
|
role: "rowgroup",
|
|
460
|
-
className: m
|
|
461
|
-
...
|
|
470
|
+
className: u(m.tbody({})),
|
|
471
|
+
...Gt
|
|
462
472
|
},
|
|
463
473
|
Q
|
|
464
474
|
);
|
|
465
|
-
let X =
|
|
466
|
-
if (
|
|
467
|
-
|
|
475
|
+
let X = Ee;
|
|
476
|
+
if (N && (X = /* @__PURE__ */ l.createElement(
|
|
477
|
+
sl,
|
|
468
478
|
{
|
|
469
|
-
unstyled:
|
|
470
|
-
columns:
|
|
479
|
+
unstyled: m,
|
|
480
|
+
columns: f.current,
|
|
471
481
|
rowReorderSettings: e.rowReorderable
|
|
472
482
|
},
|
|
473
|
-
|
|
483
|
+
Ee
|
|
474
484
|
)), e.scrollable === "none")
|
|
475
485
|
return /* @__PURE__ */ l.createElement(
|
|
476
|
-
|
|
486
|
+
Me,
|
|
477
487
|
{
|
|
478
|
-
gridRef:
|
|
479
|
-
gridProps:
|
|
488
|
+
gridRef: te,
|
|
489
|
+
gridProps: we,
|
|
480
490
|
columnsRef: $(),
|
|
481
|
-
columnsMapRef:
|
|
482
|
-
dataRef:
|
|
483
|
-
slicedData:
|
|
491
|
+
columnsMapRef: G,
|
|
492
|
+
dataRef: g,
|
|
493
|
+
slicedData: O,
|
|
484
494
|
isFixedVirtualScroll: J === j,
|
|
485
|
-
id:
|
|
486
|
-
total:
|
|
495
|
+
id: S,
|
|
496
|
+
total: R,
|
|
487
497
|
detailExpandable: !!e.detail
|
|
488
498
|
},
|
|
489
|
-
/* @__PURE__ */ l.createElement(
|
|
499
|
+
/* @__PURE__ */ l.createElement(Ue, null, /* @__PURE__ */ l.createElement(
|
|
490
500
|
"div",
|
|
491
501
|
{
|
|
492
502
|
id: e.id,
|
|
493
503
|
style: e.style,
|
|
494
|
-
className: m
|
|
504
|
+
className: u(m.wrapper({ size: E }), e.className),
|
|
495
505
|
"aria-label": e.ariaLabel,
|
|
496
|
-
...
|
|
506
|
+
...He
|
|
497
507
|
},
|
|
498
|
-
re,
|
|
499
508
|
ie,
|
|
509
|
+
de,
|
|
500
510
|
/* @__PURE__ */ l.createElement(
|
|
501
|
-
|
|
511
|
+
el,
|
|
502
512
|
{
|
|
503
513
|
selectable: e.selectable,
|
|
504
|
-
className: m
|
|
514
|
+
className: u(m.table({ size: E }))
|
|
505
515
|
},
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
/* @__PURE__ */ l.createElement(
|
|
516
|
+
he,
|
|
517
|
+
ce,
|
|
518
|
+
/* @__PURE__ */ l.createElement($e, { rowReorderable: N }, X)
|
|
509
519
|
),
|
|
510
|
-
|
|
511
|
-
|
|
520
|
+
fe && /* @__PURE__ */ l.createElement(_e, null, M.length ? M : /* @__PURE__ */ l.createElement(Oe, null)),
|
|
521
|
+
Ce && /* @__PURE__ */ l.createElement(l.Fragment, null, /* @__PURE__ */ l.createElement(We, null), /* @__PURE__ */ l.createElement(je, null))
|
|
512
522
|
)),
|
|
513
|
-
|
|
514
|
-
e.pageable &&
|
|
515
|
-
/* @__PURE__ */ l.createElement(
|
|
523
|
+
oe,
|
|
524
|
+
e.pageable && ye,
|
|
525
|
+
/* @__PURE__ */ l.createElement(Qe, { loader: e.loader, showLoader: e.showLoader })
|
|
516
526
|
);
|
|
517
|
-
let
|
|
518
|
-
return
|
|
519
|
-
|
|
527
|
+
let W = e.style || {};
|
|
528
|
+
return D && (W.height || (W = Object.assign({}, W, { height: "450px" }))), /* @__PURE__ */ l.createElement(
|
|
529
|
+
Me,
|
|
520
530
|
{
|
|
521
|
-
gridRef:
|
|
522
|
-
gridProps:
|
|
531
|
+
gridRef: te,
|
|
532
|
+
gridProps: we,
|
|
523
533
|
columnsRef: $(),
|
|
524
|
-
columnsMapRef:
|
|
525
|
-
dataRef:
|
|
526
|
-
slicedData:
|
|
534
|
+
columnsMapRef: G,
|
|
535
|
+
dataRef: g,
|
|
536
|
+
slicedData: O,
|
|
527
537
|
isFixedVirtualScroll: J === j,
|
|
528
|
-
id:
|
|
529
|
-
total:
|
|
538
|
+
id: S,
|
|
539
|
+
total: R,
|
|
530
540
|
detailExpandable: !!e.detail
|
|
531
541
|
},
|
|
532
|
-
/* @__PURE__ */ l.createElement(
|
|
542
|
+
/* @__PURE__ */ l.createElement(Ue, null, /* @__PURE__ */ l.createElement(
|
|
533
543
|
"div",
|
|
534
544
|
{
|
|
535
545
|
id: e.id,
|
|
536
|
-
style:
|
|
537
|
-
className:
|
|
538
|
-
|
|
539
|
-
size:
|
|
540
|
-
virtual:
|
|
546
|
+
style: W,
|
|
547
|
+
className: u(
|
|
548
|
+
m.wrapper({
|
|
549
|
+
size: E,
|
|
550
|
+
virtual: D
|
|
541
551
|
}),
|
|
542
552
|
e.className
|
|
543
553
|
),
|
|
544
554
|
"aria-label": e.ariaLabel,
|
|
545
|
-
...
|
|
555
|
+
...He
|
|
546
556
|
},
|
|
547
|
-
re,
|
|
548
557
|
ie,
|
|
558
|
+
de,
|
|
549
559
|
/* @__PURE__ */ l.createElement(
|
|
550
560
|
"div",
|
|
551
561
|
{
|
|
552
|
-
className: m
|
|
562
|
+
className: u(m.ariaRoot({})),
|
|
553
563
|
role: "grid",
|
|
554
|
-
"aria-colcount":
|
|
555
|
-
"aria-rowcount":
|
|
556
|
-
id:
|
|
557
|
-
"aria-label":
|
|
564
|
+
"aria-colcount": b.length,
|
|
565
|
+
"aria-rowcount": R,
|
|
566
|
+
id: S,
|
|
567
|
+
"aria-label": z.toLanguageString(Je, ol[Je])
|
|
558
568
|
},
|
|
559
|
-
|
|
560
|
-
/* @__PURE__ */ l.createElement("div", { className: m
|
|
561
|
-
|
|
569
|
+
ce,
|
|
570
|
+
/* @__PURE__ */ l.createElement("div", { className: u(m.container({})), role: "presentation" }, /* @__PURE__ */ l.createElement(al, null, /* @__PURE__ */ l.createElement("div", { className: u(m.content({})), role: "presentation" }, /* @__PURE__ */ l.createElement("div", { className: u(m.tableWrap({})), role: "presentation" }, /* @__PURE__ */ l.createElement(
|
|
571
|
+
ll,
|
|
562
572
|
{
|
|
563
573
|
selectable: e.selectable,
|
|
564
|
-
tableClassName:
|
|
565
|
-
|
|
566
|
-
size:
|
|
574
|
+
tableClassName: u(
|
|
575
|
+
m.table({
|
|
576
|
+
size: E
|
|
567
577
|
})
|
|
568
578
|
),
|
|
569
|
-
tableStyle: { userSelect:
|
|
579
|
+
tableStyle: { userSelect: dt }
|
|
570
580
|
},
|
|
571
|
-
|
|
572
|
-
/* @__PURE__ */ l.createElement(
|
|
573
|
-
),
|
|
581
|
+
he,
|
|
582
|
+
/* @__PURE__ */ l.createElement($e, { rowReorderable: N }, X)
|
|
583
|
+
), fe && /* @__PURE__ */ l.createElement(_e, null, M.length ? M : /* @__PURE__ */ l.createElement(Oe, null))), D && /* @__PURE__ */ l.createElement(
|
|
574
584
|
"div",
|
|
575
585
|
{
|
|
576
|
-
className: m
|
|
586
|
+
className: u(m.heightContainer({})),
|
|
577
587
|
role: "presentation"
|
|
578
588
|
},
|
|
579
|
-
/* @__PURE__ */ l.createElement(
|
|
589
|
+
/* @__PURE__ */ l.createElement(rl, { isVirtualScroll: D })
|
|
580
590
|
)))),
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
/* @__PURE__ */ l.createElement(
|
|
591
|
+
ft,
|
|
592
|
+
Ce && /* @__PURE__ */ l.createElement(l.Fragment, null, /* @__PURE__ */ l.createElement(We, null), /* @__PURE__ */ l.createElement(je, null)),
|
|
593
|
+
/* @__PURE__ */ l.createElement(qt, null)
|
|
584
594
|
),
|
|
585
|
-
|
|
586
|
-
e.pageable &&
|
|
587
|
-
/* @__PURE__ */ l.createElement(
|
|
595
|
+
oe,
|
|
596
|
+
e.pageable && ye,
|
|
597
|
+
/* @__PURE__ */ l.createElement(Qe, { loader: e.loader, showLoader: e.showLoader })
|
|
588
598
|
))
|
|
589
599
|
);
|
|
590
600
|
});
|
|
591
|
-
|
|
601
|
+
fl.displayName = "KendoReactGridComponent";
|
|
592
602
|
export {
|
|
593
|
-
|
|
603
|
+
fl as GridComponent
|
|
594
604
|
};
|