@ceed/cds 1.8.7 → 1.9.0

package/dist/index.js

@@ -1857,7 +1857,8 @@ import React23, {
   useImperativeHandle as useImperativeHandle2,
   createElement,
   memo,
-  useLayoutEffect
+  useLayoutEffect,
+  Fragment as Fragment2
 } from "react";
 import { useVirtualizer as useVirtualizer2 } from "@tanstack/react-virtual";
 import { styled as styled12, LinearProgress, Link, useTheme, buttonClasses, iconButtonClasses } from "@mui/joy";
@@ -2628,6 +2629,118 @@ function InfoSign(props) {
 var InfoSign_default = InfoSign;
 
 // src/components/DataTable/DataTable.tsx
+function extractFieldsFromGroupingModel(items) {
+  const fields = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if ("groupId" in item) {
+      const children = Array.isArray(item.children) ? item.children : [item.children];
+      const childFields = extractFieldsFromGroupingModel(children);
+      childFields.forEach((field) => fields.add(field));
+    } else {
+      fields.add(item.field);
+    }
+  }
+  return fields;
+}
+function reorderColumnsByGroupingModel(columns, columnGroupingModel) {
+  const fieldsInGroupingModel = extractFieldsFromGroupingModel(columnGroupingModel);
+  const orderedFields = [];
+  function collectFieldsInOrder(items) {
+    for (const item of items) {
+      if ("groupId" in item) {
+        const children = Array.isArray(item.children) ? item.children : [item.children];
+        collectFieldsInOrder(children);
+      } else {
+        if (!orderedFields.includes(item.field)) {
+          orderedFields.push(item.field);
+        }
+      }
+    }
+  }
+  collectFieldsInOrder(columnGroupingModel);
+  const columnMap = new Map(columns.map((col) => [col.field, col]));
+  const reorderedColumns = [];
+  for (const field of orderedFields) {
+    const column = columnMap.get(field);
+    if (column) {
+      reorderedColumns.push(column);
+    }
+  }
+  for (const column of columns) {
+    if (!fieldsInGroupingModel.has(column.field)) {
+      reorderedColumns.push(column);
+    }
+  }
+  return reorderedColumns;
+}
+function flattenColumnGroups(items, groupPath = [], columnIndex = { current: 0 }) {
+  const result = [];
+  for (const item of items) {
+    if ("groupId" in item) {
+      const newPath = [...groupPath, item.groupId];
+      const children = Array.isArray(item.children) ? item.children : [item.children];
+      result.push(...flattenColumnGroups(children, newPath, columnIndex));
+    } else {
+      result.push({
+        ...item,
+        groupPath,
+        columnIndex: columnIndex.current++
+      });
+    }
+  }
+  return result;
+}
+function calculateColumnGroups(columnGroupingModel, columns) {
+  const fieldsInGroupingModel = extractFieldsFromGroupingModel(columnGroupingModel);
+  const flattenedColumns = flattenColumnGroups(columnGroupingModel);
+  const columnIndexMap = new Map(flattenedColumns.map((col) => [col.field, col.columnIndex]));
+  const processedGroups = /* @__PURE__ */ new Map();
+  const groupsByLevel = [];
+  let maxLevel = 0;
+  function processGroup(items, level, parentGroupId) {
+    let minIndex = Infinity;
+    let maxIndex = -Infinity;
+    for (const item of items) {
+      if ("groupId" in item) {
+        const groupKey = parentGroupId ? `${parentGroupId}.${item.groupId}` : item.groupId;
+        if (!processedGroups.has(groupKey)) {
+          const children = Array.isArray(item.children) ? item.children : [item.children];
+          const { startIndex, colspan } = processGroup(children, level + 1, groupKey);
+          const group = {
+            groupId: item.groupId,
+            headerName: item.headerName,
+            colspan,
+            level,
+            startIndex
+          };
+          processedGroups.set(groupKey, group);
+          if (!groupsByLevel[level]) {
+            groupsByLevel[level] = [];
+          }
+          groupsByLevel[level].push(group);
+          maxLevel = Math.max(maxLevel, level);
+          minIndex = Math.min(minIndex, startIndex);
+          maxIndex = Math.max(maxIndex, startIndex + colspan - 1);
+        }
+      } else {
+        const columnIndex = columnIndexMap.get(item.field);
+        if (columnIndex !== void 0) {
+          minIndex = Math.min(minIndex, columnIndex);
+          maxIndex = Math.max(maxIndex, columnIndex);
+        }
+      }
+    }
+    return {
+      startIndex: minIndex === Infinity ? 0 : minIndex,
+      colspan: maxIndex === -Infinity ? 0 : maxIndex - minIndex + 1
+    };
+  }
+  processGroup(columnGroupingModel, 0);
+  groupsByLevel.forEach((level) => {
+    level.sort((a, b) => a.startIndex - b.startIndex);
+  });
+  return { groups: groupsByLevel, maxLevel, fieldsInGroupingModel };
+}
 function getTextAlign(props) {
   return !props.editMode && ["number", "date", "currency"].includes(props.type || "") ? "end" : "start";
 }
@@ -2698,7 +2811,7 @@ var OverlayWrapper = styled12("tr", {
   }
 });
 var numberFormatter = (value) => "Intl" in window ? new Intl.NumberFormat().format(value) : value;
-var Resizer = (ref) => /* @__PURE__ */ React23.createElement(
+var Resizer = (ref, targetRef = ref) => /* @__PURE__ */ React23.createElement(
   Box_default,
   {
     sx: {
@@ -2716,6 +2829,7 @@ var Resizer = (ref) => /* @__PURE__ */ React23.createElement(
       const onMouseMove = (e2) => {
         if (initialWidth && initialX) {
           ref.current.style.width = `${initialWidth + (e2.clientX - initialX)}px`;
+          targetRef.current.style.width = `${initialWidth + (e2.clientX - initialX)}px`;
         }
       };
       const onMouseUp = () => {
@@ -2826,17 +2940,19 @@ var HeadCell = (props) => {
     isPinned,
     pinnedStartPosition,
     pinnedEndPosition,
-    headerRef
+    headerRef,
+    tableColRef
   } = props;
   const theme = useTheme();
   const ref = headerRef;
+  const colRef = tableColRef;
   const [isHovered, setIsHovered] = useState6(false);
   const sortable = type === "actions" ? false : _sortable;
   const headId = useMemo8(
     () => `${tableId}_header_${headerName ?? field}`.trim(),
     [tableId, headerName, field]
   );
-  const resizer = useMemo8(() => resizable ?? true ? Resizer(ref) : null, [resizable, ref]);
+  const resizer = useMemo8(() => resizable ?? true ? Resizer(ref, colRef) : null, [resizable, ref, colRef]);
   const style = useMemo8(
     () => ({
       width,
@@ -3171,8 +3287,15 @@ function useDataTableRenderer({
   editMode,
   getId: _getId,
   isTotalSelected: _isTotalSelected,
-  isRowSelectable
+  isRowSelectable,
+  columnGroupingModel
+  // Add this prop
 }) {
+  if (pinnedColumns && columnGroupingModel) {
+    throw new Error(
+      "You cannot use both `pinnedColumns` and `columnGroupingModel` at the same time. Please choose one of them."
+    );
+  }
   const onSelectionModelChangeRef = useRef4(onSelectionModelChange);
   onSelectionModelChangeRef.current = onSelectionModelChange;
   const [focusedRowId, setFocusedRowId] = useState6(null);
@@ -3181,18 +3304,23 @@ function useDataTableRenderer({
     initialState?.sorting?.sortModel ?? [],
     useCallback9((sortModel2) => onSortModelChange?.(sortModel2), [onSortModelChange])
   );
+  const reorderedColumns = useMemo8(() => {
+    if (!columnGroupingModel) return columnsProp;
+    return reorderColumnsByGroupingModel(columnsProp, columnGroupingModel);
+  }, [columnsProp, columnGroupingModel]);
   const columnsByField = useMemo8(
-    () => columnsProp.reduce(
+    () => reorderedColumns.reduce(
       (acc, curr) => ({
         ...acc,
         [curr.field]: {
           ...curr,
-          headerRef: React23.createRef()
+          headerRef: React23.createRef(),
+          tableColRef: React23.createRef()
         }
       }),
       {}
     ),
-    [columnsProp]
+    [reorderedColumns]
   );
   const sortComparator = useCallback9(
     (rowA, rowB) => {
@@ -3272,11 +3400,17 @@ function useDataTableRenderer({
     columnsByField[f].minWidth ?? 0,
     [columnWidths, columnsByField]
   );
+  const processedColumnGroups = useMemo8(() => {
+    if (!columnGroupingModel) return null;
+    return calculateColumnGroups(columnGroupingModel, reorderedColumns);
+  }, [columnGroupingModel, reorderedColumns]);
   const columns = useMemo8(() => {
-    const baseColumns = columnsProp || // fallback
-    Object.keys(rows[0] || {}).map((key) => ({
-      field: key
-    }));
+    const baseColumns = reorderedColumns.length > 0 ? reorderedColumns : (
+      // fallback
+      Object.keys(rows[0] || {}).map((key) => ({
+        field: key
+      }))
+    );
     return baseColumns.map((column) => {
       const isLeftPinned = pinnedColumns?.left?.includes(column.field);
       const isRightPinned = pinnedColumns?.right?.includes(column.field);
@@ -3284,6 +3418,7 @@ function useDataTableRenderer({
       return {
         ...column,
         headerRef: columnsByField[column.field].headerRef,
+        tableColRef: columnsByField[column.field].tableColRef,
         isCellEditable: editMode && (typeof column.isCellEditable === "function" ? column.isCellEditable : column.isCellEditable ?? true),
         sort: sortModel.find((sort) => sort.field === column.field)?.sort,
         sortOrder: columnsByField[column.field]?.sortOrder || sortOrder,
@@ -3296,7 +3431,7 @@ function useDataTableRenderer({
       };
     });
   }, [
-    columnsProp,
+    reorderedColumns,
     rows,
     pinnedColumns?.left,
     pinnedColumns?.right,
@@ -3392,6 +3527,7 @@ function useDataTableRenderer({
       [selectionModel, onSelectionModelChange, selectedModelSet]
     ),
     columns,
+    processedColumnGroups,
     onTotalSelect: useCallback9(() => {
       const selectableRows = rows.filter((row, i) => {
         if (!isRowSelectable) return true;
@@ -3434,6 +3570,8 @@ function Component(props, apiRef) {
     getId: ____________,
     // getId is used in useDataTableRenderer
     loading,
+    columnGroupingModel: _________________,
+    // columnGroupingModel is used in useDataTableRenderer
     slots: {
       checkbox: RenderCheckbox = Checkbox_default,
       toolbar: Toolbar,
@@ -3450,6 +3588,7 @@ function Component(props, apiRef) {
   const tableBodyRef = useRef4(null);
   const {
     columns,
+    processedColumnGroups,
     isAllSelected,
     isSelectedRow,
     isRowSelectable: isRowSelectableCheck,
@@ -3557,7 +3696,8 @@ function Component(props, apiRef) {
           boxShadow: "sm",
           borderRadius: "sm",
           "--DataTableSheet-width": parentRef.current?.clientWidth + "px",
-          backgroundColor: "white"
+          backgroundColor: "white",
+          "--TableCell-cornerRadius": "0px"
         },
         className: [
           ...(parentRef.current?.scrollLeft || 0) > 0 ? ["ScrollableRight"] : [],
@@ -3566,12 +3706,30 @@ function Component(props, apiRef) {
         ref: parentRef,
         ...backgroundProps
       },
-      /* @__PURE__ */ React23.createElement(Table, { ...innerProps }, /* @__PURE__ */ React23.createElement("thead", null, /* @__PURE__ */ React23.createElement("tr", null, checkboxSelection && /* @__PURE__ */ React23.createElement(
+      /* @__PURE__ */ React23.createElement(Table, { ...innerProps }, /* @__PURE__ */ React23.createElement("colgroup", null, checkboxSelection && /* @__PURE__ */ React23.createElement(
+        "col",
+        {
+          style: {
+            width: "40px"
+          }
+        }
+      ), columns.map((c) => /* @__PURE__ */ React23.createElement(
+        "col",
+        {
+          ref: c.tableColRef,
+          key: `${c.field.toString()}_${c.width}`,
+          style: {
+            width: c.width
+          }
+        }
+      ))), /* @__PURE__ */ React23.createElement("thead", null, processedColumnGroups && processedColumnGroups.groups.map((levelGroups, level) => /* @__PURE__ */ React23.createElement("tr", { key: `group-level-${level}` }, checkboxSelection && level === 0 && /* @__PURE__ */ React23.createElement(
         "th",
         {
+          rowSpan: processedColumnGroups.maxLevel + 2,
           style: {
             width: "40px",
-            textAlign: "center"
+            textAlign: "center",
+            verticalAlign: "middle"
           }
         },
         /* @__PURE__ */ React23.createElement(
@@ -3584,16 +3742,52 @@ function Component(props, apiRef) {
             ...checkboxProps
           }
         )
-      ), columns.map((c, i) => /* @__PURE__ */ React23.createElement(
-        HeadCell2,
+      ), level > 0 && Array.from({ length: levelGroups[0]?.startIndex || 0 }).map((_2, i) => /* @__PURE__ */ React23.createElement("th", { key: `empty-${level}-${i}` })), levelGroups.map((group, groupIndex) => {
+        const nextGroup = levelGroups[groupIndex + 1];
+        const emptyCells = nextGroup ? nextGroup.startIndex - (group.startIndex + group.colspan) : columns.length - (group.startIndex + group.colspan);
+        return /* @__PURE__ */ React23.createElement(Fragment2, { key: group.groupId }, /* @__PURE__ */ React23.createElement(
+          "th",
+          {
+            colSpan: group.colspan,
+            style: {
+              textAlign: "center",
+              fontWeight: "bold",
+              verticalAlign: "middle"
+            }
+          },
+          group.headerName ?? group.groupId
+        ), emptyCells > 0 && Array.from({ length: emptyCells }).map((_2, i) => /* @__PURE__ */ React23.createElement("th", { key: `empty-between-${level}-${groupIndex}-${i}`, colSpan: 1 })));
+      }))), /* @__PURE__ */ React23.createElement("tr", null, !processedColumnGroups && checkboxSelection && /* @__PURE__ */ React23.createElement(
+        "th",
         {
-          tableId,
-          key: `${c.field.toString()}_${i}`,
-          stickyHeader: props.stickyHeader,
-          editMode: !!c.isCellEditable,
-          onSortChange: handleSortChange,
-          ...c
-        }
+          style: {
+            width: "40px",
+            textAlign: "center"
+          }
+        },
+        /* @__PURE__ */ React23.createElement(
+          RenderCheckbox,
+          {
+            onChange: onAllCheckboxChange,
+            checked: isAllSelected,
+            indeterminate: (selectionModel || []).length > 0 && !isAllSelected,
+            disabled: dataInPage.length > 0 && !selectableRowCount,
+            ...checkboxProps
+          }
+        )
+      ), columns.map((c, i) => (
+        // @ts-ignore
+        /* @__PURE__ */ React23.createElement(
+          HeadCell2,
+          {
+            tableId,
+            key: `${c.field.toString()}_${i}`,
+            stickyHeader: props.stickyHeader,
+            editMode: !!c.isCellEditable,
+            onSortChange: handleSortChange,
+            ...c
+          }
+        )
       )))), /* @__PURE__ */ React23.createElement(
         VirtualizedTableBody,
         {