@procore/data-table 14.17.0 → 14.18.0

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.
@@ -19,9 +19,9 @@ var _isEqual = require('lodash.isequal');
19
19
  var ReactResizeDetector = require('react-resize-detector');
20
20
  var labsDatetimeSelect = require('@procore/labs-datetime-select');
21
21
  var Decimal = require('decimal.js');
22
- var styled4 = require('styled-components');
23
- var labsGroupBySelect = require('@procore/labs-group-by-select');
22
+ var styled3 = require('styled-components');
24
23
  var globalizationToolkit = require('@procore/globalization-toolkit');
24
+ var labsGroupBySelect = require('@procore/labs-group-by-select');
25
25
 
26
26
  function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
27
27
 
@@ -33,7 +33,7 @@ var ReactDOM__default = /*#__PURE__*/_interopDefault(ReactDOM);
33
33
  var _isEqual__default = /*#__PURE__*/_interopDefault(_isEqual);
34
34
  var ReactResizeDetector__default = /*#__PURE__*/_interopDefault(ReactResizeDetector);
35
35
  var Decimal__default = /*#__PURE__*/_interopDefault(Decimal);
36
- var styled4__default = /*#__PURE__*/_interopDefault(styled4);
36
+ var styled3__default = /*#__PURE__*/_interopDefault(styled3);
37
37
 
38
38
  var __create = Object.create;
39
39
  var __defProp = Object.defineProperty;
@@ -1424,7 +1424,7 @@ ag-grid, ag-grid-angular, ag-grid-ng2, ag-grid-polymer, ag-grid-aurelia {
1424
1424
  animation-iteration-count: infinite;
1425
1425
  animation-name: ag-shake-left-to-right;
1426
1426
  }
1427
- @keyframes _ag-shake-left-to-right_1t4e8_369 {
1427
+ @keyframes _ag-shake-left-to-right_18odb_369 {
1428
1428
  from {
1429
1429
  padding-left: 6px;
1430
1430
  padding-right: 2px;
@@ -5425,7 +5425,7 @@ input[class^=ag-][type=button]:focus, button[class^=ag-]:focus {
5425
5425
  animation-iteration-count: infinite;
5426
5426
  animation-timing-function: linear;
5427
5427
  }
5428
- @keyframes _spin_1t4e8_1 {
5428
+ @keyframes _spin_18odb_1 {
5429
5429
  from {
5430
5430
  transform: rotate(0deg);
5431
5431
  }
@@ -7731,7 +7731,7 @@ input[class^=ag-][type=range]:disabled {
7731
7731
  .ag-theme-alpine.ag-theme-alpine .ag-details-row-auto-height .ag-center-cols-viewport, .ag-theme-alpine.ag-theme-alpine .ag-layout-auto-height .ag-center-cols-viewport {
7732
7732
  min-height: 0px;
7733
7733
  }
7734
- .ag-theme-alpine.ag-theme-alpine .ag-overlay button {
7734
+ .ag-theme-alpine.ag-theme-alpine .ag-overlay .ag-react-container {
7735
7735
  pointer-events: initial;
7736
7736
  }
7737
7737
  .ag-theme-alpine.ag-theme-alpine .ag-menu, .ag-theme-alpine.ag-theme-alpine .ag-menu-header {
@@ -7930,7 +7930,7 @@ input[class^=ag-][type=range]:disabled {
7930
7930
  padding-left: 16px;
7931
7931
  }
7932
7932
 
7933
- div._contextPanel_1t4e8_7153 {
7933
+ div._contextPanel_18odb_7153 {
7934
7934
  width: 400px;
7935
7935
  transition: all ease 500ms;
7936
7936
  flex: 0 0 auto;
@@ -7939,7 +7939,7 @@ div._contextPanel_1t4e8_7153 {
7939
7939
  border: 1px solid #d6dadc;
7940
7940
  display: flex;
7941
7941
  }
7942
- div._contextPanel--hidden_1t4e8_7162 {
7942
+ div._contextPanel--hidden_18odb_7162 {
7943
7943
  border: none;
7944
7944
  overflow: hidden;
7945
7945
  padding: 0px;
@@ -7947,50 +7947,50 @@ div._contextPanel--hidden_1t4e8_7162 {
7947
7947
  width: 0px;
7948
7948
  }
7949
7949
 
7950
- ._contextPanelWrapper_1t4e8_7170 {
7950
+ ._contextPanelWrapper_18odb_7170 {
7951
7951
  position: relative;
7952
7952
  flex-grow: 1;
7953
7953
  }
7954
7954
 
7955
- ._contextPanelBody_1t4e8_7175 {
7955
+ ._contextPanelBody_18odb_7175 {
7956
7956
  width: clamp(380px, 400px, 100%);
7957
7957
  }
7958
7958
 
7959
- ._contextPanel-stickyHeader_1t4e8_7179 {
7959
+ ._contextPanel-stickyHeader_18odb_7179 {
7960
7960
  background-color: #ffffff;
7961
7961
  position: sticky;
7962
7962
  top: 0;
7963
7963
  z-index: 5;
7964
7964
  }
7965
7965
 
7966
- ._filters-list_1t4e8_7186 {
7966
+ ._filters-list_18odb_7186 {
7967
7967
  padding: 0;
7968
7968
  margin: 0;
7969
7969
  }
7970
- ._filters-list_1t4e8_7186 ol {
7970
+ ._filters-list_18odb_7186 ol {
7971
7971
  padding: 0;
7972
7972
  margin: 0;
7973
7973
  }
7974
7974
 
7975
- ._col-drag-column-icon_1t4e8_7195 {
7975
+ ._col-drag-column-icon_18odb_7195 {
7976
7976
  color: #6a767c;
7977
7977
  }
7978
7978
 
7979
- ._tabular-nums_1t4e8_7199 {
7979
+ ._tabular-nums_18odb_7199 {
7980
7980
  font-variant-numeric: tabular-nums;
7981
7981
  }`;
7982
7982
  document.head.appendChild(document.createElement("style")).appendChild(document.createTextNode(css));
7983
7983
  var styles_default = {
7984
- "contextPanel": "_contextPanel_1t4e8_7153",
7985
- "contextPanel--hidden": "_contextPanel--hidden_1t4e8_7162",
7986
- "contextPanelWrapper": "_contextPanelWrapper_1t4e8_7170",
7987
- "contextPanelBody": "_contextPanelBody_1t4e8_7175",
7988
- "contextPanel-stickyHeader": "_contextPanel-stickyHeader_1t4e8_7179",
7989
- "filters-list": "_filters-list_1t4e8_7186",
7990
- "col-drag-column-icon": "_col-drag-column-icon_1t4e8_7195",
7991
- "tabular-nums": "_tabular-nums_1t4e8_7199",
7992
- "ag-shake-left-to-right": "_ag-shake-left-to-right_1t4e8_369",
7993
- "spin": "_spin_1t4e8_1"
7984
+ "contextPanel": "_contextPanel_18odb_7153",
7985
+ "contextPanel--hidden": "_contextPanel--hidden_18odb_7162",
7986
+ "contextPanelWrapper": "_contextPanelWrapper_18odb_7170",
7987
+ "contextPanelBody": "_contextPanelBody_18odb_7175",
7988
+ "contextPanel-stickyHeader": "_contextPanel-stickyHeader_18odb_7179",
7989
+ "filters-list": "_filters-list_18odb_7186",
7990
+ "col-drag-column-icon": "_col-drag-column-icon_18odb_7195",
7991
+ "tabular-nums": "_tabular-nums_18odb_7199",
7992
+ "ag-shake-left-to-right": "_ag-shake-left-to-right_18odb_369",
7993
+ "spin": "_spin_18odb_1"
7994
7994
  };
7995
7995
 
7996
7996
  // src/utils/getCellValueTypographyProps.ts
@@ -8078,7 +8078,7 @@ var Renderer = ({
8078
8078
  var ButtonsCellRenderer = withDataTableRenderer(Renderer, "select");
8079
8079
 
8080
8080
  // src/utils/truncation.scss
8081
- var css2 = `._truncatingText_114ye_1 {
8081
+ var css2 = `._truncatingText_c077g_1 {
8082
8082
  white-space: normal;
8083
8083
  overflow: hidden;
8084
8084
  word-wrap: break-word;
@@ -8087,17 +8087,43 @@ var css2 = `._truncatingText_114ye_1 {
8087
8087
  -webkit-box-orient: vertical;
8088
8088
  -webkit-line-clamp: 1;
8089
8089
  }
8090
- ._truncatingText--md_114ye_10 {
8090
+ ._truncatingText--md_c077g_10 {
8091
8091
  -webkit-line-clamp: 2;
8092
8092
  }
8093
- ._truncatingText--lg_114ye_13 {
8093
+ ._truncatingText--lg_c077g_13 {
8094
8094
  -webkit-line-clamp: 3;
8095
+ }
8096
+ ._truncatingText--overflowVisible_c077g_16 {
8097
+ overflow: visible;
8098
+ }
8099
+
8100
+ ._extendClickableArea_c077g_20 {
8101
+ display: inline-block;
8102
+ position: relative;
8103
+ width: 100%;
8104
+ }
8105
+ ._extendClickableArea_c077g_20::before {
8106
+ content: "";
8107
+ position: absolute;
8108
+ top: 50%;
8109
+ left: 50%;
8110
+ width: 48px;
8111
+ height: 48px;
8112
+ transform: translate(-50%, -50%);
8113
+ pointer-events: auto;
8114
+ background: transparent;
8115
+ }
8116
+ ._extendClickableArea--rowHeightSm_c077g_36::before {
8117
+ height: 32px;
8095
8118
  }`;
8096
8119
  document.head.appendChild(document.createElement("style")).appendChild(document.createTextNode(css2));
8097
8120
  var truncation_default = {
8098
- "truncatingText": "_truncatingText_114ye_1",
8099
- "truncatingText--md": "_truncatingText--md_114ye_10",
8100
- "truncatingText--lg": "_truncatingText--lg_114ye_13"
8121
+ "truncatingText": "_truncatingText_c077g_1",
8122
+ "truncatingText--md": "_truncatingText--md_c077g_10",
8123
+ "truncatingText--lg": "_truncatingText--lg_c077g_13",
8124
+ "truncatingText--overflowVisible": "_truncatingText--overflowVisible_c077g_16",
8125
+ "extendClickableArea": "_extendClickableArea_c077g_20",
8126
+ "extendClickableArea--rowHeightSm": "_extendClickableArea--rowHeightSm_c077g_36"
8101
8127
  };
8102
8128
 
8103
8129
  // src/utils/ContactItem.tsx
@@ -52972,8 +52998,11 @@ globalObj.MouseEvent = typeof MouseEvent === "undefined" ? {} : MouseEvent;
52972
52998
  // src/CellRenderers/GroupCell.tsx
52973
52999
  var GroupCellRenderer2 = GroupCellRenderer;
52974
53000
  var cx6 = classnames__default.default.bind(truncation_default);
53001
+ var MIN_LINK_WIDTH = 48;
52975
53002
  var InternalLinkCellRenderer = ({ columnDefinition, isGroup, data, rowHeight, value }) => {
52976
53003
  var _a, _b, _c, _d;
53004
+ const [isLinkWidthBelowMin, setIsLinkWidthBelowMin] = React76.useState(false);
53005
+ const linkRef = React76.useRef(null);
52977
53006
  const internalValue = value ? (_a = columnDefinition.getStringFormattedValue) == null ? void 0 : _a.call(columnDefinition, value) : "";
52978
53007
  const typographyProps = getCellValueTypographyProps(
52979
53008
  (_b = columnDefinition.cellRendererParams) == null ? void 0 : _b.typographyProps
@@ -52984,14 +53013,24 @@ var InternalLinkCellRenderer = ({ columnDefinition, isGroup, data, rowHeight, va
52984
53013
  "truncatingText",
52985
53014
  {
52986
53015
  "truncatingText--md": rowHeight === rowSize.md,
52987
- "truncatingText--lg": rowHeight === rowSize.lg
53016
+ "truncatingText--lg": rowHeight === rowSize.lg,
53017
+ "truncatingText--overflowVisible": isLinkWidthBelowMin
52988
53018
  }
52989
53019
  );
52990
53020
  if (isGroup) {
52991
53021
  return /* @__PURE__ */ React76__default.default.createElement(coreReact.Typography, { ...typographyProps, className, weight: "semibold" }, value);
52992
53022
  }
53023
+ React76.useEffect(() => {
53024
+ if (linkRef.current) {
53025
+ const { width } = linkRef.current.getBoundingClientRect();
53026
+ setIsLinkWidthBelowMin(width < MIN_LINK_WIDTH);
53027
+ }
53028
+ }, [internalValue]);
52993
53029
  const isExternalLink = columnDefinition.cellRendererParams.isExternalLink ?? false;
52994
53030
  const URL = columnDefinition.cellRendererParams.getURL(value, data);
53031
+ const extendClickableAreaClassNames = isLinkWidthBelowMin ? cx6("extendClickableArea", {
53032
+ "extendClickableArea--rowHeightSm": rowHeight === rowSize.sm
53033
+ }) : "";
52995
53034
  if (isExternalLink && value && URL) {
52996
53035
  return /* @__PURE__ */ React76__default.default.createElement(
52997
53036
  coreReact.Typography,
@@ -53011,7 +53050,7 @@ var InternalLinkCellRenderer = ({ columnDefinition, isGroup, data, rowHeight, va
53011
53050
  )
53012
53051
  );
53013
53052
  }
53014
- return URL ? /* @__PURE__ */ React76__default.default.createElement(coreReact.Typography, { ...typographyProps, className }, /* @__PURE__ */ React76__default.default.createElement(coreReact.Link, { href: URL }, internalValue)) : /* @__PURE__ */ React76__default.default.createElement(coreReact.Typography, { ...typographyProps }, internalValue);
53053
+ return URL ? /* @__PURE__ */ React76__default.default.createElement(coreReact.Typography, { ...typographyProps, className }, /* @__PURE__ */ React76__default.default.createElement(coreReact.Link, { href: URL, className: extendClickableAreaClassNames, ref: linkRef }, internalValue)) : /* @__PURE__ */ React76__default.default.createElement(coreReact.Typography, { ...typographyProps }, internalValue);
53015
53054
  };
53016
53055
  var LinkCellRenderer = withDataTableRenderer(
53017
53056
  InternalLinkCellRenderer,
@@ -53092,7 +53131,7 @@ var NumberCellEditor2 = withDataTableEditor(
53092
53131
  );
53093
53132
 
53094
53133
  // src/CellRenderers/peopleCellStyles.scss
53095
- var css3 = `._truncatingText_3wkw2_1 {
53134
+ var css3 = `._truncatingText_14qzu_1 {
53096
53135
  white-space: normal;
53097
53136
  overflow: hidden;
53098
53137
  word-wrap: break-word;
@@ -53101,33 +53140,59 @@ var css3 = `._truncatingText_3wkw2_1 {
53101
53140
  -webkit-box-orient: vertical;
53102
53141
  -webkit-line-clamp: 1;
53103
53142
  }
53104
- ._truncatingText--md_3wkw2_10 {
53143
+ ._truncatingText--md_14qzu_10 {
53105
53144
  -webkit-line-clamp: 2;
53106
53145
  }
53107
- ._truncatingText--lg_3wkw2_13 {
53146
+ ._truncatingText--lg_14qzu_13 {
53108
53147
  -webkit-line-clamp: 3;
53109
53148
  }
53149
+ ._truncatingText--overflowVisible_14qzu_16 {
53150
+ overflow: visible;
53151
+ }
53152
+
53153
+ ._extendClickableArea_14qzu_20 {
53154
+ display: inline-block;
53155
+ position: relative;
53156
+ width: 100%;
53157
+ }
53158
+ ._extendClickableArea_14qzu_20::before {
53159
+ content: "";
53160
+ position: absolute;
53161
+ top: 50%;
53162
+ left: 50%;
53163
+ width: 48px;
53164
+ height: 48px;
53165
+ transform: translate(-50%, -50%);
53166
+ pointer-events: auto;
53167
+ background: transparent;
53168
+ }
53169
+ ._extendClickableArea--rowHeightSm_14qzu_36::before {
53170
+ height: 32px;
53171
+ }
53110
53172
 
53111
- ._inlineListItems_3wkw2_17 {
53173
+ ._inlineListItems_14qzu_40 {
53112
53174
  list-style: none;
53113
53175
  margin: 0;
53114
53176
  padding: 0;
53115
53177
  }
53116
- ._inlineListItems_3wkw2_17 > li {
53178
+ ._inlineListItems_14qzu_40 > li {
53117
53179
  display: inline;
53118
53180
  }
53119
53181
 
53120
- ._dynamicRowHeightSpacing_3wkw2_26 {
53182
+ ._dynamicRowHeightSpacing_14qzu_49 {
53121
53183
  margin-top: 8px;
53122
53184
  margin-bottom: 8px;
53123
53185
  }`;
53124
53186
  document.head.appendChild(document.createElement("style")).appendChild(document.createTextNode(css3));
53125
53187
  var peopleCellStyles_default = {
53126
- "truncatingText": "_truncatingText_3wkw2_1",
53127
- "truncatingText--md": "_truncatingText--md_3wkw2_10",
53128
- "truncatingText--lg": "_truncatingText--lg_3wkw2_13",
53129
- "inlineListItems": "_inlineListItems_3wkw2_17",
53130
- "dynamicRowHeightSpacing": "_dynamicRowHeightSpacing_3wkw2_26"
53188
+ "truncatingText": "_truncatingText_14qzu_1",
53189
+ "truncatingText--md": "_truncatingText--md_14qzu_10",
53190
+ "truncatingText--lg": "_truncatingText--lg_14qzu_13",
53191
+ "truncatingText--overflowVisible": "_truncatingText--overflowVisible_14qzu_16",
53192
+ "extendClickableArea": "_extendClickableArea_14qzu_20",
53193
+ "extendClickableArea--rowHeightSm": "_extendClickableArea--rowHeightSm_14qzu_36",
53194
+ "inlineListItems": "_inlineListItems_14qzu_40",
53195
+ "dynamicRowHeightSpacing": "_dynamicRowHeightSpacing_14qzu_49"
53131
53196
  };
53132
53197
 
53133
53198
  // src/CellRenderers/PeopleCell.tsx
@@ -82945,7 +83010,7 @@ var FILTERS_GROUP_EXPANDABLE_AREA_VERTICAL_MARGIN = coreReact.spacing.md;
82945
83010
  var FILTERS_GROUP_ITEM_HEIGHT = 60;
82946
83011
  var ITEMS_IN_FILTERS_GROUP = 5;
82947
83012
  var FILTERS_GROUP_EXPANDABLE_AREA_HEIGHT = (FILTERS_GROUP_ITEM_HEIGHT + coreReact.spacing.xl) * ITEMS_IN_FILTERS_GROUP + BORDER_WIDTH;
82948
- var StyledPanelSection = styled4__default.default(coreReact.Panel.Section)`
83013
+ var StyledPanelSection = styled3__default.default(coreReact.Panel.Section)`
82949
83014
  // Filters Group container styles
82950
83015
  &.filters-list-group-section {
82951
83016
  padding-bottom: ${FILTERS_GROUP_VERTICAL_MARGIN}px;
@@ -83236,905 +83301,307 @@ var ConfigPanelButton = () => {
83236
83301
  )
83237
83302
  );
83238
83303
  };
83239
- function getFilterTokenText(columnDefinition, filterValue) {
83240
- var _a, _b, _c, _d;
83241
- if ((_a = columnDefinition == null ? void 0 : columnDefinition.filterProps) == null ? void 0 : _a.getFilterTokenText) {
83242
- return (_c = (_b = columnDefinition == null ? void 0 : columnDefinition.filterProps) == null ? void 0 : _b.getFilterTokenText) == null ? void 0 : _c.call(_b, {
83243
- headerName: (columnDefinition == null ? void 0 : columnDefinition.headerName) || "",
83244
- value: filterValue
83245
- });
83304
+ var QuickFilterLabel = React76__default.default.forwardRef(({ enabled, ...props }, ref) => {
83305
+ return /* @__PURE__ */ React76__default.default.createElement(StyledQuickFilterLabel, { $enabled: enabled }, /* @__PURE__ */ React76__default.default.createElement(coreReact.SelectButton, { ref, ...props }));
83306
+ });
83307
+ var StyledQuickFilterLabel = styled3__default.default.div`
83308
+ ${coreReact.StyledSelectButton} {
83309
+ width: auto;
83310
+ max-width: 380px;
83311
+ ${({ $enabled }) => $enabled && styled3.css`
83312
+ background: ${coreReact.colors.blue96};
83313
+ border-color: ${coreReact.colors.blue96};
83314
+ font-weight: ${coreReact.typographyWeights.semibold};
83315
+ &:hover {
83316
+ background: ${coreReact.colors.blue90};
83317
+ border-color: ${coreReact.colors.blue90};
83318
+ }
83319
+ ${coreReact.StyledSelectButtonLabel} {
83320
+ color: ${coreReact.colors.blue45};
83321
+ }
83322
+ ${coreReact.StyledButton} {
83323
+ color: ${coreReact.colors.blue45};
83324
+ &:hover {
83325
+ background: white;
83326
+ }
83327
+ }
83328
+ ${coreReact.StyledSelectArrow} {
83329
+ svg {
83330
+ fill: ${coreReact.colors.blue45};
83331
+ }
83332
+ }
83333
+ `}
83246
83334
  }
83247
- if (columnDefinition.filterRenderer === DateFilterRenderer_default) {
83335
+ `;
83336
+
83337
+ // src/QuickFilterRenderers/DateQuickFilterRenderer.tsx
83338
+ function getPlacement2(currentSelectionType, position) {
83339
+ if (currentSelectionType === "single") {
83340
+ return "bottom-left";
83341
+ }
83342
+ if (position === "start") {
83343
+ return "bottom-left";
83344
+ }
83345
+ return "bottom-right";
83346
+ }
83347
+ var OptionalDateTimeProvider2 = ({ timeZone, children }) => {
83348
+ return timeZone ? /* @__PURE__ */ React76__default.default.createElement(coreReact.DateTimeProvider, { timeZone }, children) : /* @__PURE__ */ React76__default.default.createElement(React76__default.default.Fragment, null, children);
83349
+ };
83350
+ var DateFilterSelect2 = React76__default.default.forwardRef(
83351
+ ({
83352
+ afterHide,
83353
+ selectionType = "either",
83354
+ headerName,
83355
+ disabled,
83356
+ onChange,
83357
+ position,
83358
+ selectedValue,
83359
+ setSelectionType = () => {
83360
+ }
83361
+ }, ref) => {
83362
+ const dateTime = coreReact.useDateTime();
83363
+ const { start, end } = selectedValue;
83364
+ const selectedDate = (position === "start" ? start : end) ?? void 0;
83365
+ const [displayed, setDisplayed2] = React76__default.default.useState(
83366
+ // @ts-ignore
83367
+ selectedDate || dateTime.newDate()
83368
+ );
83369
+ React76__default.default.useEffect(() => {
83370
+ if (dateFns.isDate(start) && !dateFns.isDate(end) && position === "end") {
83371
+ setDisplayed2(start);
83372
+ }
83373
+ if (!dateFns.isDate(start) && dateFns.isDate(end) && position === "start") {
83374
+ setDisplayed2(end);
83375
+ }
83376
+ }, [position, selectedValue]);
83377
+ function onClear() {
83378
+ onChange(null, position);
83379
+ }
83380
+ const clearRef = React76__default.default.useRef(null);
83381
+ const monthRef = React76__default.default.useRef(null);
83382
+ const yearRef = React76__default.default.useRef(null);
83383
+ const overlay = /* @__PURE__ */ React76__default.default.createElement(
83384
+ DateFilterOverlay,
83385
+ {
83386
+ displayDate: displayed,
83387
+ selectionType,
83388
+ monthRef,
83389
+ onSelect: (date) => {
83390
+ onChange(date, position);
83391
+ },
83392
+ position,
83393
+ selectedValue,
83394
+ setDisplayDate: setDisplayed2,
83395
+ setSelectionType,
83396
+ yearRef
83397
+ }
83398
+ );
83248
83399
  return /* @__PURE__ */ React76__default.default.createElement(
83249
- OptionalDateTimeProvider,
83400
+ coreReact.OverlayTrigger,
83250
83401
  {
83251
- timeZone: columnDefinition.timeZone
83402
+ afterHide,
83403
+ autoFocus: true,
83404
+ beforeShow: (e) => {
83405
+ if (coreReact.isEventSource(clearRef, e)) {
83406
+ return false;
83407
+ }
83408
+ return true;
83409
+ },
83410
+ clickOutsideIgnoreRefs: [monthRef, yearRef],
83411
+ overlay,
83412
+ placement: getPlacement2(selectionType, position),
83413
+ ref,
83414
+ restoreFocusOnHide: true,
83415
+ role: "dialog"
83252
83416
  },
83253
83417
  /* @__PURE__ */ React76__default.default.createElement(
83254
- DateFilterTokenText,
83418
+ DateQuickFilterLabel,
83255
83419
  {
83256
- headerName: columnDefinition.headerName,
83257
- value: filterValue
83420
+ headerName,
83421
+ onClear,
83422
+ value: selectedDate,
83423
+ disabled
83258
83424
  }
83259
83425
  )
83260
83426
  );
83261
83427
  }
83262
- if (columnDefinition.filterRenderer === NumberFilterRenderer) {
83263
- return columnDefinition == null ? void 0 : columnDefinition.headerName;
83264
- }
83265
- if (Array.isArray(filterValue)) {
83266
- if (filterValue.length === 0) {
83267
- return columnDefinition == null ? void 0 : columnDefinition.headerName;
83268
- }
83269
- if (filterValue.length === 1) {
83270
- return `${columnDefinition == null ? void 0 : columnDefinition.headerName}: ${getLabel(
83271
- (_d = columnDefinition.filterProps) == null ? void 0 : _d.getLabel,
83272
- filterValue[0]
83273
- )}`;
83428
+ );
83429
+ function DateFilter3({
83430
+ // TODO: talk to design about potential loading UX for this.
83431
+ // core DateSelect doesn't have it
83432
+ // loading,
83433
+ headerName,
83434
+ onChange,
83435
+ selectionType = "either",
83436
+ value,
83437
+ disabled,
83438
+ ...props
83439
+ }) {
83440
+ const [selectedValue, setSelectedValue] = React76__default.default.useState({
83441
+ type: selectionType === "either" ? "range" : selectionType
83442
+ });
83443
+ React76__default.default.useEffect(() => {
83444
+ const parsedValue = value.map((date) => {
83445
+ if (dateFns.isDate(date)) {
83446
+ return date;
83447
+ }
83448
+ return dateFns.parseISO(String(date));
83449
+ });
83450
+ const type = dateFns.isSameDay(parsedValue[0], parsedValue[1]) ? "single" : "range";
83451
+ setSelectedValue({ type, start: parsedValue[0], end: parsedValue[1] });
83452
+ }, [value]);
83453
+ const dateRangeEndDateRef = React76__default.default.useRef(null);
83454
+ function dateFilterOnChange(date, position) {
83455
+ const newValue = getValueFromSelection(selectedValue, date, position);
83456
+ setSelectedValue(newValue);
83457
+ if (isValidDateSelection(newValue)) {
83458
+ onChange(
83459
+ newValue.start || newValue.end ? [
83460
+ newValue.start,
83461
+ newValue.type === "single" ? newValue.start : newValue.end
83462
+ ] : []
83463
+ );
83274
83464
  }
83275
- return `${columnDefinition == null ? void 0 : columnDefinition.headerName}: (${filterValue.length})`;
83276
- }
83277
- return columnDefinition == null ? void 0 : columnDefinition.headerName;
83278
- }
83279
- var ensureArray = (input) => {
83280
- if (input === null) {
83281
- return [];
83282
- }
83283
- return Array.isArray(input) ? input : [input];
83284
- };
83285
- var FiltersPanelToggleButton = ({ hasSelectedFilters, hasDefinedFilters }) => {
83286
- const I18n = coreReact.useI18nContext();
83287
- const { contextPanel } = useInternalTableContext();
83288
- const hasNoContent = useTableHasNoContent();
83289
- if (!hasDefinedFilters) {
83290
- return null;
83291
83465
  }
83292
- return /* @__PURE__ */ React76__default.default.createElement(
83293
- EmptyResultsControlTooltip,
83294
- {
83295
- featureI18nKey: "featureFilter",
83296
- enabled: hasNoContent
83466
+ const onSelectionTypeChange = React76__default.default.useCallback(
83467
+ (newSelectionType) => {
83468
+ setSelectedValue({ type: newSelectionType });
83297
83469
  },
83298
- /* @__PURE__ */ React76__default.default.createElement(
83299
- coreReact.ToggleButton,
83300
- {
83301
- "data-qa": "data-table-show-filters-button",
83302
- disabled: hasNoContent,
83303
- icon: /* @__PURE__ */ React76__default.default.createElement(FilterIcon, null),
83304
- onClick: () => {
83305
- if (contextPanel.content === "filters") {
83306
- contextPanel.hide();
83307
- } else {
83308
- contextPanel.show("filters");
83309
- }
83310
- },
83311
- selected: contextPanel.content === "filters"
83312
- },
83313
- hasSelectedFilters ? I18n.t("dataTable.filters.moreFilters") : I18n.t("dataTable.filters.filters")
83314
- )
83470
+ [setSelectedValue]
83315
83471
  );
83316
- };
83317
- var ServerSideFiltersPanelToggleButton = () => {
83318
- const {
83319
- filterStorage: { hasDefinedFilters, hasSelectedFilters }
83320
- } = useInternalTableContext();
83321
- return /* @__PURE__ */ React76__default.default.createElement(
83322
- FiltersPanelToggleButton,
83472
+ function dateRangeAfterHide() {
83473
+ var _a;
83474
+ if (selectedValue.type === "range" && dateFns.isDate(selectedValue.start) && !dateFns.isDate(selectedValue.end)) {
83475
+ (_a = dateRangeEndDateRef.current) == null ? void 0 : _a.click();
83476
+ }
83477
+ return true;
83478
+ }
83479
+ return /* @__PURE__ */ React76__default.default.createElement(coreReact.FlexList, { space: "xs", "data-qa": props["data-qa"] }, /* @__PURE__ */ React76__default.default.createElement(
83480
+ DateFilterSelect2,
83323
83481
  {
83324
- hasDefinedFilters,
83325
- hasSelectedFilters
83482
+ afterHide: dateRangeAfterHide,
83483
+ headerName,
83484
+ onChange: dateFilterOnChange,
83485
+ position: "start",
83486
+ selectedValue,
83487
+ selectionType,
83488
+ setSelectionType: onSelectionTypeChange,
83489
+ disabled
83326
83490
  }
83327
- );
83328
- };
83329
- var ClientSideFiltersPanelToggleButton = () => {
83330
- const { filterState } = useInternalTableContext();
83331
- const activeFilters = React76__default.default.useMemo(() => {
83332
- return filterState.allAvailableFilters.filter(({ instance }) => {
83333
- return instance.isFilterActive();
83334
- });
83335
- }, [filterState.allAvailableFilters]);
83336
- return /* @__PURE__ */ React76__default.default.createElement(
83337
- FiltersPanelToggleButton,
83491
+ ), selectedValue.type === "range" && /* @__PURE__ */ React76__default.default.createElement(
83492
+ DateFilterSelect2,
83338
83493
  {
83339
- hasDefinedFilters: filterState.allAvailableFilters.length > 0,
83340
- hasSelectedFilters: activeFilters.length > 0
83494
+ headerName,
83495
+ onChange: dateFilterOnChange,
83496
+ position: "end",
83497
+ ref: dateRangeEndDateRef,
83498
+ selectedValue,
83499
+ selectionType,
83500
+ setSelectionType: onSelectionTypeChange,
83501
+ disabled
83341
83502
  }
83342
- );
83343
- };
83344
-
83345
- // src/QuickControls/QuickFilters.tsx
83346
- var FilterIcon = () => {
83347
- return /* @__PURE__ */ React76__default.default.createElement(
83348
- "svg",
83503
+ ));
83504
+ }
83505
+ function ServerSideQuickDateFilterRenderer({
83506
+ columnDefinition,
83507
+ disabled
83508
+ }) {
83509
+ var _a;
83510
+ const { onChange, value = [] } = useServerSideFilter({
83511
+ columnDefinition
83512
+ });
83513
+ const colDef = columnDefinition;
83514
+ return /* @__PURE__ */ React76__default.default.createElement(OptionalDateTimeProvider2, { timeZone: colDef.timeZone }, /* @__PURE__ */ React76__default.default.createElement(
83515
+ DateFilter3,
83349
83516
  {
83350
- focusable: false,
83351
- width: "16",
83352
- height: "16",
83353
- viewBox: "0 0 20 20",
83354
- fill: "none",
83355
- xmlns: "http://www.w3.org/2000/svg"
83356
- },
83357
- /* @__PURE__ */ React76__default.default.createElement(
83358
- "path",
83359
- {
83360
- fillRule: "evenodd",
83361
- clipRule: "evenodd",
83362
- d: "M3 5V7H17V5H3ZM8 15H12V13H8V15ZM15 11H5V9H15V11Z",
83363
- fill: "currentColor"
83364
- }
83365
- )
83517
+ selectionType: ((_a = colDef.filterProps) == null ? void 0 : _a.selectionType) ?? "either",
83518
+ headerName: colDef.headerName,
83519
+ disabled,
83520
+ onChange: (selected) => {
83521
+ onChange(
83522
+ selected.map((date) => {
83523
+ return date ? {
83524
+ // future extensions can go here (month, day, year keys etc)
83525
+ date
83526
+ } : (
83527
+ // TODO: refactor out date-specific getId stuff from useServerSideFilterStorage
83528
+ date
83529
+ );
83530
+ })
83531
+ );
83532
+ },
83533
+ value: value.map((option) => option ? option.date : option)
83534
+ }
83535
+ ));
83536
+ }
83537
+ var QuickDateFilterRenderer = (props) => {
83538
+ const { onServerSideDataRequest } = useInternalTableContext();
83539
+ if (onServerSideDataRequest) {
83540
+ return /* @__PURE__ */ React76__default.default.createElement(ServerSideQuickDateFilterRenderer, { ...props });
83541
+ }
83542
+ logger.error(
83543
+ "Warning: Date Filters are currently only implemented for the serverside row model"
83366
83544
  );
83545
+ return null;
83367
83546
  };
83368
- var StyledFilterTokenWrapper = styled4__default.default.div`
83369
- ${coreReact.UNSAFE_StyledFilterTokenLabel} {
83370
- font-weight: ${coreReact.typographyWeights.semibold};
83547
+ var dateInputLocales = {
83548
+ "fr-CA": {
83549
+ placeholders: { day: "jj", month: "mm", year: "aaaa" }
83550
+ },
83551
+ "fr-FR": {
83552
+ placeholders: { day: "jj", month: "mm", year: "aaaa" }
83553
+ },
83554
+ es: {
83555
+ placeholders: { day: "dd", month: "mm", year: "aaaa" }
83556
+ },
83557
+ "es-ES": {
83558
+ placeholders: { day: "dd", month: "mm", year: "aaaa" }
83559
+ },
83560
+ pt: {
83561
+ placeholders: { day: "dd", month: "mm", year: "aaaa" }
83562
+ },
83563
+ "is-IS": {
83564
+ placeholders: { day: "dd", month: "mm", year: "\xE1\xE1\xE1\xE1" }
83565
+ },
83566
+ "de-DE": {
83567
+ placeholders: { day: "tt", month: "MM", year: "jjjj" }
83371
83568
  }
83372
- `;
83373
- var ClientSideQuickFilters = ({ overlayMatchesTriggerWidth }) => {
83374
- const { tableRef, filterState, getColumnDefinition } = useInternalTableContext();
83375
- const hasNoContent = useTableHasNoContent();
83376
- const { quickFilters, tokens } = React76__default.default.useMemo(() => {
83377
- return filterState.allAvailableFilters.reduce(
83378
- (acc, filter) => {
83379
- const colDef = getColumnDefinition(filter.field);
83380
- if (!colDef) {
83381
- return acc;
83382
- }
83383
- if (colDef == null ? void 0 : colDef.quickFilterRenderer) {
83384
- return { ...acc, quickFilters: [...acc.quickFilters, filter] };
83385
- } else if (filter.instance.isFilterActive()) {
83386
- return { ...acc, tokens: [...acc.tokens, filter] };
83387
- }
83388
- return acc;
83389
- },
83569
+ };
83570
+ var DateQuickFilterLabel = React76__default.default.forwardRef(({ headerName, onClear, value, disabled }, ref) => {
83571
+ var _a;
83572
+ const dateTime = coreReact.useDateTime();
83573
+ const i18n = coreReact.useI18nContext();
83574
+ const placeholders = ((_a = dateInputLocales[i18n.locale]) == null ? void 0 : _a.placeholders) || {
83575
+ day: "dd",
83576
+ month: "mm",
83577
+ year: "yyyy"
83578
+ };
83579
+ if (value !== void 0 && dateFns.isDate(value)) {
83580
+ return /* @__PURE__ */ React76__default.default.createElement(
83581
+ QuickFilterLabel,
83390
83582
  {
83391
- quickFilters: [],
83392
- tokens: []
83583
+ enabled: true,
83584
+ disabled,
83585
+ label: `${headerName}: ${dateTime.format(value, "numeric-date")}`,
83586
+ onClear,
83587
+ ref
83393
83588
  }
83394
83589
  );
83395
- }, [filterState.allAvailableFilters, getColumnDefinition]);
83396
- const isEmpty2 = quickFilters.length === 0 && tokens.length === 0;
83397
- return isEmpty2 ? null : /* @__PURE__ */ React76__default.default.createElement(
83398
- coreReact.FlexList,
83590
+ }
83591
+ return /* @__PURE__ */ React76__default.default.createElement(
83592
+ QuickFilterLabel,
83399
83593
  {
83400
- padding: "xs none",
83401
- size: "none",
83402
- alignItems: "center",
83403
- wrap: "wrap",
83404
- gap: "sm"
83405
- },
83406
- quickFilters.map((filter) => {
83407
- const colDef = getColumnDefinition(filter.field);
83408
- const QuickFilter = colDef == null ? void 0 : colDef.quickFilterRenderer;
83409
- if (!colDef || !QuickFilter) {
83410
- return null;
83411
- }
83412
- return /* @__PURE__ */ React76__default.default.createElement(
83413
- EmptyResultsControlTooltip,
83414
- {
83415
- featureI18nKey: "featureQuickFilter",
83416
- enabled: hasNoContent
83417
- },
83418
- /* @__PURE__ */ React76__default.default.createElement(
83419
- QuickFilter,
83420
- {
83421
- key: filter.field,
83422
- filter,
83423
- columnDefinition: colDef,
83424
- disabled: hasNoContent,
83425
- onChange: (value) => {
83426
- var _a;
83427
- return (_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.applyListFilter(filter.field, value);
83428
- },
83429
- onRemove: () => {
83430
- var _a;
83431
- return (_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.removeFilter(filter.field);
83432
- },
83433
- overlayMatchesTriggerWidth
83434
- }
83435
- )
83436
- );
83437
- }),
83438
- tokens.map((filter) => {
83439
- const colDef = getColumnDefinition(filter.field);
83440
- if (!colDef) {
83441
- return null;
83442
- }
83443
- return /* @__PURE__ */ React76__default.default.createElement(StyledFilterTokenWrapper, { key: filter.field }, /* @__PURE__ */ React76__default.default.createElement(coreReact.UNSAFE_FilterToken, null, /* @__PURE__ */ React76__default.default.createElement(coreReact.UNSAFE_FilterToken.Label, null, getFilterTokenText(colDef, filter.filterValues)), /* @__PURE__ */ React76__default.default.createElement(
83444
- coreReact.UNSAFE_FilterToken.Remove,
83445
- {
83446
- onClick: () => {
83447
- var _a;
83448
- return (_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.removeFilter(filter.field);
83449
- }
83450
- }
83451
- )));
83452
- })
83594
+ enabled: false,
83595
+ disabled,
83596
+ label: `${headerName}: ${globalizationToolkit.getDatePlaceholder(i18n.locale, placeholders)}`,
83597
+ ref
83598
+ }
83453
83599
  );
83454
- };
83455
- var ServerSideQuickFilters = ({ overlayMatchesTriggerWidth }) => {
83456
- const {
83457
- filterStorage: {
83458
- hasDefinedFilters,
83459
- onClearFilter,
83460
- possibleFilters,
83461
- selectedFilters,
83462
- getListFilter
83463
- },
83464
- getColumnDefinition
83465
- } = useInternalTableContext();
83466
- const hasNoContent = useTableHasNoContent();
83467
- const { quickFilterNames, tokenNames } = React76__default.default.useMemo(() => {
83468
- const appliedFilterNames = Object.keys(selectedFilters);
83469
- const isActiveFilter = (filterName) => appliedFilterNames.includes(filterName);
83470
- return possibleFilters.reduce(
83471
- (acc, filterName) => {
83472
- const colDef = getColumnDefinition(filterName);
83473
- if (!colDef) {
83474
- return acc;
83475
- }
83476
- if (colDef == null ? void 0 : colDef.quickFilterRenderer) {
83477
- return {
83478
- ...acc,
83479
- quickFilterNames: [...acc.quickFilterNames, filterName]
83480
- };
83481
- } else if (isActiveFilter(filterName)) {
83482
- return { ...acc, tokenNames: [...acc.tokenNames, filterName] };
83483
- }
83484
- return acc;
83485
- },
83486
- {
83487
- quickFilterNames: [],
83488
- tokenNames: []
83489
- }
83490
- );
83491
- }, [possibleFilters, selectedFilters, getColumnDefinition]);
83492
- if (!hasDefinedFilters) {
83493
- return null;
83494
- }
83495
- const isEmpty2 = quickFilterNames.length === 0 && tokenNames.length === 0;
83496
- return isEmpty2 ? null : /* @__PURE__ */ React76__default.default.createElement(
83497
- coreReact.FlexList,
83498
- {
83499
- padding: "xs none",
83500
- size: "none",
83501
- alignItems: "center",
83502
- wrap: "wrap",
83503
- gap: "sm",
83504
- "data-qa": "data-table-quick-filters"
83505
- },
83506
- quickFilterNames.map((fieldName) => {
83507
- const colDef = getColumnDefinition(fieldName);
83508
- const QuickFilter = colDef == null ? void 0 : colDef.quickFilterRenderer;
83509
- if (!colDef || !QuickFilter) {
83510
- return null;
83511
- }
83512
- return /* @__PURE__ */ React76__default.default.createElement(
83513
- EmptyResultsControlTooltip,
83514
- {
83515
- featureI18nKey: "featureQuickFilter",
83516
- enabled: hasNoContent
83517
- },
83518
- /* @__PURE__ */ React76__default.default.createElement(
83519
- QuickFilter,
83520
- {
83521
- key: fieldName,
83522
- columnDefinition: colDef,
83523
- disabled: hasNoContent,
83524
- overlayMatchesTriggerWidth
83525
- }
83526
- )
83527
- );
83528
- }),
83529
- tokenNames.map((fieldName) => {
83530
- const colDef = getColumnDefinition(fieldName);
83531
- if (!colDef) {
83532
- return null;
83533
- }
83534
- const filter = getListFilter(fieldName);
83535
- return /* @__PURE__ */ React76__default.default.createElement(StyledFilterTokenWrapper, { key: fieldName }, /* @__PURE__ */ React76__default.default.createElement(coreReact.UNSAFE_FilterToken, null, /* @__PURE__ */ React76__default.default.createElement(coreReact.UNSAFE_FilterToken.Label, null, getFilterTokenText(
83536
- colDef,
83537
- colDef.filterRenderer === DateFilterRenderer_default ? filter.value : filter.selected
83538
- )), /* @__PURE__ */ React76__default.default.createElement(
83539
- coreReact.UNSAFE_FilterToken.Remove,
83540
- {
83541
- "data-qa": "data-table-quick-filter-remove-token",
83542
- onClick: () => onClearFilter(fieldName)
83543
- }
83544
- )));
83545
- })
83546
- );
83547
- };
83548
- var QuickFilters = ({ overlayMatchesTriggerWidth }) => {
83549
- const { onServerSideDataRequest } = useInternalTableContext();
83550
- if (onServerSideDataRequest) {
83551
- return /* @__PURE__ */ React76__default.default.createElement(
83552
- ServerSideQuickFilters,
83553
- {
83554
- overlayMatchesTriggerWidth
83555
- }
83556
- );
83557
- }
83558
- return /* @__PURE__ */ React76__default.default.createElement(
83559
- ClientSideQuickFilters,
83560
- {
83561
- overlayMatchesTriggerWidth
83562
- }
83563
- );
83564
- };
83565
- var FiltersPanelButton = () => {
83566
- const { onServerSideDataRequest } = useInternalTableContext();
83567
- if (onServerSideDataRequest) {
83568
- return /* @__PURE__ */ React76__default.default.createElement(ServerSideFiltersPanelToggleButton, null);
83569
- }
83570
- return /* @__PURE__ */ React76__default.default.createElement(ClientSideFiltersPanelToggleButton, null);
83571
- };
83572
- var RowGroupSelector = ({ localeText }) => {
83573
- const {
83574
- columnDefinitions: _columnDefinitions,
83575
- columnApi,
83576
- gridApi,
83577
- tableRef
83578
- } = useInternalTableContext();
83579
- const hasNoContent = useTableHasNoContent();
83580
- const [columnDefinitions, setColumnDefinitions] = React76__default.default.useState(_columnDefinitions);
83581
- const groupableColumns = React76__default.default.useMemo(
83582
- () => mapColumnsToOptions(
83583
- columnDefinitions.filter((column2) => column2.enableRowGroup)
83584
- ),
83585
- [columnDefinitions]
83586
- );
83587
- const groupedColumns = React76__default.default.useMemo(() => {
83588
- const rowGrouping = (columnApi == null ? void 0 : columnApi.getRowGroupColumns()) ?? [];
83589
- return rowGrouping.map((column2) => {
83590
- const colDef = column2.getColDef();
83591
- return transformToColumnDefinition(colDef);
83592
- });
83593
- }, [columnDefinitions]);
83594
- const selectedColumns = React76__default.default.useMemo(
83595
- () => mapColumnsToOptions(groupedColumns),
83596
- [groupedColumns]
83597
- );
83598
- const onGroupedClear = React76__default.default.useCallback(() => {
83599
- var _a;
83600
- (_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.setRowGrouping([]);
83601
- }, [tableRef]);
83602
- const onGroupedRowChange = React76__default.default.useCallback(
83603
- (newValue) => {
83604
- var _a;
83605
- const fields = newValue.map((val) => {
83606
- return val.id;
83607
- });
83608
- if (!ramda.equals(selectedColumns, newValue)) {
83609
- (_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.setRowGrouping(fields);
83610
- }
83611
- },
83612
- [selectedColumns]
83613
- );
83614
- React76__default.default.useEffect(() => {
83615
- function onDisplayedColumnsChanged(event) {
83616
- const agColumnDefs = event.api.getColumnDefs();
83617
- if (agColumnDefs == null ? void 0 : agColumnDefs.length) {
83618
- const flattenedAgColDefs = flattenColDefs(event.api.getColumnDefs());
83619
- const dataTableColumnDefinitions = flattenedAgColDefs.map(
83620
- transformToColumnDefinition
83621
- );
83622
- setColumnDefinitions(dataTableColumnDefinitions);
83623
- }
83624
- }
83625
- gridApi == null ? void 0 : gridApi.addEventListener(
83626
- "displayedColumnsChanged",
83627
- onDisplayedColumnsChanged
83628
- );
83629
- return () => {
83630
- removeEventListenerFromGrid(
83631
- "displayedColumnsChanged",
83632
- onDisplayedColumnsChanged,
83633
- gridApi
83634
- );
83635
- };
83636
- }, [gridApi]);
83637
- if (groupableColumns.length === 0) {
83638
- return null;
83639
- }
83640
- return /* @__PURE__ */ React76__default.default.createElement(
83641
- EmptyResultsControlTooltip,
83642
- {
83643
- featureI18nKey: "featureGroupBy",
83644
- enabled: hasNoContent
83645
- },
83646
- /* @__PURE__ */ React76__default.default.createElement(
83647
- labsGroupBySelect.GroupBySelect,
83648
- {
83649
- isDisabled: hasNoContent,
83650
- localeText,
83651
- onBlur: onGroupedRowChange,
83652
- onClear: onGroupedClear,
83653
- options: groupableColumns,
83654
- selected: selectedColumns
83655
- }
83656
- )
83657
- );
83658
- };
83659
- function mapColumnsToOptions(columnDefinitions) {
83660
- return columnDefinitions.map((col) => {
83661
- return {
83662
- label: col.headerName,
83663
- id: col.field,
83664
- key: col.field,
83665
- group: col.columnGroupName
83666
- };
83667
- });
83668
- }
83669
- var cx21 = classnames__default.default.bind(quickControlsStyles_default);
83670
- var ClientSideSearch = ({
83671
- onSearch,
83672
- placeholder
83673
- }) => {
83674
- var _a;
83675
- const [internalValue, setInternalValue] = React76__default.default.useState("");
83676
- const { tableRef } = useInternalTableContext();
83677
- const hasNoContent = useTableHasNoContent();
83678
- const I18n = coreReact.useI18nContext();
83679
- const debouncedSetSearchValue = React76__default.default.useCallback(
83680
- debounce5__default.default((value) => {
83681
- var _a2;
83682
- (_a2 = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a2.setSearchValue(value);
83683
- }, 250),
83684
- [(_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.setSearchValue]
83685
- );
83686
- const onChange = React76__default.default.useCallback(
83687
- (value, event) => {
83688
- setInternalValue(value);
83689
- if (onSearch) {
83690
- onSearch(event);
83691
- } else {
83692
- debouncedSetSearchValue(value);
83693
- }
83694
- },
83695
- [debouncedSetSearchValue, onSearch]
83696
- );
83697
- return /* @__PURE__ */ React76__default.default.createElement(EmptyResultsControlTooltip, { hasSearch: true, enabled: hasNoContent }, /* @__PURE__ */ React76__default.default.createElement(
83698
- coreReact.Typeahead,
83699
- {
83700
- disabled: hasNoContent,
83701
- "data-qa": "data-table-search",
83702
- value: internalValue,
83703
- className: cx21("search", {
83704
- "search--empty": !internalValue.length
83705
- }),
83706
- onChange,
83707
- placeholder: placeholder || I18n.t("dataTable.search")
83708
- }
83709
- ));
83710
- };
83711
- var Search = (props) => {
83712
- const { onServerSideDataRequest } = useInternalTableContext();
83713
- if (onServerSideDataRequest) {
83714
- return /* @__PURE__ */ React76__default.default.createElement(ServerSideSearch, { ...props });
83715
- }
83716
- return /* @__PURE__ */ React76__default.default.createElement(ClientSideSearch, { ...props });
83717
- };
83718
-
83719
- // src/QuickControls/QuickControls.tsx
83720
- var QuickControls = (props) => {
83721
- const I18n = coreReact.useI18nContext();
83722
- if (props.children) {
83723
- return /* @__PURE__ */ React76__default.default.createElement(
83724
- coreReact.Box,
83725
- {
83726
- "data-qa": "data-table-quick-controls",
83727
- padding: "xs none",
83728
- style: props.style
83729
- },
83730
- props.children
83731
- );
83732
- }
83733
- return /* @__PURE__ */ React76__default.default.createElement(coreReact.Box, { padding: "xs none", style: props.style }, /* @__PURE__ */ React76__default.default.createElement(coreReact.Box, { padding: "xs none", display: "flex-row", justifyContent: "space-between" }, /* @__PURE__ */ React76__default.default.createElement(coreReact.FlexList, { size: "xs", alignItems: "center", marginRight: "sm" }, /* @__PURE__ */ React76__default.default.createElement(
83734
- Search,
83735
- {
83736
- onSearch: props.onSearch,
83737
- placeholder: props.placeholder,
83738
- disabled: props.disabledSearch
83739
- }
83740
- ), /* @__PURE__ */ React76__default.default.createElement(FiltersPanelButton, null)), /* @__PURE__ */ React76__default.default.createElement(coreReact.FlexList, { size: "xs", alignItems: "center" }, /* @__PURE__ */ React76__default.default.createElement(
83741
- RowGroupSelector,
83742
- {
83743
- localeText: {
83744
- reset: I18n.t("dataTable.tableSettings.reset"),
83745
- placeholder: I18n.t("dataTable.tableSettings.selectColumnGroup"),
83746
- selectedItemsPrefix: I18n.t("dataTable.tableSettings.groupBy")
83747
- }
83748
- }
83749
- ), /* @__PURE__ */ React76__default.default.createElement(ConfigPanelButton, null))), /* @__PURE__ */ React76__default.default.createElement(
83750
- QuickFilters,
83751
- {
83752
- overlayMatchesTriggerWidth: props.filterOverlayMatchesTriggerWidth
83753
- }
83754
- ));
83755
- };
83756
-
83757
- // src/utils/addSubcomponents.ts
83758
- var addSubcomponents = (subs, parent) => {
83759
- const assigned = parent;
83760
- Object.keys(subs).forEach((key) => {
83761
- assigned[key] = subs[key];
83762
- });
83763
- return assigned;
83764
- };
83765
-
83766
- // src/ClientSideDataTable.tsx
83767
- var ClientSideDataTable = ({
83768
- analytics,
83769
- children,
83770
- columnDefinitions: _columnDefinitions,
83771
- customBulkEditorFields,
83772
- enableDynamicRowHeight,
83773
- enableGroupEditAndValidation,
83774
- filterGroups,
83775
- getRowId,
83776
- initialTableConfig: _initialTableConfig,
83777
- onBulkEditUpdate,
83778
- onTableConfigChange,
83779
- translations: translations2 = {},
83780
- enableCellTextSelection,
83781
- localStoragePersistenceKey
83782
- }) => {
83783
- return /* @__PURE__ */ React76__default.default.createElement(
83784
- DataTable,
83785
- {
83786
- analytics,
83787
- columnDefinitions: _columnDefinitions,
83788
- enableGroupEditAndValidation,
83789
- enableDynamicRowHeight,
83790
- filterGroups,
83791
- getRowId,
83792
- initialTableConfig: _initialTableConfig,
83793
- onTableConfigChange,
83794
- onBulkEditUpdate,
83795
- showExpandCollapseAllToggle: true,
83796
- translations: translations2,
83797
- localStoragePersistenceKey,
83798
- customBulkEditorFields,
83799
- enableCellTextSelection
83800
- },
83801
- children
83802
- );
83803
- };
83804
- var Table2 = (props) => {
83805
- const internalTableContext = useInternalTableContext();
83806
- React76__default.default.useEffect(() => {
83807
- var _a;
83808
- internalTableContext.setTotalRowCount(((_a = props.rows) == null ? void 0 : _a.length) ?? 0);
83809
- }, [props.rows]);
83810
- return /* @__PURE__ */ React76__default.default.createElement(Table, { ...props, modules: [ClientSideRowModelModule] });
83811
- };
83812
- BulkActions.displayName = "ClientSideDataTable.BulkActions";
83813
- ConfigPanelButton.displayName = "ClientSideDataTable.ConfigPanelButton";
83814
- ContextPanel.displayName = "ClientSideDataTable.ContextPanel";
83815
- QuickControls.displayName = "ClientSideDataTable.QuickControls";
83816
- QuickFilters.displayName = "ClientSideDataTable.QuickFilters";
83817
- RowGroupSelector.displayName = "ClientSideDataTable.RowGroupSelector";
83818
- Search.displayName = "ClientSideDataTable.Search";
83819
- Table2.displayName = "ClientSideDataTable.Table";
83820
- FiltersPanel.displayName = "ClientSideDataTable.FiltersPanel";
83821
- var ClientSideDataTable_default = addSubcomponents(
83822
- {
83823
- BulkActions,
83824
- BulkEditActionButton,
83825
- ConfigPanelButton,
83826
- ContextPanel,
83827
- QuickControls,
83828
- QuickFilters,
83829
- RowGroupSelector,
83830
- Search,
83831
- Table: Table2,
83832
- FiltersPanel,
83833
- FiltersPanelButton
83834
- },
83835
- ClientSideDataTable
83836
- );
83837
- var QuickFilterLabel = React76__default.default.forwardRef(({ enabled, ...props }, ref) => {
83838
- return /* @__PURE__ */ React76__default.default.createElement(StyledQuickFilterLabel, { $enabled: enabled }, /* @__PURE__ */ React76__default.default.createElement(coreReact.SelectButton, { ref, ...props }));
83839
- });
83840
- var StyledQuickFilterLabel = styled4__default.default.div`
83841
- ${coreReact.StyledSelectButton} {
83842
- width: auto;
83843
- max-width: 380px;
83844
- ${({ $enabled }) => $enabled && styled4.css`
83845
- background: ${coreReact.colors.blue96};
83846
- border-color: ${coreReact.colors.blue96};
83847
- font-weight: ${coreReact.typographyWeights.semibold};
83848
- &:hover {
83849
- background: ${coreReact.colors.blue90};
83850
- border-color: ${coreReact.colors.blue90};
83851
- }
83852
- ${coreReact.StyledSelectButtonLabel} {
83853
- color: ${coreReact.colors.blue45};
83854
- }
83855
- ${coreReact.StyledButton} {
83856
- color: ${coreReact.colors.blue45};
83857
- &:hover {
83858
- background: white;
83859
- }
83860
- }
83861
- ${coreReact.StyledSelectArrow} {
83862
- svg {
83863
- fill: ${coreReact.colors.blue45};
83864
- }
83865
- }
83866
- `}
83867
- }
83868
- `;
83869
-
83870
- // src/QuickFilterRenderers/DateQuickFilterRenderer.tsx
83871
- function getPlacement2(currentSelectionType, position) {
83872
- if (currentSelectionType === "single") {
83873
- return "bottom-left";
83874
- }
83875
- if (position === "start") {
83876
- return "bottom-left";
83877
- }
83878
- return "bottom-right";
83879
- }
83880
- var OptionalDateTimeProvider2 = ({ timeZone, children }) => {
83881
- return timeZone ? /* @__PURE__ */ React76__default.default.createElement(coreReact.DateTimeProvider, { timeZone }, children) : /* @__PURE__ */ React76__default.default.createElement(React76__default.default.Fragment, null, children);
83882
- };
83883
- var DateFilterSelect2 = React76__default.default.forwardRef(
83884
- ({
83885
- afterHide,
83886
- selectionType = "either",
83887
- headerName,
83888
- disabled,
83889
- onChange,
83890
- position,
83891
- selectedValue,
83892
- setSelectionType = () => {
83893
- }
83894
- }, ref) => {
83895
- const dateTime = coreReact.useDateTime();
83896
- const { start, end } = selectedValue;
83897
- const selectedDate = (position === "start" ? start : end) ?? void 0;
83898
- const [displayed, setDisplayed2] = React76__default.default.useState(
83899
- // @ts-ignore
83900
- selectedDate || dateTime.newDate()
83901
- );
83902
- React76__default.default.useEffect(() => {
83903
- if (dateFns.isDate(start) && !dateFns.isDate(end) && position === "end") {
83904
- setDisplayed2(start);
83905
- }
83906
- if (!dateFns.isDate(start) && dateFns.isDate(end) && position === "start") {
83907
- setDisplayed2(end);
83908
- }
83909
- }, [position, selectedValue]);
83910
- function onClear() {
83911
- onChange(null, position);
83912
- }
83913
- const clearRef = React76__default.default.useRef(null);
83914
- const monthRef = React76__default.default.useRef(null);
83915
- const yearRef = React76__default.default.useRef(null);
83916
- const overlay = /* @__PURE__ */ React76__default.default.createElement(
83917
- DateFilterOverlay,
83918
- {
83919
- displayDate: displayed,
83920
- selectionType,
83921
- monthRef,
83922
- onSelect: (date) => {
83923
- onChange(date, position);
83924
- },
83925
- position,
83926
- selectedValue,
83927
- setDisplayDate: setDisplayed2,
83928
- setSelectionType,
83929
- yearRef
83930
- }
83931
- );
83932
- return /* @__PURE__ */ React76__default.default.createElement(
83933
- coreReact.OverlayTrigger,
83934
- {
83935
- afterHide,
83936
- autoFocus: true,
83937
- beforeShow: (e) => {
83938
- if (coreReact.isEventSource(clearRef, e)) {
83939
- return false;
83940
- }
83941
- return true;
83942
- },
83943
- clickOutsideIgnoreRefs: [monthRef, yearRef],
83944
- overlay,
83945
- placement: getPlacement2(selectionType, position),
83946
- ref,
83947
- restoreFocusOnHide: true,
83948
- role: "dialog"
83949
- },
83950
- /* @__PURE__ */ React76__default.default.createElement(
83951
- DateQuickFilterLabel,
83952
- {
83953
- headerName,
83954
- onClear,
83955
- value: selectedDate,
83956
- disabled
83957
- }
83958
- )
83959
- );
83960
- }
83961
- );
83962
- function DateFilter3({
83963
- // TODO: talk to design about potential loading UX for this.
83964
- // core DateSelect doesn't have it
83965
- // loading,
83966
- headerName,
83967
- onChange,
83968
- selectionType = "either",
83969
- value,
83970
- disabled,
83971
- ...props
83972
- }) {
83973
- const [selectedValue, setSelectedValue] = React76__default.default.useState({
83974
- type: selectionType === "either" ? "range" : selectionType
83975
- });
83976
- React76__default.default.useEffect(() => {
83977
- const parsedValue = value.map((date) => {
83978
- if (dateFns.isDate(date)) {
83979
- return date;
83980
- }
83981
- return dateFns.parseISO(String(date));
83982
- });
83983
- const type = dateFns.isSameDay(parsedValue[0], parsedValue[1]) ? "single" : "range";
83984
- setSelectedValue({ type, start: parsedValue[0], end: parsedValue[1] });
83985
- }, [value]);
83986
- const dateRangeEndDateRef = React76__default.default.useRef(null);
83987
- function dateFilterOnChange(date, position) {
83988
- const newValue = getValueFromSelection(selectedValue, date, position);
83989
- setSelectedValue(newValue);
83990
- if (isValidDateSelection(newValue)) {
83991
- onChange(
83992
- newValue.start || newValue.end ? [
83993
- newValue.start,
83994
- newValue.type === "single" ? newValue.start : newValue.end
83995
- ] : []
83996
- );
83997
- }
83998
- }
83999
- const onSelectionTypeChange = React76__default.default.useCallback(
84000
- (newSelectionType) => {
84001
- setSelectedValue({ type: newSelectionType });
84002
- },
84003
- [setSelectedValue]
84004
- );
84005
- function dateRangeAfterHide() {
84006
- var _a;
84007
- if (selectedValue.type === "range" && dateFns.isDate(selectedValue.start) && !dateFns.isDate(selectedValue.end)) {
84008
- (_a = dateRangeEndDateRef.current) == null ? void 0 : _a.click();
84009
- }
84010
- return true;
84011
- }
84012
- return /* @__PURE__ */ React76__default.default.createElement(coreReact.FlexList, { space: "xs", "data-qa": props["data-qa"] }, /* @__PURE__ */ React76__default.default.createElement(
84013
- DateFilterSelect2,
84014
- {
84015
- afterHide: dateRangeAfterHide,
84016
- headerName,
84017
- onChange: dateFilterOnChange,
84018
- position: "start",
84019
- selectedValue,
84020
- selectionType,
84021
- setSelectionType: onSelectionTypeChange,
84022
- disabled
84023
- }
84024
- ), selectedValue.type === "range" && /* @__PURE__ */ React76__default.default.createElement(
84025
- DateFilterSelect2,
84026
- {
84027
- headerName,
84028
- onChange: dateFilterOnChange,
84029
- position: "end",
84030
- ref: dateRangeEndDateRef,
84031
- selectedValue,
84032
- selectionType,
84033
- setSelectionType: onSelectionTypeChange,
84034
- disabled
84035
- }
84036
- ));
84037
- }
84038
- function ServerSideQuickDateFilterRenderer({
84039
- columnDefinition,
84040
- disabled
84041
- }) {
84042
- var _a;
84043
- const { onChange, value = [] } = useServerSideFilter({
84044
- columnDefinition
84045
- });
84046
- const colDef = columnDefinition;
84047
- return /* @__PURE__ */ React76__default.default.createElement(OptionalDateTimeProvider2, { timeZone: colDef.timeZone }, /* @__PURE__ */ React76__default.default.createElement(
84048
- DateFilter3,
84049
- {
84050
- selectionType: ((_a = colDef.filterProps) == null ? void 0 : _a.selectionType) ?? "either",
84051
- headerName: colDef.headerName,
84052
- disabled,
84053
- onChange: (selected) => {
84054
- onChange(
84055
- selected.map((date) => {
84056
- return date ? {
84057
- // future extensions can go here (month, day, year keys etc)
84058
- date
84059
- } : (
84060
- // TODO: refactor out date-specific getId stuff from useServerSideFilterStorage
84061
- date
84062
- );
84063
- })
84064
- );
84065
- },
84066
- value: value.map((option) => option ? option.date : option)
84067
- }
84068
- ));
84069
- }
84070
- var QuickDateFilterRenderer = (props) => {
84071
- const { onServerSideDataRequest } = useInternalTableContext();
84072
- if (onServerSideDataRequest) {
84073
- return /* @__PURE__ */ React76__default.default.createElement(ServerSideQuickDateFilterRenderer, { ...props });
84074
- }
84075
- logger.error(
84076
- "Warning: Date Filters are currently only implemented for the serverside row model"
84077
- );
84078
- return null;
84079
- };
84080
- var dateInputLocales = {
84081
- "fr-CA": {
84082
- placeholders: { day: "jj", month: "mm", year: "aaaa" }
84083
- },
84084
- "fr-FR": {
84085
- placeholders: { day: "jj", month: "mm", year: "aaaa" }
84086
- },
84087
- es: {
84088
- placeholders: { day: "dd", month: "mm", year: "aaaa" }
84089
- },
84090
- "es-ES": {
84091
- placeholders: { day: "dd", month: "mm", year: "aaaa" }
84092
- },
84093
- pt: {
84094
- placeholders: { day: "dd", month: "mm", year: "aaaa" }
84095
- },
84096
- "is-IS": {
84097
- placeholders: { day: "dd", month: "mm", year: "\xE1\xE1\xE1\xE1" }
84098
- },
84099
- "de-DE": {
84100
- placeholders: { day: "tt", month: "MM", year: "jjjj" }
84101
- }
84102
- };
84103
- var DateQuickFilterLabel = React76__default.default.forwardRef(({ headerName, onClear, value, disabled }, ref) => {
84104
- var _a;
84105
- const dateTime = coreReact.useDateTime();
84106
- const i18n = coreReact.useI18nContext();
84107
- const placeholders = ((_a = dateInputLocales[i18n.locale]) == null ? void 0 : _a.placeholders) || {
84108
- day: "dd",
84109
- month: "mm",
84110
- year: "yyyy"
84111
- };
84112
- if (value !== void 0 && dateFns.isDate(value)) {
84113
- return /* @__PURE__ */ React76__default.default.createElement(
84114
- QuickFilterLabel,
84115
- {
84116
- enabled: true,
84117
- disabled,
84118
- label: `${headerName}: ${dateTime.format(value, "numeric-date")}`,
84119
- onClear,
84120
- ref
84121
- }
84122
- );
84123
- }
84124
- return /* @__PURE__ */ React76__default.default.createElement(
84125
- QuickFilterLabel,
84126
- {
84127
- enabled: false,
84128
- disabled,
84129
- label: `${headerName}: ${globalizationToolkit.getDatePlaceholder(i18n.locale, placeholders)}`,
84130
- ref
84131
- }
84132
- );
84133
- });
84134
- var DateQuickFilterRenderer_default = QuickDateFilterRenderer;
84135
- var defaultGetId2 = (option) => option == null ? void 0 : option.id;
84136
- var defaultGetLabel2 = (option) => {
84137
- return (option == null ? void 0 : option.label) ?? (option == null ? void 0 : option.name) ?? option;
83600
+ });
83601
+ var DateQuickFilterRenderer_default = QuickDateFilterRenderer;
83602
+ var defaultGetId2 = (option) => option == null ? void 0 : option.id;
83603
+ var defaultGetLabel2 = (option) => {
83604
+ return (option == null ? void 0 : option.label) ?? (option == null ? void 0 : option.name) ?? option;
84138
83605
  };
84139
83606
  var useSuperSelectOptionAsValueWorkaround = ({
84140
83607
  originValue,
@@ -84467,7 +83934,7 @@ var LocationQuickFilterRenderer = ({
84467
83934
  );
84468
83935
  };
84469
83936
  var LocationQuickFilterRenderer_default = LocationQuickFilterRenderer;
84470
- var StyledFilterPresetPopoverContent = styled4__default.default(coreReact.Popover.Content)`
83937
+ var StyledFilterPresetPopoverContent = styled3__default.default(coreReact.Popover.Content)`
84471
83938
  padding: ${coreReact.spacing.sm}px ${coreReact.spacing.lg}px;
84472
83939
  `;
84473
83940
  var getValueLabel = (isValueEmpty, value, placeholder, filterName) => {
@@ -84551,12 +84018,12 @@ var getSuperSelectFilterPreset = (columnDefinition) => {
84551
84018
  selectionStyle: "highlight"
84552
84019
  };
84553
84020
  };
84554
- var StyledSuperSelectWrapper = styled4__default.default.div`
84021
+ var StyledSuperSelectWrapper = styled3__default.default.div`
84555
84022
  ${coreReact.UNSAFE_StyledSuperSelectTrigger} {
84556
84023
  width: auto;
84557
84024
  }
84558
84025
 
84559
- ${({ $enabled }) => $enabled && styled4.css`
84026
+ ${({ $enabled }) => $enabled && styled3.css`
84560
84027
  ${coreReact.UNSAFE_StyledSuperSelectTrigger} {
84561
84028
  max-width: 360px;
84562
84029
  background: ${coreReact.colors.blue96};
@@ -84626,236 +84093,875 @@ var ClientSideMultiSelectQuickFilter = ({
84626
84093
  onRemove == null ? void 0 : onRemove();
84627
84094
  return;
84628
84095
  }
84629
- onChange == null ? void 0 : onChange(values2);
84630
- },
84631
- ...getSuperSelectFilterPreset(columnDefinition)
84632
- }
84633
- ));
84096
+ onChange == null ? void 0 : onChange(values2);
84097
+ },
84098
+ ...getSuperSelectFilterPreset(columnDefinition)
84099
+ }
84100
+ ));
84101
+ };
84102
+ var useSuperSelectOptionAsValueWorkaround2 = ({
84103
+ originValue,
84104
+ originOptions,
84105
+ getId: getId3,
84106
+ loading
84107
+ }) => {
84108
+ const isValueFromOptions = React76__default.default.useRef(false);
84109
+ const getValueFromOptions = () => {
84110
+ const valueIds = originValue.map((option) => getId(getId3, option));
84111
+ isValueFromOptions.current = true;
84112
+ return originOptions.filter(
84113
+ (option) => valueIds.includes(getId(getId3, option))
84114
+ );
84115
+ };
84116
+ const hasOptions = originOptions.length > 0 && !loading;
84117
+ const hasValue = (originValue == null ? void 0 : originValue.length) > 0;
84118
+ const options = !hasOptions && hasValue ? originValue : originOptions;
84119
+ const value = !hasOptions ? originValue : isValueFromOptions.current ? originValue : getValueFromOptions();
84120
+ return {
84121
+ options,
84122
+ value,
84123
+ getOptionValue: (option) => option
84124
+ };
84125
+ };
84126
+ var ServerSideMultiSelectQuickFilter = ({ columnDefinition, overlayMatchesTriggerWidth, disabled }) => {
84127
+ var _a;
84128
+ const {
84129
+ options: originOptions,
84130
+ onClearFilter,
84131
+ fieldName,
84132
+ value: originValue = [],
84133
+ onChange,
84134
+ getOptions,
84135
+ loading
84136
+ } = useServerSideFilter({ columnDefinition });
84137
+ const { options, value, getOptionValue } = useSuperSelectOptionAsValueWorkaround2({
84138
+ originOptions,
84139
+ originValue,
84140
+ loading,
84141
+ getId: (_a = columnDefinition.filterProps) == null ? void 0 : _a.getId
84142
+ });
84143
+ return /* @__PURE__ */ React76__default.default.createElement(StyledSuperSelectWrapper, { $enabled: Boolean(value == null ? void 0 : value.length) }, /* @__PURE__ */ React76__default.default.createElement(
84144
+ coreReact.UNSAFE_SuperSelect,
84145
+ {
84146
+ overlayMatchesTriggerWidth,
84147
+ loading,
84148
+ value: value === null ? [] : value,
84149
+ search: false,
84150
+ getOptionLabel: (option) => {
84151
+ var _a2;
84152
+ return getLabel((_a2 = columnDefinition.filterProps) == null ? void 0 : _a2.getLabel, option);
84153
+ },
84154
+ getOptionValue,
84155
+ multiple: true,
84156
+ options,
84157
+ disabled,
84158
+ onChange: (values2) => {
84159
+ if (Array.isArray(values2) && !values2.length) {
84160
+ onClearFilter == null ? void 0 : onClearFilter(fieldName);
84161
+ getOptions();
84162
+ return;
84163
+ }
84164
+ onChange(values2);
84165
+ },
84166
+ onOpenChange: (open) => {
84167
+ if (open && !originOptions.length) {
84168
+ getOptions();
84169
+ }
84170
+ },
84171
+ ...getSuperSelectFilterPreset(columnDefinition)
84172
+ }
84173
+ ));
84174
+ };
84175
+ var MultiSelectQuickFilterRenderer = (props) => {
84176
+ const { onServerSideDataRequest } = useInternalTableContext();
84177
+ if (!isClientSideFilterProps(props, !!onServerSideDataRequest)) {
84178
+ return /* @__PURE__ */ React76__default.default.createElement(ServerSideMultiSelectQuickFilter, { ...props });
84179
+ }
84180
+ return /* @__PURE__ */ React76__default.default.createElement(ClientSideMultiSelectQuickFilter, { ...props });
84181
+ };
84182
+ var MultiSelectQuickFilterRenderer_default = MultiSelectQuickFilterRenderer;
84183
+ function getFilterTokenText(columnDefinition, filterValue) {
84184
+ var _a, _b, _c, _d;
84185
+ if ((_a = columnDefinition == null ? void 0 : columnDefinition.filterProps) == null ? void 0 : _a.getFilterTokenText) {
84186
+ return (_c = (_b = columnDefinition == null ? void 0 : columnDefinition.filterProps) == null ? void 0 : _b.getFilterTokenText) == null ? void 0 : _c.call(_b, {
84187
+ headerName: (columnDefinition == null ? void 0 : columnDefinition.headerName) || "",
84188
+ value: filterValue
84189
+ });
84190
+ }
84191
+ if (columnDefinition.filterRenderer === DateFilterRenderer_default) {
84192
+ return /* @__PURE__ */ React76__default.default.createElement(
84193
+ OptionalDateTimeProvider,
84194
+ {
84195
+ timeZone: columnDefinition.timeZone
84196
+ },
84197
+ /* @__PURE__ */ React76__default.default.createElement(
84198
+ DateFilterTokenText,
84199
+ {
84200
+ headerName: columnDefinition.headerName,
84201
+ value: filterValue
84202
+ }
84203
+ )
84204
+ );
84205
+ }
84206
+ if (columnDefinition.filterRenderer === NumberFilterRenderer) {
84207
+ return columnDefinition == null ? void 0 : columnDefinition.headerName;
84208
+ }
84209
+ if (Array.isArray(filterValue)) {
84210
+ if (filterValue.length === 0) {
84211
+ return columnDefinition == null ? void 0 : columnDefinition.headerName;
84212
+ }
84213
+ if (filterValue.length === 1) {
84214
+ return `${columnDefinition == null ? void 0 : columnDefinition.headerName}: ${getLabel(
84215
+ (_d = columnDefinition.filterProps) == null ? void 0 : _d.getLabel,
84216
+ filterValue[0]
84217
+ )}`;
84218
+ }
84219
+ return `${columnDefinition == null ? void 0 : columnDefinition.headerName}: (${filterValue.length})`;
84220
+ }
84221
+ return columnDefinition == null ? void 0 : columnDefinition.headerName;
84222
+ }
84223
+ var ensureArray = (input) => {
84224
+ if (input === null) {
84225
+ return [];
84226
+ }
84227
+ return Array.isArray(input) ? input : [input];
84228
+ };
84229
+
84230
+ // src/QuickFilterRenderers/SingleSelectQuickFilterRenderer.tsx
84231
+ var ClientSideSingleSelectQuickFilter = ({
84232
+ filter,
84233
+ columnDefinition,
84234
+ onChange,
84235
+ onRemove,
84236
+ overlayMatchesTriggerWidth,
84237
+ disabled
84238
+ }) => {
84239
+ var _a;
84240
+ return /* @__PURE__ */ React76__default.default.createElement(
84241
+ StyledSuperSelectWrapper,
84242
+ {
84243
+ $enabled: Boolean((_a = filter.filterValues) == null ? void 0 : _a.length),
84244
+ "data-test-id": "client-side-single-select-quick-filter"
84245
+ },
84246
+ /* @__PURE__ */ React76__default.default.createElement(
84247
+ coreReact.UNSAFE_SuperSelect,
84248
+ {
84249
+ overlayMatchesTriggerWidth,
84250
+ value: filter.filterValues ?? [],
84251
+ search: false,
84252
+ multiple: false,
84253
+ options: filter.options,
84254
+ disabled,
84255
+ getOptionValue: (option) => {
84256
+ var _a2;
84257
+ return getId((_a2 = columnDefinition.filterProps) == null ? void 0 : _a2.getId, option);
84258
+ },
84259
+ getOptionLabel: (option) => {
84260
+ var _a2;
84261
+ return getLabel((_a2 = columnDefinition.filterProps) == null ? void 0 : _a2.getLabel, option);
84262
+ },
84263
+ onChange: (values2) => {
84264
+ const valuesArray = ensureArray(values2);
84265
+ if (!valuesArray.length) {
84266
+ onRemove == null ? void 0 : onRemove();
84267
+ return;
84268
+ }
84269
+ onChange == null ? void 0 : onChange(valuesArray);
84270
+ },
84271
+ ...getSuperSelectFilterPreset(columnDefinition)
84272
+ }
84273
+ )
84274
+ );
84275
+ };
84276
+ var useSuperSelectOptionAsValueWorkaround3 = ({
84277
+ originValue,
84278
+ originOptions,
84279
+ getId: getId3,
84280
+ loading
84281
+ }) => {
84282
+ const isValueFromOptions = React76__default.default.useRef(false);
84283
+ const getValueFromOptions = () => {
84284
+ const valueIds = originValue.map((option) => getId(getId3, option));
84285
+ isValueFromOptions.current = true;
84286
+ return originOptions.filter(
84287
+ (option) => valueIds.includes(getId(getId3, option))
84288
+ );
84289
+ };
84290
+ const hasOptions = originOptions.length > 0 && !loading;
84291
+ const hasValue = (originValue == null ? void 0 : originValue.length) > 0;
84292
+ const options = !hasOptions && hasValue ? originValue : originOptions;
84293
+ const value = !hasOptions ? originValue : isValueFromOptions.current ? originValue : getValueFromOptions();
84294
+ return {
84295
+ options,
84296
+ value,
84297
+ getOptionValue: (option) => option
84298
+ };
84299
+ };
84300
+ var ServerSideSingleSelectQuickFilter = ({ columnDefinition, overlayMatchesTriggerWidth, disabled }) => {
84301
+ var _a;
84302
+ const {
84303
+ options: originOptions,
84304
+ onClearFilter,
84305
+ fieldName,
84306
+ value: originValue = [],
84307
+ onChange,
84308
+ getOptions,
84309
+ loading
84310
+ } = useServerSideFilter({ columnDefinition });
84311
+ const { options, value, getOptionValue } = useSuperSelectOptionAsValueWorkaround3({
84312
+ originOptions,
84313
+ originValue,
84314
+ loading,
84315
+ getId: (_a = columnDefinition.filterProps) == null ? void 0 : _a.getId
84316
+ });
84317
+ const hasFetchedOptions = React76__default.default.useRef(false);
84318
+ React76__default.default.useEffect(() => {
84319
+ if (!hasFetchedOptions.current && !originOptions.length) {
84320
+ getOptions();
84321
+ hasFetchedOptions.current = true;
84322
+ }
84323
+ }, [getOptions, originOptions.length]);
84324
+ const handleOnChange = (values2) => {
84325
+ const selectedValues = ensureArray(values2);
84326
+ if (!selectedValues.length) {
84327
+ onClearFilter == null ? void 0 : onClearFilter(fieldName);
84328
+ getOptions();
84329
+ return;
84330
+ }
84331
+ onChange(selectedValues);
84332
+ };
84333
+ const handleOnOpenChange = (open) => {
84334
+ if (open && !originOptions.length) {
84335
+ getOptions();
84336
+ }
84337
+ };
84338
+ return /* @__PURE__ */ React76__default.default.createElement(
84339
+ StyledSuperSelectWrapper,
84340
+ {
84341
+ $enabled: Boolean(value == null ? void 0 : value.length),
84342
+ "data-test-id": "server-side-single-select-quick-filter"
84343
+ },
84344
+ /* @__PURE__ */ React76__default.default.createElement(
84345
+ coreReact.UNSAFE_SuperSelect,
84346
+ {
84347
+ overlayMatchesTriggerWidth,
84348
+ loading,
84349
+ value: value ?? [],
84350
+ search: false,
84351
+ disabled,
84352
+ getOptionLabel: (option) => {
84353
+ var _a2;
84354
+ return getLabel((_a2 = columnDefinition.filterProps) == null ? void 0 : _a2.getLabel, option);
84355
+ },
84356
+ getOptionValue,
84357
+ multiple: false,
84358
+ options,
84359
+ onChange: handleOnChange,
84360
+ onOpenChange: handleOnOpenChange,
84361
+ ...getSuperSelectFilterPreset(columnDefinition)
84362
+ }
84363
+ )
84364
+ );
84365
+ };
84366
+ var SingleSelectQuickFilterRenderer = (props) => {
84367
+ const { onServerSideDataRequest } = useInternalTableContext();
84368
+ if (!isClientSideFilterProps(props, !!onServerSideDataRequest)) {
84369
+ return /* @__PURE__ */ React76__default.default.createElement(ServerSideSingleSelectQuickFilter, { ...props });
84370
+ }
84371
+ return /* @__PURE__ */ React76__default.default.createElement(ClientSideSingleSelectQuickFilter, { ...props });
84372
+ };
84373
+ var SingleSelectQuickFilterRenderer_default = SingleSelectQuickFilterRenderer;
84374
+ var FiltersPanelToggleButton = ({ hasSelectedFilters, hasDefinedFilters }) => {
84375
+ const I18n = coreReact.useI18nContext();
84376
+ const { contextPanel } = useInternalTableContext();
84377
+ const hasNoContent = useTableHasNoContent();
84378
+ if (!hasDefinedFilters) {
84379
+ return null;
84380
+ }
84381
+ return /* @__PURE__ */ React76__default.default.createElement(
84382
+ EmptyResultsControlTooltip,
84383
+ {
84384
+ featureI18nKey: "featureFilter",
84385
+ enabled: hasNoContent
84386
+ },
84387
+ /* @__PURE__ */ React76__default.default.createElement(
84388
+ coreReact.ToggleButton,
84389
+ {
84390
+ "data-qa": "data-table-show-filters-button",
84391
+ disabled: hasNoContent,
84392
+ icon: /* @__PURE__ */ React76__default.default.createElement(FilterIcon, null),
84393
+ onClick: () => {
84394
+ if (contextPanel.content === "filters") {
84395
+ contextPanel.hide();
84396
+ } else {
84397
+ contextPanel.show("filters");
84398
+ }
84399
+ },
84400
+ selected: contextPanel.content === "filters"
84401
+ },
84402
+ hasSelectedFilters ? I18n.t("dataTable.filters.moreFilters") : I18n.t("dataTable.filters.filters")
84403
+ )
84404
+ );
84405
+ };
84406
+ var ServerSideFiltersPanelToggleButton = () => {
84407
+ const {
84408
+ filterStorage: { hasDefinedFilters, hasSelectedFilters }
84409
+ } = useInternalTableContext();
84410
+ return /* @__PURE__ */ React76__default.default.createElement(
84411
+ FiltersPanelToggleButton,
84412
+ {
84413
+ hasDefinedFilters,
84414
+ hasSelectedFilters
84415
+ }
84416
+ );
84417
+ };
84418
+ var ClientSideFiltersPanelToggleButton = () => {
84419
+ const { filterState } = useInternalTableContext();
84420
+ const activeFilters = React76__default.default.useMemo(() => {
84421
+ return filterState.allAvailableFilters.filter(({ instance }) => {
84422
+ return instance.isFilterActive();
84423
+ });
84424
+ }, [filterState.allAvailableFilters]);
84425
+ return /* @__PURE__ */ React76__default.default.createElement(
84426
+ FiltersPanelToggleButton,
84427
+ {
84428
+ hasDefinedFilters: filterState.allAvailableFilters.length > 0,
84429
+ hasSelectedFilters: activeFilters.length > 0
84430
+ }
84431
+ );
84432
+ };
84433
+
84434
+ // src/QuickControls/QuickFilters.tsx
84435
+ var defaultQuickFilterRenderers = {
84436
+ MultiSelectFilterRenderer: MultiSelectQuickFilterRenderer_default,
84437
+ DateFilterRenderer: DateQuickFilterRenderer_default,
84438
+ LocationFilterRenderer: LocationQuickFilterRenderer_default,
84439
+ SingleSelectFilterRenderer: SingleSelectQuickFilterRenderer_default
84440
+ };
84441
+ function getQuickFilterRenderer(colDef) {
84442
+ var _a;
84443
+ if (!colDef)
84444
+ return null;
84445
+ if (colDef.quickFilterRenderer) {
84446
+ return colDef.quickFilterRenderer;
84447
+ }
84448
+ const filterRendererName = (_a = colDef.filterRenderer) == null ? void 0 : _a.displayName;
84449
+ if (filterRendererName) {
84450
+ return defaultQuickFilterRenderers[filterRendererName] || null;
84451
+ }
84452
+ return null;
84453
+ }
84454
+ var FilterIcon = () => {
84455
+ return /* @__PURE__ */ React76__default.default.createElement(
84456
+ "svg",
84457
+ {
84458
+ focusable: false,
84459
+ width: "16",
84460
+ height: "16",
84461
+ viewBox: "0 0 20 20",
84462
+ fill: "none",
84463
+ xmlns: "http://www.w3.org/2000/svg"
84464
+ },
84465
+ /* @__PURE__ */ React76__default.default.createElement(
84466
+ "path",
84467
+ {
84468
+ fillRule: "evenodd",
84469
+ clipRule: "evenodd",
84470
+ d: "M3 5V7H17V5H3ZM8 15H12V13H8V15ZM15 11H5V9H15V11Z",
84471
+ fill: "currentColor"
84472
+ }
84473
+ )
84474
+ );
84475
+ };
84476
+ var StyledFilterTokenWrapper = styled3__default.default.div`
84477
+ ${coreReact.UNSAFE_StyledFilterTokenLabel} {
84478
+ font-weight: ${coreReact.typographyWeights.semibold};
84479
+ }
84480
+ `;
84481
+ var ClientSideQuickFilters = ({ overlayMatchesTriggerWidth }) => {
84482
+ const { tableRef, filterState, getColumnDefinition } = useInternalTableContext();
84483
+ const hasNoContent = useTableHasNoContent();
84484
+ const { quickFilters, tokens } = React76__default.default.useMemo(() => {
84485
+ return filterState.allAvailableFilters.reduce(
84486
+ (acc, filter) => {
84487
+ var _a;
84488
+ const colDef = getColumnDefinition(filter.field);
84489
+ if (!colDef) {
84490
+ return acc;
84491
+ }
84492
+ const isInteractive = ((_a = colDef == null ? void 0 : colDef.filterProps) == null ? void 0 : _a.isInteractiveFilterToken) === true;
84493
+ const hasQuickFilterRenderer = !!(colDef == null ? void 0 : colDef.quickFilterRenderer);
84494
+ const filterIsActive = filter.instance.isFilterActive();
84495
+ if (hasQuickFilterRenderer || filterIsActive && isInteractive && getQuickFilterRenderer(colDef) !== null) {
84496
+ return { ...acc, quickFilters: [...acc.quickFilters, filter] };
84497
+ } else if (filterIsActive) {
84498
+ return { ...acc, tokens: [...acc.tokens, filter] };
84499
+ }
84500
+ return acc;
84501
+ },
84502
+ {
84503
+ quickFilters: [],
84504
+ tokens: []
84505
+ }
84506
+ );
84507
+ }, [filterState.allAvailableFilters, getColumnDefinition]);
84508
+ const isEmpty2 = quickFilters.length === 0 && tokens.length === 0;
84509
+ return isEmpty2 ? null : /* @__PURE__ */ React76__default.default.createElement(
84510
+ coreReact.FlexList,
84511
+ {
84512
+ padding: "xs none",
84513
+ size: "none",
84514
+ alignItems: "center",
84515
+ wrap: "wrap",
84516
+ gap: "sm"
84517
+ },
84518
+ quickFilters.map((filter) => {
84519
+ const colDef = getColumnDefinition(filter.field);
84520
+ const QuickFilter = getQuickFilterRenderer(colDef);
84521
+ if (!colDef || !QuickFilter) {
84522
+ return null;
84523
+ }
84524
+ return /* @__PURE__ */ React76__default.default.createElement(
84525
+ EmptyResultsControlTooltip,
84526
+ {
84527
+ featureI18nKey: "featureQuickFilter",
84528
+ enabled: hasNoContent
84529
+ },
84530
+ /* @__PURE__ */ React76__default.default.createElement(
84531
+ QuickFilter,
84532
+ {
84533
+ key: filter.field,
84534
+ filter,
84535
+ columnDefinition: colDef,
84536
+ disabled: hasNoContent,
84537
+ onChange: (value) => {
84538
+ var _a;
84539
+ return (_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.applyListFilter(filter.field, value);
84540
+ },
84541
+ onRemove: () => {
84542
+ var _a;
84543
+ return (_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.removeFilter(filter.field);
84544
+ },
84545
+ overlayMatchesTriggerWidth
84546
+ }
84547
+ )
84548
+ );
84549
+ }),
84550
+ tokens.map((filter) => {
84551
+ const colDef = getColumnDefinition(filter.field);
84552
+ if (!colDef) {
84553
+ return null;
84554
+ }
84555
+ return /* @__PURE__ */ React76__default.default.createElement(StyledFilterTokenWrapper, { key: filter.field }, /* @__PURE__ */ React76__default.default.createElement(coreReact.UNSAFE_FilterToken, null, /* @__PURE__ */ React76__default.default.createElement(coreReact.UNSAFE_FilterToken.Label, null, getFilterTokenText(colDef, filter.filterValues)), /* @__PURE__ */ React76__default.default.createElement(
84556
+ coreReact.UNSAFE_FilterToken.Remove,
84557
+ {
84558
+ onClick: () => {
84559
+ var _a;
84560
+ return (_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.removeFilter(filter.field);
84561
+ }
84562
+ }
84563
+ )));
84564
+ })
84565
+ );
84566
+ };
84567
+ var ServerSideQuickFilters = ({ overlayMatchesTriggerWidth }) => {
84568
+ const {
84569
+ filterStorage: {
84570
+ hasDefinedFilters,
84571
+ onClearFilter,
84572
+ possibleFilters,
84573
+ selectedFilters,
84574
+ getListFilter
84575
+ },
84576
+ getColumnDefinition
84577
+ } = useInternalTableContext();
84578
+ const hasNoContent = useTableHasNoContent();
84579
+ const { quickFilterNames, tokenNames } = React76__default.default.useMemo(() => {
84580
+ const appliedFilterNames = Object.keys(selectedFilters);
84581
+ const isActiveFilter = (filterName) => appliedFilterNames.includes(filterName);
84582
+ return possibleFilters.reduce(
84583
+ (acc, filterName) => {
84584
+ var _a;
84585
+ const colDef = getColumnDefinition(filterName);
84586
+ if (!colDef) {
84587
+ return acc;
84588
+ }
84589
+ const isInteractive = ((_a = colDef == null ? void 0 : colDef.filterProps) == null ? void 0 : _a.isInteractiveFilterToken) === true;
84590
+ const hasQuickFilterRenderer = !!(colDef == null ? void 0 : colDef.quickFilterRenderer);
84591
+ const filterIsActive = isActiveFilter(filterName);
84592
+ if (hasQuickFilterRenderer || filterIsActive && isInteractive && getQuickFilterRenderer(colDef) !== null) {
84593
+ return {
84594
+ ...acc,
84595
+ quickFilterNames: [...acc.quickFilterNames, filterName]
84596
+ };
84597
+ } else if (filterIsActive) {
84598
+ return {
84599
+ ...acc,
84600
+ tokenNames: [...acc.tokenNames, filterName]
84601
+ };
84602
+ }
84603
+ return acc;
84604
+ },
84605
+ {
84606
+ quickFilterNames: [],
84607
+ tokenNames: []
84608
+ }
84609
+ );
84610
+ }, [possibleFilters, selectedFilters, getColumnDefinition]);
84611
+ if (!hasDefinedFilters) {
84612
+ return null;
84613
+ }
84614
+ const isEmpty2 = quickFilterNames.length === 0 && tokenNames.length === 0;
84615
+ return isEmpty2 ? null : /* @__PURE__ */ React76__default.default.createElement(
84616
+ coreReact.FlexList,
84617
+ {
84618
+ padding: "xs none",
84619
+ size: "none",
84620
+ alignItems: "center",
84621
+ wrap: "wrap",
84622
+ gap: "sm",
84623
+ "data-qa": "data-table-quick-filters"
84624
+ },
84625
+ quickFilterNames.map((fieldName) => {
84626
+ const colDef = getColumnDefinition(fieldName);
84627
+ const QuickFilter = getQuickFilterRenderer(colDef);
84628
+ if (!colDef || !QuickFilter) {
84629
+ return null;
84630
+ }
84631
+ return /* @__PURE__ */ React76__default.default.createElement(
84632
+ EmptyResultsControlTooltip,
84633
+ {
84634
+ featureI18nKey: "featureQuickFilter",
84635
+ enabled: hasNoContent
84636
+ },
84637
+ /* @__PURE__ */ React76__default.default.createElement(
84638
+ QuickFilter,
84639
+ {
84640
+ key: fieldName,
84641
+ columnDefinition: colDef,
84642
+ disabled: hasNoContent,
84643
+ overlayMatchesTriggerWidth
84644
+ }
84645
+ )
84646
+ );
84647
+ }),
84648
+ tokenNames.map((fieldName) => {
84649
+ const colDef = getColumnDefinition(fieldName);
84650
+ if (!colDef) {
84651
+ return null;
84652
+ }
84653
+ const filter = getListFilter(fieldName);
84654
+ return /* @__PURE__ */ React76__default.default.createElement(StyledFilterTokenWrapper, { key: fieldName }, /* @__PURE__ */ React76__default.default.createElement(coreReact.UNSAFE_FilterToken, null, /* @__PURE__ */ React76__default.default.createElement(coreReact.UNSAFE_FilterToken.Label, null, getFilterTokenText(
84655
+ colDef,
84656
+ colDef.filterRenderer === DateFilterRenderer_default ? filter.value : filter.selected
84657
+ )), /* @__PURE__ */ React76__default.default.createElement(
84658
+ coreReact.UNSAFE_FilterToken.Remove,
84659
+ {
84660
+ "data-qa": "data-table-quick-filter-remove-token",
84661
+ onClick: () => onClearFilter(fieldName)
84662
+ }
84663
+ )));
84664
+ })
84665
+ );
84634
84666
  };
84635
- var useSuperSelectOptionAsValueWorkaround2 = ({
84636
- originValue,
84637
- originOptions,
84638
- getId: getId3,
84639
- loading
84640
- }) => {
84641
- const isValueFromOptions = React76__default.default.useRef(false);
84642
- const getValueFromOptions = () => {
84643
- const valueIds = originValue.map((option) => getId(getId3, option));
84644
- isValueFromOptions.current = true;
84645
- return originOptions.filter(
84646
- (option) => valueIds.includes(getId(getId3, option))
84667
+ var QuickFilters = ({ overlayMatchesTriggerWidth }) => {
84668
+ const { onServerSideDataRequest } = useInternalTableContext();
84669
+ if (onServerSideDataRequest) {
84670
+ return /* @__PURE__ */ React76__default.default.createElement(
84671
+ ServerSideQuickFilters,
84672
+ {
84673
+ overlayMatchesTriggerWidth
84674
+ }
84647
84675
  );
84648
- };
84649
- const hasOptions = originOptions.length > 0 && !loading;
84650
- const hasValue = (originValue == null ? void 0 : originValue.length) > 0;
84651
- const options = !hasOptions && hasValue ? originValue : originOptions;
84652
- const value = !hasOptions ? originValue : isValueFromOptions.current ? originValue : getValueFromOptions();
84653
- return {
84654
- options,
84655
- value,
84656
- getOptionValue: (option) => option
84657
- };
84658
- };
84659
- var ServerSideMultiSelectQuickFilter = ({ columnDefinition, overlayMatchesTriggerWidth, disabled }) => {
84660
- var _a;
84661
- const {
84662
- options: originOptions,
84663
- onClearFilter,
84664
- fieldName,
84665
- value: originValue = [],
84666
- onChange,
84667
- getOptions,
84668
- loading
84669
- } = useServerSideFilter({ columnDefinition });
84670
- const { options, value, getOptionValue } = useSuperSelectOptionAsValueWorkaround2({
84671
- originOptions,
84672
- originValue,
84673
- loading,
84674
- getId: (_a = columnDefinition.filterProps) == null ? void 0 : _a.getId
84675
- });
84676
- return /* @__PURE__ */ React76__default.default.createElement(StyledSuperSelectWrapper, { $enabled: Boolean(value == null ? void 0 : value.length) }, /* @__PURE__ */ React76__default.default.createElement(
84677
- coreReact.UNSAFE_SuperSelect,
84676
+ }
84677
+ return /* @__PURE__ */ React76__default.default.createElement(
84678
+ ClientSideQuickFilters,
84678
84679
  {
84679
- overlayMatchesTriggerWidth,
84680
- loading,
84681
- value: value === null ? [] : value,
84682
- search: false,
84683
- getOptionLabel: (option) => {
84684
- var _a2;
84685
- return getLabel((_a2 = columnDefinition.filterProps) == null ? void 0 : _a2.getLabel, option);
84686
- },
84687
- getOptionValue,
84688
- multiple: true,
84689
- options,
84690
- disabled,
84691
- onChange: (values2) => {
84692
- if (Array.isArray(values2) && !values2.length) {
84693
- onClearFilter == null ? void 0 : onClearFilter(fieldName);
84694
- getOptions();
84695
- return;
84696
- }
84697
- onChange(values2);
84698
- },
84699
- onOpenChange: (open) => {
84700
- if (open && !originOptions.length) {
84701
- getOptions();
84702
- }
84703
- },
84704
- ...getSuperSelectFilterPreset(columnDefinition)
84680
+ overlayMatchesTriggerWidth
84705
84681
  }
84706
- ));
84682
+ );
84707
84683
  };
84708
- var MultiSelectQuickFilterRenderer = (props) => {
84684
+ var FiltersPanelButton = () => {
84709
84685
  const { onServerSideDataRequest } = useInternalTableContext();
84710
- if (!isClientSideFilterProps(props, !!onServerSideDataRequest)) {
84711
- return /* @__PURE__ */ React76__default.default.createElement(ServerSideMultiSelectQuickFilter, { ...props });
84686
+ if (onServerSideDataRequest) {
84687
+ return /* @__PURE__ */ React76__default.default.createElement(ServerSideFiltersPanelToggleButton, null);
84712
84688
  }
84713
- return /* @__PURE__ */ React76__default.default.createElement(ClientSideMultiSelectQuickFilter, { ...props });
84689
+ return /* @__PURE__ */ React76__default.default.createElement(ClientSideFiltersPanelToggleButton, null);
84714
84690
  };
84715
- var MultiSelectQuickFilterRenderer_default = MultiSelectQuickFilterRenderer;
84716
- var ClientSideSingleSelectQuickFilter = ({
84717
- filter,
84718
- columnDefinition,
84719
- onChange,
84720
- onRemove,
84721
- overlayMatchesTriggerWidth,
84722
- disabled
84723
- }) => {
84724
- var _a;
84691
+ var RowGroupSelector = ({ localeText }) => {
84692
+ const {
84693
+ columnDefinitions: _columnDefinitions,
84694
+ columnApi,
84695
+ gridApi,
84696
+ tableRef
84697
+ } = useInternalTableContext();
84698
+ const hasNoContent = useTableHasNoContent();
84699
+ const [columnDefinitions, setColumnDefinitions] = React76__default.default.useState(_columnDefinitions);
84700
+ const groupableColumns = React76__default.default.useMemo(
84701
+ () => mapColumnsToOptions(
84702
+ columnDefinitions.filter((column2) => column2.enableRowGroup)
84703
+ ),
84704
+ [columnDefinitions]
84705
+ );
84706
+ const groupedColumns = React76__default.default.useMemo(() => {
84707
+ const rowGrouping = (columnApi == null ? void 0 : columnApi.getRowGroupColumns()) ?? [];
84708
+ return rowGrouping.map((column2) => {
84709
+ const colDef = column2.getColDef();
84710
+ return transformToColumnDefinition(colDef);
84711
+ });
84712
+ }, [columnDefinitions]);
84713
+ const selectedColumns = React76__default.default.useMemo(
84714
+ () => mapColumnsToOptions(groupedColumns),
84715
+ [groupedColumns]
84716
+ );
84717
+ const onGroupedClear = React76__default.default.useCallback(() => {
84718
+ var _a;
84719
+ (_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.setRowGrouping([]);
84720
+ }, [tableRef]);
84721
+ const onGroupedRowChange = React76__default.default.useCallback(
84722
+ (newValue) => {
84723
+ var _a;
84724
+ const fields = newValue.map((val) => {
84725
+ return val.id;
84726
+ });
84727
+ if (!ramda.equals(selectedColumns, newValue)) {
84728
+ (_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.setRowGrouping(fields);
84729
+ }
84730
+ },
84731
+ [selectedColumns]
84732
+ );
84733
+ React76__default.default.useEffect(() => {
84734
+ function onDisplayedColumnsChanged(event) {
84735
+ const agColumnDefs = event.api.getColumnDefs();
84736
+ if (agColumnDefs == null ? void 0 : agColumnDefs.length) {
84737
+ const flattenedAgColDefs = flattenColDefs(event.api.getColumnDefs());
84738
+ const dataTableColumnDefinitions = flattenedAgColDefs.map(
84739
+ transformToColumnDefinition
84740
+ );
84741
+ setColumnDefinitions(dataTableColumnDefinitions);
84742
+ }
84743
+ }
84744
+ gridApi == null ? void 0 : gridApi.addEventListener(
84745
+ "displayedColumnsChanged",
84746
+ onDisplayedColumnsChanged
84747
+ );
84748
+ return () => {
84749
+ removeEventListenerFromGrid(
84750
+ "displayedColumnsChanged",
84751
+ onDisplayedColumnsChanged,
84752
+ gridApi
84753
+ );
84754
+ };
84755
+ }, [gridApi]);
84756
+ if (groupableColumns.length === 0) {
84757
+ return null;
84758
+ }
84725
84759
  return /* @__PURE__ */ React76__default.default.createElement(
84726
- StyledSuperSelectWrapper,
84760
+ EmptyResultsControlTooltip,
84727
84761
  {
84728
- $enabled: Boolean((_a = filter.filterValues) == null ? void 0 : _a.length),
84729
- "data-test-id": "client-side-single-select-quick-filter"
84762
+ featureI18nKey: "featureGroupBy",
84763
+ enabled: hasNoContent
84730
84764
  },
84731
84765
  /* @__PURE__ */ React76__default.default.createElement(
84732
- coreReact.UNSAFE_SuperSelect,
84766
+ coreReact.Tooltip,
84733
84767
  {
84734
- overlayMatchesTriggerWidth,
84735
- value: filter.filterValues ?? [],
84736
- search: false,
84737
- multiple: false,
84738
- options: filter.options,
84739
- disabled,
84740
- getOptionValue: (option) => {
84741
- var _a2;
84742
- return getId((_a2 = columnDefinition.filterProps) == null ? void 0 : _a2.getId, option);
84743
- },
84744
- getOptionLabel: (option) => {
84745
- var _a2;
84746
- return getLabel((_a2 = columnDefinition.filterProps) == null ? void 0 : _a2.getLabel, option);
84747
- },
84748
- onChange: (values2) => {
84749
- const valuesArray = ensureArray(values2);
84750
- if (!valuesArray.length) {
84751
- onRemove == null ? void 0 : onRemove();
84752
- return;
84753
- }
84754
- onChange == null ? void 0 : onChange(valuesArray);
84755
- },
84756
- ...getSuperSelectFilterPreset(columnDefinition)
84757
- }
84768
+ overlay: localeText.placeholder,
84769
+ trigger: "hover",
84770
+ placement: "top",
84771
+ showDelay: 400
84772
+ },
84773
+ /* @__PURE__ */ React76__default.default.createElement(coreReact.Box, { style: { width: "100%" } }, /* @__PURE__ */ React76__default.default.createElement(
84774
+ labsGroupBySelect.GroupBySelect,
84775
+ {
84776
+ isDisabled: hasNoContent,
84777
+ localeText,
84778
+ onBlur: onGroupedRowChange,
84779
+ onClear: onGroupedClear,
84780
+ options: groupableColumns,
84781
+ selected: selectedColumns
84782
+ }
84783
+ ))
84758
84784
  )
84759
84785
  );
84760
84786
  };
84761
- var useSuperSelectOptionAsValueWorkaround3 = ({
84762
- originValue,
84763
- originOptions,
84764
- getId: getId3,
84765
- loading
84787
+ function mapColumnsToOptions(columnDefinitions) {
84788
+ return columnDefinitions.map((col) => {
84789
+ return {
84790
+ label: col.headerName,
84791
+ id: col.field,
84792
+ key: col.field,
84793
+ group: col.columnGroupName
84794
+ };
84795
+ });
84796
+ }
84797
+ var cx21 = classnames__default.default.bind(quickControlsStyles_default);
84798
+ var ClientSideSearch = ({
84799
+ onSearch,
84800
+ placeholder
84766
84801
  }) => {
84767
- const isValueFromOptions = React76__default.default.useRef(false);
84768
- const getValueFromOptions = () => {
84769
- const valueIds = originValue.map((option) => getId(getId3, option));
84770
- isValueFromOptions.current = true;
84771
- return originOptions.filter(
84772
- (option) => valueIds.includes(getId(getId3, option))
84773
- );
84774
- };
84775
- const hasOptions = originOptions.length > 0 && !loading;
84776
- const hasValue = (originValue == null ? void 0 : originValue.length) > 0;
84777
- const options = !hasOptions && hasValue ? originValue : originOptions;
84778
- const value = !hasOptions ? originValue : isValueFromOptions.current ? originValue : getValueFromOptions();
84779
- return {
84780
- options,
84781
- value,
84782
- getOptionValue: (option) => option
84783
- };
84784
- };
84785
- var ServerSideSingleSelectQuickFilter = ({ columnDefinition, overlayMatchesTriggerWidth, disabled }) => {
84786
84802
  var _a;
84787
- const {
84788
- options: originOptions,
84789
- onClearFilter,
84790
- fieldName,
84791
- value: originValue = [],
84792
- onChange,
84793
- getOptions,
84794
- loading
84795
- } = useServerSideFilter({ columnDefinition });
84796
- const { options, value, getOptionValue } = useSuperSelectOptionAsValueWorkaround3({
84797
- originOptions,
84798
- originValue,
84799
- loading,
84800
- getId: (_a = columnDefinition.filterProps) == null ? void 0 : _a.getId
84801
- });
84802
- const hasFetchedOptions = React76__default.default.useRef(false);
84803
- React76__default.default.useEffect(() => {
84804
- if (!hasFetchedOptions.current && !originOptions.length) {
84805
- getOptions();
84806
- hasFetchedOptions.current = true;
84803
+ const [internalValue, setInternalValue] = React76__default.default.useState("");
84804
+ const { tableRef } = useInternalTableContext();
84805
+ const hasNoContent = useTableHasNoContent();
84806
+ const I18n = coreReact.useI18nContext();
84807
+ const debouncedSetSearchValue = React76__default.default.useCallback(
84808
+ debounce5__default.default((value) => {
84809
+ var _a2;
84810
+ (_a2 = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a2.setSearchValue(value);
84811
+ }, 250),
84812
+ [(_a = tableRef == null ? void 0 : tableRef.current) == null ? void 0 : _a.setSearchValue]
84813
+ );
84814
+ const onChange = React76__default.default.useCallback(
84815
+ (value, event) => {
84816
+ setInternalValue(value);
84817
+ if (onSearch) {
84818
+ onSearch(event);
84819
+ } else {
84820
+ debouncedSetSearchValue(value);
84821
+ }
84822
+ },
84823
+ [debouncedSetSearchValue, onSearch]
84824
+ );
84825
+ return /* @__PURE__ */ React76__default.default.createElement(EmptyResultsControlTooltip, { hasSearch: true, enabled: hasNoContent }, /* @__PURE__ */ React76__default.default.createElement(
84826
+ coreReact.Typeahead,
84827
+ {
84828
+ disabled: hasNoContent,
84829
+ "data-qa": "data-table-search",
84830
+ value: internalValue,
84831
+ className: cx21("search", {
84832
+ "search--empty": !internalValue.length
84833
+ }),
84834
+ onChange,
84835
+ placeholder: placeholder || I18n.t("dataTable.search")
84807
84836
  }
84808
- }, [getOptions, originOptions.length]);
84809
- const handleOnChange = (values2) => {
84810
- const selectedValues = ensureArray(values2);
84811
- if (!selectedValues.length) {
84812
- onClearFilter == null ? void 0 : onClearFilter(fieldName);
84813
- getOptions();
84814
- return;
84837
+ ));
84838
+ };
84839
+ var Search = (props) => {
84840
+ const { onServerSideDataRequest } = useInternalTableContext();
84841
+ if (onServerSideDataRequest) {
84842
+ return /* @__PURE__ */ React76__default.default.createElement(ServerSideSearch, { ...props });
84843
+ }
84844
+ return /* @__PURE__ */ React76__default.default.createElement(ClientSideSearch, { ...props });
84845
+ };
84846
+
84847
+ // src/QuickControls/QuickControls.tsx
84848
+ var QuickControls = (props) => {
84849
+ const I18n = coreReact.useI18nContext();
84850
+ if (props.children) {
84851
+ return /* @__PURE__ */ React76__default.default.createElement(
84852
+ coreReact.Box,
84853
+ {
84854
+ "data-qa": "data-table-quick-controls",
84855
+ padding: "xs none",
84856
+ style: props.style
84857
+ },
84858
+ props.children
84859
+ );
84860
+ }
84861
+ return /* @__PURE__ */ React76__default.default.createElement(coreReact.Box, { padding: "xs none", style: props.style }, /* @__PURE__ */ React76__default.default.createElement(coreReact.Box, { padding: "xs none", display: "flex-row", justifyContent: "space-between" }, /* @__PURE__ */ React76__default.default.createElement(coreReact.FlexList, { size: "xs", alignItems: "center", marginRight: "sm" }, /* @__PURE__ */ React76__default.default.createElement(
84862
+ Search,
84863
+ {
84864
+ onSearch: props.onSearch,
84865
+ placeholder: props.placeholder,
84866
+ disabled: props.disabledSearch
84815
84867
  }
84816
- onChange(selectedValues);
84817
- };
84818
- const handleOnOpenChange = (open) => {
84819
- if (open && !originOptions.length) {
84820
- getOptions();
84868
+ ), /* @__PURE__ */ React76__default.default.createElement(FiltersPanelButton, null)), /* @__PURE__ */ React76__default.default.createElement(coreReact.FlexList, { size: "xs", alignItems: "center" }, /* @__PURE__ */ React76__default.default.createElement(
84869
+ RowGroupSelector,
84870
+ {
84871
+ localeText: {
84872
+ reset: I18n.t("dataTable.tableSettings.reset"),
84873
+ placeholder: I18n.t("dataTable.tableSettings.selectColumnGroup"),
84874
+ selectedItemsPrefix: I18n.t("dataTable.tableSettings.groupBy")
84875
+ }
84821
84876
  }
84822
- };
84877
+ ), /* @__PURE__ */ React76__default.default.createElement(ConfigPanelButton, null))), /* @__PURE__ */ React76__default.default.createElement(
84878
+ QuickFilters,
84879
+ {
84880
+ overlayMatchesTriggerWidth: props.filterOverlayMatchesTriggerWidth
84881
+ }
84882
+ ));
84883
+ };
84884
+
84885
+ // src/utils/addSubcomponents.ts
84886
+ var addSubcomponents = (subs, parent) => {
84887
+ const assigned = parent;
84888
+ Object.keys(subs).forEach((key) => {
84889
+ assigned[key] = subs[key];
84890
+ });
84891
+ return assigned;
84892
+ };
84893
+
84894
+ // src/ClientSideDataTable.tsx
84895
+ var ClientSideDataTable = ({
84896
+ analytics,
84897
+ children,
84898
+ columnDefinitions: _columnDefinitions,
84899
+ customBulkEditorFields,
84900
+ enableDynamicRowHeight,
84901
+ enableGroupEditAndValidation,
84902
+ filterGroups,
84903
+ getRowId,
84904
+ initialTableConfig: _initialTableConfig,
84905
+ onBulkEditUpdate,
84906
+ onTableConfigChange,
84907
+ translations: translations2 = {},
84908
+ enableCellTextSelection,
84909
+ localStoragePersistenceKey
84910
+ }) => {
84823
84911
  return /* @__PURE__ */ React76__default.default.createElement(
84824
- StyledSuperSelectWrapper,
84912
+ DataTable,
84825
84913
  {
84826
- $enabled: Boolean(value == null ? void 0 : value.length),
84827
- "data-test-id": "server-side-single-select-quick-filter"
84914
+ analytics,
84915
+ columnDefinitions: _columnDefinitions,
84916
+ enableGroupEditAndValidation,
84917
+ enableDynamicRowHeight,
84918
+ filterGroups,
84919
+ getRowId,
84920
+ initialTableConfig: _initialTableConfig,
84921
+ onTableConfigChange,
84922
+ onBulkEditUpdate,
84923
+ showExpandCollapseAllToggle: true,
84924
+ translations: translations2,
84925
+ localStoragePersistenceKey,
84926
+ customBulkEditorFields,
84927
+ enableCellTextSelection
84828
84928
  },
84829
- /* @__PURE__ */ React76__default.default.createElement(
84830
- coreReact.UNSAFE_SuperSelect,
84831
- {
84832
- overlayMatchesTriggerWidth,
84833
- loading,
84834
- value: value ?? [],
84835
- search: false,
84836
- disabled,
84837
- getOptionLabel: (option) => {
84838
- var _a2;
84839
- return getLabel((_a2 = columnDefinition.filterProps) == null ? void 0 : _a2.getLabel, option);
84840
- },
84841
- getOptionValue,
84842
- multiple: false,
84843
- options,
84844
- onChange: handleOnChange,
84845
- onOpenChange: handleOnOpenChange,
84846
- ...getSuperSelectFilterPreset(columnDefinition)
84847
- }
84848
- )
84929
+ children
84849
84930
  );
84850
84931
  };
84851
- var SingleSelectQuickFilterRenderer = (props) => {
84852
- const { onServerSideDataRequest } = useInternalTableContext();
84853
- if (!isClientSideFilterProps(props, !!onServerSideDataRequest)) {
84854
- return /* @__PURE__ */ React76__default.default.createElement(ServerSideSingleSelectQuickFilter, { ...props });
84855
- }
84856
- return /* @__PURE__ */ React76__default.default.createElement(ClientSideSingleSelectQuickFilter, { ...props });
84932
+ var Table2 = (props) => {
84933
+ const internalTableContext = useInternalTableContext();
84934
+ React76__default.default.useEffect(() => {
84935
+ var _a;
84936
+ internalTableContext.setTotalRowCount(((_a = props.rows) == null ? void 0 : _a.length) ?? 0);
84937
+ }, [props.rows]);
84938
+ return /* @__PURE__ */ React76__default.default.createElement(Table, { ...props, modules: [ClientSideRowModelModule] });
84857
84939
  };
84858
- var SingleSelectQuickFilterRenderer_default = SingleSelectQuickFilterRenderer;
84940
+ BulkActions.displayName = "ClientSideDataTable.BulkActions";
84941
+ ConfigPanelButton.displayName = "ClientSideDataTable.ConfigPanelButton";
84942
+ ContextPanel.displayName = "ClientSideDataTable.ContextPanel";
84943
+ QuickControls.displayName = "ClientSideDataTable.QuickControls";
84944
+ QuickFilters.displayName = "ClientSideDataTable.QuickFilters";
84945
+ RowGroupSelector.displayName = "ClientSideDataTable.RowGroupSelector";
84946
+ Search.displayName = "ClientSideDataTable.Search";
84947
+ Table2.displayName = "ClientSideDataTable.Table";
84948
+ FiltersPanel.displayName = "ClientSideDataTable.FiltersPanel";
84949
+ var ClientSideDataTable_default = addSubcomponents(
84950
+ {
84951
+ BulkActions,
84952
+ BulkEditActionButton,
84953
+ ConfigPanelButton,
84954
+ ContextPanel,
84955
+ QuickControls,
84956
+ QuickFilters,
84957
+ RowGroupSelector,
84958
+ Search,
84959
+ Table: Table2,
84960
+ FiltersPanel,
84961
+ FiltersPanelButton
84962
+ },
84963
+ ClientSideDataTable
84964
+ );
84859
84965
 
84860
84966
  // ../../node_modules/@ag-grid-enterprise/server-side-row-model/dist/esm/es6/serverSideRowModel/stores/fullStore.mjs
84861
84967
  var __decorate212 = function(decorators, target, key, desc) {