@navikt/ds-react 8.10.2 → 8.10.4

package/esm/data/table/hooks/useTableSelection.js

@@ -3,7 +3,8 @@ import { useId } from "../../../utils-external/index.js";
 import { useControllableState } from "../../../utils/hooks/index.js";
 import { getMultipleSelectProps } from "../helpers/selection/getMultipleSelectProps.js";
 import { getSingleSelectProps } from "../helpers/selection/getSingleSelectProps.js";
-function useTableSelection({ selectionMode = "none", defaultSelectedKeys, selectedKeys: selectedKeysProp, onSelectionChange, disabledSelectionKeys = [], allRowKeys, }) {
+function useTableSelection({ selection = {}, visibleRowIds = [], childRowIdsById, }) {
+    const { selectionMode = "none", defaultSelectedKeys, selectedKeys: selectedKeysProp, onSelectionChange, disabledSelectionKeys = [], disableRowSelectionOnClick = false, } = selection;
     const radioGroupName = useId();
     const [selectedKeys, setSelectedKeys] = useControllableState({
         value: selectionMode !== "none" ? selectedKeysProp : undefined,
@@ -17,6 +18,7 @@ function useTableSelection({ selectionMode = "none", defaultSelectedKeys, select
     if (selectionMode === "none") {
         return {
             selection: Object.assign(Object.assign({ selectionMode }, baseSelection), { selectedKeys: [] }),
+            disableRowSelectionOnClick,
             renderSelection: false,
         };
     }
@@ -28,7 +30,8 @@ function useTableSelection({ selectionMode = "none", defaultSelectedKeys, select
                 disabledKeysSet,
                 name: radioGroupName,
             })),
-            renderSelection: allRowKeys.length !== 0,
+            disableRowSelectionOnClick,
+            renderSelection: visibleRowIds.length !== 0,
         };
     }
     return {
@@ -37,9 +40,11 @@ function useTableSelection({ selectionMode = "none", defaultSelectedKeys, select
             selectedKeys,
             setSelectedKeys,
             disabledKeysSet,
-            allRowKeys,
+            visibleRowIds,
+            childRowIdsById,
         })),
-        renderSelection: allRowKeys.length !== 0,
+        disableRowSelectionOnClick,
+        renderSelection: visibleRowIds.length !== 0,
     };
 }
 /**
@@ -52,6 +57,7 @@ const noSelectionState = {
         disabledSelectionKeys: [],
         isRowSelected: () => false,
     },
+    disableRowSelectionOnClick: false,
     renderSelection: false,
 };
 export { useTableSelection, noSelectionState };

package/esm/data/table/hooks/useTableSelection.js.map

@@ -1 +1 @@
-{"version":3,"file":"useTableSelection.js","sourceRoot":"","sources":["../../../../src/data/table/hooks/useTableSelection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAiBjF,SAAS,iBAAiB,CAAC,EACzB,aAAa,GAAG,MAAM,EACtB,mBAAmB,EACnB,YAAY,EAAE,gBAAgB,EAC9B,iBAAiB,EACjB,qBAAqB,GAAG,EAAE,EAC1B,UAAU,GACY;IACtB,MAAM,cAAc,GAAG,KAAK,EAAE,CAAC;IAE/B,MAAM,CAAC,YAAY,EAAE,eAAe,CAAC,GAAG,oBAAoB,CAAgB;QAC1E,KAAK,EAAE,aAAa,KAAK,MAAM,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS;QAC9D,YAAY,EAAE,mBAAmB,aAAnB,mBAAmB,cAAnB,mBAAmB,GAAI,EAAE;QACvC,QAAQ,EAAE,iBAAiB;KAC5B,CAAC,CAAC;IAEH,MAAM,eAAe,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;IAE7E,MAAM,eAAe,GAAG,OAAO,CAC7B,GAAG,EAAE,CAAC,IAAI,GAAG,CAAC,qBAAqB,CAAC,EACpC,CAAC,qBAAqB,CAAC,CACxB,CAAC;IAEF,MAAM,aAAa,GAAG,WAAW,CAC/B,CAAC,KAAsB,EAAE,EAAE,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,EACtD,CAAC,eAAe,CAAC,CAClB,CAAC;IAEF,MAAM,aAAa,GAAG,EAAE,YAAY,EAAE,qBAAqB,EAAE,aAAa,EAAE,CAAC;IAE7E,IAAI,aAAa,KAAK,MAAM,EAAE,CAAC;QAC7B,OAAO;YACL,SAAS,gCACP,aAAa,IACV,aAAa,KAChB,YAAY,EAAE,EAAE,GACjB;YACD,eAAe,EAAE,KAAK;SACvB,CAAC;IACJ,CAAC;IAED,IAAI,aAAa,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO;YACL,SAAS,gCACP,aAAa,IACV,aAAa,GACb,oBAAoB,CAAC;gBACtB,eAAe;gBACf,eAAe;gBACf,eAAe;gBACf,IAAI,EAAE,cAAc;aACrB,CAAC,CACH;YACD,eAAe,EAAE,UAAU,CAAC,MAAM,KAAK,CAAC;SACzC,CAAC;IACJ,CAAC;IAED,OAAO;QACL,SAAS,gCACP,aAAa,IACV,aAAa,GACb,sBAAsB,CAAC;YACxB,eAAe;YACf,YAAY;YACZ,eAAe;YACf,eAAe;YACf,UAAU;SACX,CAAC,CACH;QACD,eAAe,EAAE,UAAU,CAAC,MAAM,KAAK,CAAC;KACzC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,gBAAgB,GAA4B;IAChD,SAAS,EAAE;QACT,aAAa,EAAE,MAAM;QACrB,YAAY,EAAE,EAAE;QAChB,qBAAqB,EAAE,EAAE;QACzB,aAAa,EAAE,GAAG,EAAE,CAAC,KAAK;KAC3B;IACD,eAAe,EAAE,KAAK;CACvB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"useTableSelection.js","sourceRoot":"","sources":["../../../../src/data/table/hooks/useTableSelection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AACrF,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAqBjF,SAAS,iBAAiB,CAAC,EACzB,SAAS,GAAG,EAAE,EACd,aAAa,GAAG,EAAE,EAClB,eAAe,GACO;IACtB,MAAM,EACJ,aAAa,GAAG,MAAM,EACtB,mBAAmB,EACnB,YAAY,EAAE,gBAAgB,EAC9B,iBAAiB,EACjB,qBAAqB,GAAG,EAAE,EAC1B,0BAA0B,GAAG,KAAK,GACnC,GAAG,SAAS,CAAC;IAEd,MAAM,cAAc,GAAG,KAAK,EAAE,CAAC;IAE/B,MAAM,CAAC,YAAY,EAAE,eAAe,CAAC,GAAG,oBAAoB,CAAgB;QAC1E,KAAK,EAAE,aAAa,KAAK,MAAM,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS;QAC9D,YAAY,EAAE,mBAAmB,aAAnB,mBAAmB,cAAnB,mBAAmB,GAAI,EAAE;QACvC,QAAQ,EAAE,iBAAiB;KAC5B,CAAC,CAAC;IAEH,MAAM,eAAe,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;IAE7E,MAAM,eAAe,GAAG,OAAO,CAC7B,GAAG,EAAE,CAAC,IAAI,GAAG,CAAC,qBAAqB,CAAC,EACpC,CAAC,qBAAqB,CAAC,CACxB,CAAC;IAEF,MAAM,aAAa,GAAG,WAAW,CAC/B,CAAC,KAAsB,EAAE,EAAE,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,EACtD,CAAC,eAAe,CAAC,CAClB,CAAC;IAEF,MAAM,aAAa,GAAG,EAAE,YAAY,EAAE,qBAAqB,EAAE,aAAa,EAAE,CAAC;IAE7E,IAAI,aAAa,KAAK,MAAM,EAAE,CAAC;QAC7B,OAAO;YACL,SAAS,gCACP,aAAa,IACV,aAAa,KAChB,YAAY,EAAE,EAAE,GACjB;YACD,0BAA0B;YAC1B,eAAe,EAAE,KAAK;SACvB,CAAC;IACJ,CAAC;IAED,IAAI,aAAa,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO;YACL,SAAS,gCACP,aAAa,IACV,aAAa,GACb,oBAAoB,CAAC;gBACtB,eAAe;gBACf,eAAe;gBACf,eAAe;gBACf,IAAI,EAAE,cAAc;aACrB,CAAC,CACH;YACD,0BAA0B;YAC1B,eAAe,EAAE,aAAa,CAAC,MAAM,KAAK,CAAC;SAC5C,CAAC;IACJ,CAAC;IAED,OAAO;QACL,SAAS,gCACP,aAAa,IACV,aAAa,GACb,sBAAsB,CAAC;YACxB,eAAe;YACf,YAAY;YACZ,eAAe;YACf,eAAe;YACf,aAAa;YACb,eAAe;SAChB,CAAC,CACH;QACD,0BAA0B;QAC1B,eAAe,EAAE,aAAa,CAAC,MAAM,KAAK,CAAC;KAC5C,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,gBAAgB,GAA4B;IAChD,SAAS,EAAE;QACT,aAAa,EAAE,MAAM;QACrB,YAAY,EAAE,EAAE;QAChB,qBAAqB,EAAE,EAAE;QACzB,aAAa,EAAE,GAAG,EAAE,CAAC,KAAK;KAC3B;IACD,0BAA0B,EAAE,KAAK;IACjC,eAAe,EAAE,KAAK;CACvB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC"}

package/esm/data/table/index.d.ts

@@ -1,2 +1 @@
-export { default as DataTable, DataTableCaption, DataTableThead, DataTableTbody, DataTableTr, DataTableTh, DataTableTd, DataTableTfoot, } from "./root/DataTableRoot.js";
-export type { DataTableProps, DataTableCaptionProps, DataTableTheadProps, DataTableTbodyProps, DataTableTrProps, DataTableThProps, DataTableTdProps, DataTableTfootProps, } from "./root/DataTableRoot.js";
+export { DataTable, type DataTableProps } from "./root/DataTableRoot.js";

package/esm/data/table/index.js

@@ -1,3 +1,23 @@
 "use client";
-export { default as DataTable, DataTableCaption, DataTableThead, DataTableTbody, DataTableTr, DataTableTh, DataTableTd, DataTableTfoot, } from "./root/DataTableRoot.js";
+/* export {
+  default as DataTable,
+  DataTableCaption,
+  DataTableThead,
+  DataTableTbody,
+  DataTableTr,
+  DataTableTh,
+  DataTableTd,
+  DataTableTfoot,
+} from "./root/DataTableRoot.legacy.js";
+export type {
+  DataTableProps,
+  DataTableCaptionProps,
+  DataTableTheadProps,
+  DataTableTbodyProps,
+  DataTableTrProps,
+  DataTableThProps,
+  DataTableTdProps,
+  DataTableTfootProps,
+} from "./root/DataTableRoot.legacy.js"; */
+export { DataTable } from "./root/DataTableRoot.js";
 //# sourceMappingURL=index.js.map

package/esm/data/table/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/data/table/index.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;AACb,OAAO,EACL,OAAO,IAAI,SAAS,EACpB,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,WAAW,EACX,WAAW,EACX,WAAW,EACX,cAAc,GACf,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/data/table/index.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;AACb;;;;;;;;;;;;;;;;;;;wCAmBwC;AAExC,OAAO,EAAE,SAAS,EAAuB,MAAM,sBAAsB,CAAC"}

package/esm/data/table/root/DataTable.types.d.ts

@@ -1,21 +1,19 @@
+import type { ResizeProps } from "../column-header/useTableColumnResize.js";
 type SortDirection = "asc" | "desc" | "none";
 /**
  * TODO:
  * - Consider "accessorKey" or similar to allow simple column definitions without a cell function.
  * - Add "align" property for better control over text alignment in cells.
  */
-type ColumnDefinition<T> = {
+type ColumnDefinition<T, DetailsT = Record<string, any>> = Pick<ResizeProps, "resizable" | "width" | "defaultWidth" | "autoWidth" | "minWidth" | "maxWidth" | "onWidthChange"> & {
     id: string;
-    width?: number | string;
-    defaultWidth?: number | string;
-    minWidth?: number | string;
-    maxWidth?: number | string;
     /**
-     * Currently only handles cell alignment.
-     * TODO: Should this include centering?
-     * type "icon" or something to avoid ellipsis on actions, tags etc
+     * Text alignment for cells in this column.
+     *
+     *
+     * @default "left"
      */
-    type?: "string" | "number";
+    align?: "left" | "right" | "center";
     /**
      * Assigned to the cell's `th` element instead of `td` if true.
      *
@@ -42,8 +40,12 @@ type ColumnDefinition<T> = {
      * Use `sort` and `onSortChange` on the root component to control sort state.
      */
     sortable?: boolean;
+    /**
+     * Additional metadata that can be used for filtering or other purposes. Not used by the table itself.
+     */
+    details?: DetailsT;
 };
-type ColumnDefinitions<T> = ColumnDefinition<T>[];
+type ColumnDefinitions<T, DetailsT = Record<string, any>> = ColumnDefinition<T, DetailsT>[];
 /**
  * A single sort entry representing a column's current sort state.
  * Absent from the `sort` array means the column is unsorted.

package/esm/data/table/root/DataTableRoot.context.d.ts

@@ -9,10 +9,14 @@ type DataTableContextProps<T> = {
     tableId: string;
     showLoadingSkeletons: boolean;
     onRowClick?: (rowId: string | number, event: React.MouseEvent<HTMLTableRowElement>) => void;
-    disableRowSelectionOnClick: boolean;
     isLoading?: boolean;
     showLoadingOverlay: boolean;
     columns: UseColumnOptionsResult<T>["columns"];
+    /**
+     * Used to set exact colspan for detailsPanel, loadingState and emptyState.
+     * This is necessary to ensure that these components span the entire width of the table.
+     */
+    fullWidthColSpan: number;
 };
 declare const DataTableContextProvider: import("react").FC<DataTableContextProps<any> & {
     children: React.ReactNode;

package/esm/data/table/root/DataTableRoot.context.js.map

@@ -1 +1 @@
-{"version":3,"file":"DataTableRoot.context.js","sourceRoot":"","sources":["../../../../src/data/table/root/DataTableRoot.context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAsB7D,MAAM,EAAE,QAAQ,EAAE,wBAAwB,EAAE,UAAU,EAAE,mBAAmB,EAAE,GAC3E,mBAAmB,CAA6B;IAC9C,IAAI,EAAE,kBAAkB;IACxB,YAAY,EAAE,mDAAmD;CAClE,CAAC,CAAC;AAIL,MAAM,EACJ,QAAQ,EAAE,yBAAyB,EACnC,UAAU,EAAE,oBAAoB,GACjC,GAAG,mBAAmB,CAAkC;IACvD,IAAI,EAAE,mBAAmB;IACzB,YAAY,EACV,mIAAmI;CACtI,CAAC,CAAC;AAEH,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,GACrB,CAAC"}
+{"version":3,"file":"DataTableRoot.context.js","sourceRoot":"","sources":["../../../../src/data/table/root/DataTableRoot.context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AA0B7D,MAAM,EAAE,QAAQ,EAAE,wBAAwB,EAAE,UAAU,EAAE,mBAAmB,EAAE,GAC3E,mBAAmB,CAA6B;IAC9C,IAAI,EAAE,kBAAkB;IACxB,YAAY,EAAE,mDAAmD;CAClE,CAAC,CAAC;AAIL,MAAM,EACJ,QAAQ,EAAE,yBAAyB,EACnC,UAAU,EAAE,oBAAoB,GACjC,GAAG,mBAAmB,CAAkC;IACvD,IAAI,EAAE,mBAAmB;IACzB,YAAY,EACV,mIAAmI;CACtI,CAAC,CAAC;AAEH,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,GACrB,CAAC"}

package/esm/data/table/root/DataTableRoot.d.ts

@@ -1,16 +1,12 @@
+/** biome-ignore-all lint/correctness/useHookAtTopLevel: False positive because of the way forwardRef() is added */
 import React from "react";
-import { DataTableCaption, type DataTableCaptionProps } from "../caption/DataTableCaption.js";
-import { DataTableEmptyState, type DataTableEmptyStateProps } from "../empty-state/DataTableEmptyState.js";
+import { type DetailsPanelProps } from "../hooks/useTableDetailsPanel.js";
+import { type SubRowsProps } from "../hooks/useTableItems.js";
 import { type SelectionProps } from "../hooks/useTableSelection.js";
-import { DataTableLoadingState, type DataTableLoadingStateProps } from "../loading-state/DataTableLoadingState.js";
-import { DataTableTbody, type DataTableTbodyProps } from "../tbody/DataTableTbody.js";
-import { DataTableTd, type DataTableTdProps } from "../td/DataTableTd.js";
-import { DataTableTfoot, type DataTableTfootProps } from "../tfoot/DataTableTfoot.js";
-import { DataTableTh, type DataTableThProps } from "../th/DataTableTh.js";
-import { DataTableThead, type DataTableTheadProps } from "../thead/DataTableThead.js";
-import { DataTableTr, type DataTableTrProps } from "../tr/DataTableTr.js";
-interface DataTableProps extends React.HTMLAttributes<HTMLTableElement>, SelectionProps {
-    children: React.ReactNode;
+import { type TableSortOptions } from "../hooks/useTableSort.js";
+import type { ColumnDefinitions } from "./DataTable.types.js";
+interface DataTableProps<T> extends React.HTMLAttributes<HTMLTableElement>, TableSortOptions {
+    children?: never;
     /**
      * Controls vertical cell padding.
      * @default "normal"
@@ -30,7 +26,7 @@ interface DataTableProps extends React.HTMLAttributes<HTMLTableElement>, Selecti
     truncateContent?: boolean;
     /**
      * Enables keyboard navigation for table rows and cells.
-     * @default false
+     * @default true
      */
     withKeyboardNav?: boolean;
     /**
@@ -54,124 +50,92 @@ interface DataTableProps extends React.HTMLAttributes<HTMLTableElement>, Selecti
      * @default "fixed"
      */
     layout?: "fixed" | "auto";
-}
-interface DataTableRootComponent extends React.ForwardRefExoticComponent<DataTableProps & React.RefAttributes<HTMLTableElement>> {
-    /**
-     * @see 🏷️ {@link DataTableCaptionProps}
-     * @example
-     * ```jsx
-     * <DataTable>
-     *   <DataTable.Caption>
-     *     Lorem ipsum
-     *   </DataTable.Caption
-     * </DataTable>
-     * ```
-     */
-    Caption: typeof DataTableCaption;
     /**
-     * @see 🏷️ {@link DataTableTheadProps}
-     * @example
-     * ```jsx
-     * <DataTable>
-     *   <DataTable.Thead>
-     *     ... TODO
-     *   </DataTable.Thead>
-     * </DataTable>
-     * ```
+     * Defines the columns of the table and how to render them.
+     *
+     *
+     * Each column definition should have a unique `id` (or use the column index as fallback) and a `cell`-renderer function that takes the row data as argument and returns a React node.
      */
-    Thead: typeof DataTableThead;
+    columnDefinitions: ColumnDefinitions<T>;
     /**
-     * @see 🏷️ {@link DataTableTbodyProps}
-     * @example
-     * ```jsx
-     * <DataTable>
-     *   <DataTable.Tbody>
-     *     ... TODO
-     *   </DataTable.Tbody>
-     * </DataTable>
-     * ```
+     * The data to display in the table.
+     *
+     *
+     * Each object in the array represents a row, and the properties of the object are used to render the cells based on the `columnDefinitions`.
      */
-    Tbody: typeof DataTableTbody;
+    data: T[];
     /**
-     * @see 🏷️ {@link DataTableTrProps}
-     * @example
-     * ```jsx
-     * <DataTable>
-     *   <DataTable.Tr>
-     *     ... TODO
-     *   </DataTable.Tr
-     * </DataTable>
-     * ```
+     * Function to get unique row id from row data.
+     *
+     *
+     * If not provided, the row index will be used as id. This can cause issues if your data changes dynamically, so it's recommended to provide a stable id if possible.
      */
-    Tr: typeof DataTableTr;
+    getRowId?: (rowData: T, index: number) => string | number;
     /**
-     * @see 🏷️ {@link DataTableThProps}
-     * @example
-     * ```jsx
-     * ```
+     * Sticky columns that remain visible when horizontally scrolling the table.
+     *
+     * You can specify 1 sticky column on the left and 1 on the right.
      */
-    Th: typeof DataTableTh;
+    stickyColumns?: {
+        first?: "1";
+        last?: "1";
+    };
     /**
-     * @see 🏷️ {@link DataTableTdProps}
-     * @example
-     * ```jsx
-     * <DataTable>
-     *   <DataTable.Tbody>
-     *     <DataTable.Td>
-     *       Lorem ipsum
-     *     </DataTable.Td>
-     *     <DataTable.Td>
-     *       Dolor sit amet
-     *     </DataTable.Td>
-     *   </DataTable.Tbody>
-     * </DataTable>
-     * ```
+     * @default true
      */
-    Td: typeof DataTableTd;
+    stickyHeader?: boolean;
     /**
-     * @see 🏷️ {@link DataTableTfootProps}
-     * @example
-     * ```jsx
-     * <DataTable>
-     *   <DataTable.Tfoot>
-     *     ...
-     *   </DataTable.Tfoot>
-     * </DataTable>
-     * ```
+     * Callback invoked when a data row is clicked.
+     * Not called when clicking header, loading, or empty-state rows.
      */
-    Tfoot: typeof DataTableTfoot;
+    onRowClick?: (rowId: string | number, event: React.MouseEvent<HTMLTableRowElement>) => void;
     /**
-     * @see 🏷️ {@link DataTableEmptyStateProps}
-     * @example
-     * ```jsx
-     * <DataTable>
-     *   <DataTable.TBody>
-     *     <DataTable.EmptyState />
-     *   </DataTable.TBody>
-     * </DataTable>
-     * ```
+     * Content to render when `data` is empty.
+     * Rendered inside a `DataTable.EmptyState` row spanning all columns.
      */
-    EmptyState: typeof DataTableEmptyState;
+    emptyState?: React.ReactNode;
+    loading?: {
+        /**
+         * Shows the table in a loading state.
+         *
+         * - When `loadingState` is provided, it is rendered inside a `DataTable.LoadingState` row.
+         * - When `loadingState` is **not** provided, skeleton placeholder rows are rendered instead.
+         * @default false
+         */
+        isLoading?: boolean;
+        /**
+         * Custom content to render when `isLoading` is `true`.
+         * Rendered inside a `DataTable.LoadingState` row spanning all columns.
+         * When omitted, skeleton rows are rendered based on `loadingRows`.
+         */
+        loadingState?: React.ReactNode;
+        /**
+         * Number of skeleton rows to render when `isLoading` is `true` and no `loadingState` is provided.
+         *
+         *
+         * If not provided, the rendered content will get a temporarily overlay while loading
+         */
+        loadingRows?: number;
+        /**
+         * Visually hidden label announced to screen readers when skeleton rows are shown.
+         * Only used when `isLoading` is `true` and no `loadingState` is provided.
+         * @default "Laster innhold"
+         */
+        loadingLabel?: string;
+    };
     /**
-     * @see 🏷️ {@link DataTableEmptyStateProps}
-     * @example
-     * ```jsx
-     * <DataTable>
-     *   <DataTable.TBody>
-     *     <DataTable.LoadingState />
-     *   </DataTable.TBody>
-     * </DataTable>
-     * ```
+     * Function to get sub-rows for a given row, used for nested rows.
+     * When provided, an expand toggle column is added automatically.
+     *
+     *
+     * TODO:
+     * - Table might need to be implemented with role="treegrid" for a11y when having nested rows.
      */
-    LoadingState: typeof DataTableLoadingState;
+    selection?: SelectionProps;
+    subRows?: SubRowsProps<T>;
+    detailsPanel?: DetailsPanelProps<T>;
 }
-/**
- * TODO Component description etc.
- *
- * **NB:** To get sticky headers, you have to set a height restriction on the table container. You can use VStack for this:
- * TODO example
- */
-declare const DataTable: DataTableRootComponent;
-export { DataTable, DataTableCaption, DataTableEmptyState, DataTableLoadingState, DataTableTbody, DataTableTd, DataTableTfoot, DataTableTh, DataTableThead, DataTableTr, };
+declare const DataTable: <T>(props: DataTableProps<T> & React.RefAttributes<HTMLTableElement>) => React.ReactElement | null;
+export { DataTable };
+export type { DataTableProps };
 export default DataTable;
-export type { DataTableCaptionProps, DataTableEmptyStateProps, DataTableLoadingStateProps, DataTableProps, DataTableTbodyProps, DataTableTdProps, DataTableTfootProps, DataTableTheadProps, DataTableThProps, DataTableTrProps, };

package/esm/data/table/root/DataTableRoot.js

@@ -9,52 +9,189 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import React, { forwardRef } from "react";
+/** biome-ignore-all lint/correctness/useHookAtTopLevel: False positive because of the way forwardRef() is added */
+import React, { forwardRef, useCallback, useEffect, useMemo, useRef, useState, } from "react";
+import { Skeleton } from "../../../skeleton/index.js";
 import { useId } from "../../../utils-external/index.js";
+import { Slot } from "../../../utils/components/slot/Slot.js";
 import { cl } from "../../../utils/helpers/index.js";
 import { useMergeRefs } from "../../../utils/hooks/index.js";
-import { DataTableCaption, } from "../caption/DataTableCaption.js";
-import { DataTableEmptyState, } from "../empty-state/DataTableEmptyState.js";
-import { DataTableExpansionProvider } from "../hooks/useTableExpansion.js";
+import { DataTableBaseCell } from "../base-cell/DataTableBaseCell.js";
+import { DataTableColumnHeader } from "../column-header/DataTableColumnHeader.js";
+import { DataTableDetailsPanelRow } from "../details-panel-row/DataTableDetailsPanelRow.js";
+import { DataTableEmptyState } from "../empty-state/DataTableEmptyState.js";
+import { useColumnOptions } from "../hooks/useColumnOptions.js";
+import { DataTableDetailsPanelProvider, } from "../hooks/useTableDetailsPanel.js";
+import { TableItemsProvider, useTableItems, useTableItemsContext, } from "../hooks/useTableItems.js";
 import { useTableKeyboardNav } from "../hooks/useTableKeyboardNav.js";
-import { noSelectionState } from "../hooks/useTableSelection.js";
-import { DataTableLoadingState, } from "../loading-state/DataTableLoadingState.js";
-import { DataTableTbody, } from "../tbody/DataTableTbody.js";
-import { DataTableTd } from "../td/DataTableTd.js";
-import { DataTableTfoot, } from "../tfoot/DataTableTfoot.js";
-import { DataTableTh } from "../th/DataTableTh.js";
-import { DataTableThead, } from "../thead/DataTableThead.js";
+import { useTableSelection, } from "../hooks/useTableSelection.js";
+import { useTableSort } from "../hooks/useTableSort.js";
+import { DataTableLoadingState } from "../loading-state/DataTableLoadingState.js";
+import { DataTableSubRowToggle } from "../sub-row-toggle/DataTableSubRowToggle.js";
+import { DataTableTbody } from "../tbody/DataTableTbody.js";
+import { DataTableThead } from "../thead/DataTableThead.js";
 import { DataTableTr } from "../tr/DataTableTr.js";
-import { DataTableContextProvider } from "./DataTableRoot.context.js";
-const EMPTY_ITEM_DETAILS = new Map();
+import { DataTableContextProvider, useDataTableContext, } from "./DataTableRoot.context.js";
+function DataTableInner(_a, forwardedRef) {
+    var { className, id, rowDensity = "normal", withKeyboardNav = true, zebraStripes = false, truncateContent = true, shouldBlockNavigation, layout = "fixed", selection, data, columnDefinitions, getRowId, stickyColumns, stickyHeader = true, sort: sortProp, defaultSort = [], onSortChange, onRowClick, emptyState, loading, detailsPanel, subRows } = _a, rest = __rest(_a, ["className", "id", "rowDensity", "withKeyboardNav", "zebraStripes", "truncateContent", "shouldBlockNavigation", "layout", "selection", "data", "columnDefinitions", "getRowId", "stickyColumns", "stickyHeader", "sort", "defaultSort", "onSortChange", "onRowClick", "emptyState", "loading", "detailsPanel", "subRows"]);
+    const { sortState, onSortClick } = useTableSort({
+        defaultSort,
+        onSortChange,
+        sort: sortProp,
+    });
+    /**
+     * TODO:
+     * - If user currently does not give a getRowsId function, and data is nested (getSubRows)
+     *   we end up in an infinite loop since the index based ids repeat for children and causes chaos.
+     */
+    const tableItems = useTableItems({
+        items: data,
+        getRowId: getRowId !== null && getRowId !== void 0 ? getRowId : ((_, index) => index),
+        subRows,
+    });
+    const tableSelectionState = useTableSelection({
+        selection,
+        visibleRowIds: tableItems.visibleRowIds,
+        childRowIdsById: tableItems.childRowIdsById,
+    });
+    const { columns, stickySelection } = useColumnOptions(columnDefinitions, {
+        stickyColumns,
+        selectionMode: tableSelectionState.selection.selectionMode,
+    });
+    const { isLoading = false, loadingState, loadingRows, loadingLabel = "Laster innhold", } = loading || {};
+    const fullWidthColSpan = useMemo(() => {
+        return (columns.length +
+            (layout === "fixed" ? 1 : 0) +
+            (tableSelectionState.selection.selectionMode !== "none" ? 1 : 0) +
+            ((detailsPanel === null || detailsPanel === void 0 ? void 0 : detailsPanel.getContent) ? 1 : 0));
+    }, [
+        columns,
+        layout,
+        tableSelectionState.selection.selectionMode,
+        detailsPanel,
+    ]);
+    const tableId = useId(id);
+    return (React.createElement(DataTableContextProvider, { layout: layout, withKeyboardNav: withKeyboardNav, selectionState: tableSelectionState, stickySelection: stickySelection, stickyHeader: stickyHeader, tableId: tableId, showLoadingSkeletons: isLoading && loadingState == null, onRowClick: onRowClick, isLoading: isLoading, showLoadingOverlay: isLoading && !loadingState && !loadingRows, columns: columns, fullWidthColSpan: fullWidthColSpan },
+        React.createElement(TableItemsProvider, { itemDetails: tableItems.itemDetails, items: tableItems.items, onExpandedRowIdsChange: tableItems.onExpandedRowIdsChange, isSubRowExpanded: tableItems.isSubRowExpanded },
+            React.createElement(DataTableDetailsPanelProvider, { detailsPanel: detailsPanel },
+                React.createElement(TableElementWrapper, { shouldBlockNavigation: shouldBlockNavigation, enabled: withKeyboardNav },
+                    React.createElement("table", Object.assign({}, rest, { ref: forwardedRef, className: cl("aksel-data-table", className), "data-zebra-stripes": zebraStripes, "data-truncate-content": truncateContent, "data-density": rowDensity, "data-layout": layout, "data-loading": isLoading || undefined, "aria-busy": isLoading || undefined }),
+                        React.createElement(DataTableThead, null,
+                            React.createElement(DataTableTr, null, columns.map(({ isSticky, colDef }) => {
+                                var _a, _b, _c;
+                                const sortEntry = sortState.find((s) => s.columnId === colDef.id);
+                                const sortDirection = (_a = sortEntry === null || sortEntry === void 0 ? void 0 : sortEntry.direction) !== null && _a !== void 0 ? _a : "none";
+                                return (React.createElement(DataTableColumnHeader, { resizable: colDef.resizable, width: colDef.width, defaultWidth: colDef.defaultWidth, autoWidth: colDef.autoWidth, minWidth: colDef.minWidth, maxWidth: colDef.maxWidth, onWidthChange: colDef.onWidthChange, textAlign: (_b = colDef.align) !== null && _b !== void 0 ? _b : "left", key: colDef.id, isSticky: isSticky, sortable: colDef.sortable, sortDirection: sortDirection, onSortClick: (event) => onSortClick(colDef.id, event), label: colDef.label }, (_c = colDef.header) !== null && _c !== void 0 ? _c : colDef.label));
+                            }))),
+                        React.createElement(DataTableTbody, null,
+                            React.createElement(DataTableTBodyContent, { loadingState: loadingState, loadingRows: loadingRows, loadingLabel: loadingLabel, emptyState: emptyState }))))))));
+}
 /**
- * TODO Component description etc.
- *
- * **NB:** To get sticky headers, you have to set a height restriction on the table container. You can use VStack for this:
- * TODO example
+ * Temp optimization to avoid re-renders on every keyboard-move, selection change etc
  */
-const DataTable = forwardRef((_a, forwardedRef) => {
-    var { className, rowDensity = "normal", withKeyboardNav = false, zebraStripes = false, truncateContent = true, shouldBlockNavigation, layout = "fixed" } = _a, rest = __rest(_a, ["className", "rowDensity", "withKeyboardNav", "zebraStripes", "truncateContent", "shouldBlockNavigation", "layout"]);
+function TableElementWrapper({ children, enabled, shouldBlockNavigation, }) {
+    const [applyStickyStyles, setApplyStickyStyles] = useState(false);
+    const tableWrapperRef = useRef(null);
+    const tableRef = useRef(null);
+    const rafRef = useRef(null);
     const { tabIndex, setTableRef } = useTableKeyboardNav({
-        enabled: withKeyboardNav,
+        enabled,
         shouldBlockNavigation,
     });
-    const mergedRef = useMergeRefs(forwardedRef, setTableRef);
-    return (React.createElement(DataTableContextProvider, { layout: layout, withKeyboardNav: withKeyboardNav, selectionState: noSelectionState, stickySelection: false, stickyHeader: false, tableId: useId(), showLoadingSkeletons: false, onRowClick: undefined, disableRowSelectionOnClick: false, showLoadingOverlay: false, columns: [] },
-        React.createElement(DataTableExpansionProvider, { itemDetails: EMPTY_ITEM_DETAILS },
-            React.createElement("div", { className: "aksel-data-table__border-wrapper" },
-                React.createElement("div", { className: "aksel-data-table__scroll-wrapper" },
-                    React.createElement("table", Object.assign({}, rest, { ref: mergedRef, className: cl("aksel-data-table", className), "data-zebra-stripes": zebraStripes, "data-truncate-content": truncateContent, "data-density": rowDensity, "data-layout": layout, tabIndex: tabIndex })))))));
-});
-DataTable.Caption = DataTableCaption;
-DataTable.Thead = DataTableThead;
-DataTable.Tbody = DataTableTbody;
-DataTable.Th = DataTableTh;
-DataTable.Tr = DataTableTr;
-DataTable.Td = DataTableTd;
-DataTable.Tfoot = DataTableTfoot;
-DataTable.EmptyState = DataTableEmptyState;
-DataTable.LoadingState = DataTableLoadingState;
-export { DataTable, DataTableCaption, DataTableEmptyState, DataTableLoadingState, DataTableTbody, DataTableTd, DataTableTfoot, DataTableTh, DataTableThead, DataTableTr, };
+    const mergedTableRefs = useMergeRefs(tableRef, setTableRef);
+    const updateStickyStyles = useCallback(() => {
+        if (!tableWrapperRef.current) {
+            return;
+        }
+        const doesWrapperHasScroll = tableWrapperRef.current.scrollWidth > tableWrapperRef.current.clientWidth;
+        setApplyStickyStyles(doesWrapperHasScroll);
+    }, []);
+    const scheduleStickyStylesUpdate = useCallback(() => {
+        if (rafRef.current !== null) {
+            return;
+        }
+        rafRef.current = requestAnimationFrame(() => {
+            rafRef.current = null;
+            updateStickyStyles();
+        });
+    }, [updateStickyStyles]);
+    useEffect(() => {
+        const tableWrapperElement = tableWrapperRef.current;
+        if (!tableWrapperElement) {
+            return;
+        }
+        const handleResize = () => scheduleStickyStylesUpdate();
+        window.addEventListener("resize", handleResize);
+        let resizeObserver;
+        if (typeof ResizeObserver !== "undefined") {
+            resizeObserver = new ResizeObserver(handleResize);
+            resizeObserver.observe(tableWrapperElement);
+            if (tableRef.current) {
+                resizeObserver.observe(tableRef.current);
+            }
+        }
+        scheduleStickyStylesUpdate();
+        return () => {
+            window.removeEventListener("resize", handleResize);
+            resizeObserver === null || resizeObserver === void 0 ? void 0 : resizeObserver.disconnect();
+            if (rafRef.current !== null) {
+                cancelAnimationFrame(rafRef.current);
+                rafRef.current = null;
+            }
+        };
+    }, [scheduleStickyStylesUpdate]);
+    return (React.createElement("div", { className: "aksel-data-table__border-wrapper" },
+        React.createElement("div", { ref: tableWrapperRef, className: "aksel-data-table__scroll-wrapper" },
+            React.createElement(Slot, { tabIndex: tabIndex, 
+                /* @ts-expect-error Ref is not typed correctly to handle this case */
+                ref: mergedTableRefs, "data-scroll": applyStickyStyles ? "true" : undefined }, children))));
+}
+function DataTableTBodyContent({ loadingState, loadingRows, loadingLabel, emptyState, }) {
+    const { items, itemDetails } = useTableItemsContext();
+    const { columns, isLoading, fullWidthColSpan } = useDataTableContext();
+    if (isLoading && loadingState != null) {
+        return (React.createElement(DataTableLoadingState, { colSpan: fullWidthColSpan }, loadingState));
+    }
+    if (isLoading && loadingRows) {
+        return (React.createElement(React.Fragment, null,
+            React.createElement("tr", null,
+                React.createElement("td", { colSpan: fullWidthColSpan, className: "aksel-sr-only" }, loadingLabel)),
+            Array.from({ length: loadingRows }, (_, rowIndex) => (React.createElement(DataTableTr, { key: `skeleton-row-${rowIndex}`, "aria-hidden": true }, columns.map(({ isSticky, colDef }, colDefIndex) => {
+                var _a;
+                return (React.createElement(DataTableBaseCell, { textAlign: (_a = colDef.align) !== null && _a !== void 0 ? _a : "left", key: colDef.id || colDefIndex, as: colDef.isRowHeader ? "th" : "td", isSticky: isSticky },
+                    React.createElement(Skeleton, { variant: "text" })));
+            }))))));
+    }
+    if (items.length === 0 && emptyState !== undefined) {
+        return (React.createElement(DataTableEmptyState, { colSpan: fullWidthColSpan }, emptyState));
+    }
+    const renderLoadingAnnouncement = isLoading && !loadingState && !loadingRows;
+    return (React.createElement(React.Fragment, null,
+        renderLoadingAnnouncement && (React.createElement("tr", null,
+            React.createElement("td", { colSpan: fullWidthColSpan, className: "aksel-sr-only" }, loadingLabel))),
+        items.map((rowData) => {
+            const details = itemDetails.get(rowData);
+            /* Should in theory be impossible. Look about typing this? */
+            if (!details) {
+                return null;
+            }
+            const hasSubRows = details.children.length > 0;
+            return (React.createElement(React.Fragment, { key: details.id },
+                React.createElement(DataTableTr, { rowId: details.id }, columns.map(({ isSticky, colDef }, colDefIndex) => {
+                    var _a;
+                    const renderNestedToggle = colDefIndex === 0 && hasSubRows;
+                    const renderNestedIndent = colDefIndex === 0 && (details.level > 0 || hasSubRows);
+                    const style = {
+                        "--__axc-data-table-nested-depth": details.level,
+                    };
+                    return (React.createElement(DataTableBaseCell, { textAlign: (_a = colDef.align) !== null && _a !== void 0 ? _a : "left", key: colDef.id || colDefIndex, as: colDef.isRowHeader ? "th" : "td", isSticky: isSticky, "data-nested": renderNestedIndent || undefined, style: style },
+                        renderNestedToggle && (React.createElement(DataTableSubRowToggle, { details: details })),
+                        colDef.cell(rowData)));
+                })),
+                React.createElement(DataTableDetailsPanelRow, { rowId: details.id, rowData: rowData })));
+        })));
+}
+const DataTable = forwardRef(DataTableInner);
+export { DataTable };
 export default DataTable;
 //# sourceMappingURL=DataTableRoot.js.map