@nova-design-system/nova-react 3.27.0 → 3.28.0

package/dist/cjs/{nv-togglebuttongroup.entry-TizvIVlB.js → nv-togglebuttongroup.entry-L8gitSUS.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-clzdrCkN.js');
+var index = require('./index-Kxp9mv-Q.js');
 require('@stencil/react-output-target/runtime');
 require('react');
 require('react-dom');
@@ -156,7 +156,7 @@ const NvTogglebuttongroup = class {
     /****************************************************************************/
     //#region RENDER
     render() {
-        return (index.h(index.Host, { key: '93a5693197f8b41b18ecef0132168e7f209ec86a' }, index.h("slot", { key: '3085cde261575115286c295eb416063ef14a7bf2' })));
+        return (index.h(index.Host, { key: '2026cb95db8b57f2a1cd4ea53608f336843b63fe' }, index.h("slot", { key: '5c06ab59d6c99e789c3a1c3a8a4842a0772ca3a2' })));
     }
     get el() { return index.getElement(this); }
     static get watchers() { return {

package/dist/cjs/{nv-tooltip.entry-0kcGcQZo.js → nv-tooltip.entry-BElnrEqE.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-clzdrCkN.js');
+var index = require('./index-Kxp9mv-Q.js');
 require('@stencil/react-output-target/runtime');
 require('react');
 require('react-dom');
@@ -39,15 +39,20 @@ const NvTooltip = class {
     /****************************************************************************/
     //#region LIFECYCLE
     componentDidRender() {
-        if (this.triggerElement || !this.defaultSlot)
+        if (!this.popoverElement)
             return;
-        this.popoverElement.triggerElement = this.defaultSlot?.nextSibling;
+        const trigger = this.triggerElement ??
+            this.defaultSlot?.nextElementSibling ??
+            this.el.querySelector(':scope > :not(nv-popover):not(slot):not([slot])');
+        if (trigger && this.popoverElement.triggerElement !== trigger) {
+            this.popoverElement.triggerElement = trigger;
+        }
     }
     //#endregion LIFECYCLE
     /****************************************************************************/
     //#region RENDER
     render() {
-        return (index.h(index.Host, { key: 'f01e67c6f67c35beba40681c4bcd109886bbdbcf' }, index.h("nv-popover", { key: '47cd75161715752aeeae29223606e21c617a271a', ref: el => (this.popoverElement = el), triggerMode: "hover", hasArrow: true, placement: this.placement, strategy: this.strategy, triggerElement: this.triggerElement, groupName: 'tooltip', enterDelay: this.enterDelay, onOpenChanged: e => this.openChanged.emit(e.detail) }, index.h("p", { key: 'fe5b09a6c0e4a67a50c9f43cb8344cee68e197f5', slot: "content" }, this.message), index.h("slot", { key: '4ef23e294baa1d5e60236ffec4a26439610030c1', name: "content" })), index.h("slot", { key: '5d8486923cd7cf99da69f4fa4d319dd5b5999cfa', ref: el => (this.defaultSlot = el) })));
+        return (index.h(index.Host, { key: '8285fbb412cb45cc7baf2936f0405c0438395c8d' }, index.h("nv-popover", { key: '29d70e9baa826de35d2cdca88f48610d70ec55e4', ref: el => (this.popoverElement = el), triggerMode: "hover", hasArrow: true, placement: this.placement, strategy: this.strategy, groupName: 'tooltip', enterDelay: this.enterDelay, onOpenChanged: e => this.openChanged.emit(e.detail) }, index.h("p", { key: 'a9c907fa96f9c4108a8d84cec53981218c060811', slot: "content" }, this.message), index.h("slot", { key: 'af1b7ac8069071fe2d41e925f1c0090f8b6aaab5', name: "content" })), index.h("slot", { key: 'e5d3c6d16fb7e4a682b66e0016d9e4e30e5647e0', ref: el => (this.defaultSlot = el) })));
     }
     get el() { return index.getElement(this); }
 };

package/dist/components/NvDatatable/NvDatatable.js

@@ -1,12 +1,25 @@
 import React, { useMemo, useState, useEffect, useRef, useCallback, } from 'react';
 import { flexRender, getCoreRowModel, getPaginationRowModel, getSortedRowModel, getFilteredRowModel, useReactTable, } from '@tanstack/react-table';
-import { NvTable, NvTableheader, NvPaginationtable, } from '../../generated/components';
+import { NvTable, NvTableheader, NvPaginationtable, NvFieldcheckbox, } from '../../generated/components';
 import { defineCustomElement as defineNvPaginationtable } from '@nova-design-system/nova-webcomponents/dist/components/nv-paginationtable.js';
 if (typeof window !== 'undefined' &&
     !customElements.get('nv-paginationtable')) {
     defineNvPaginationtable();
 }
-function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filtering, renderPagination, renderFiltering, stickyHeader, ...htmlProps }) {
+import { applyRowSelection, applySelectAllSelection, shouldIgnoreSelectAllEvent, } from './selectionState';
+function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filtering, selection, renderPagination, renderFiltering, stickyHeader, ...htmlProps }) {
+    const SELECTION_EVENT_SUPPRESSION_MS = 16;
+    const areSetsEqual = useCallback((a, b) => {
+        if (a.size !== b.size) {
+            return false;
+        }
+        for (const value of a) {
+            if (!b.has(value)) {
+                return false;
+            }
+        }
+        return true;
+    }, []);
     const isInfiniteScroll = pagination?.infinite && mode === 'server';
     const [paginationState, setPaginationState] = useState({
         pageIndex: 0,
@@ -14,7 +27,14 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
     });
     const [sortingState, setSortingState] = useState(sorting?.sortState || []);
     const [globalFilterState, setGlobalFilterState] = useState(filtering?.filterState);
+    const [selectedRowIdsState, setSelectedRowIdsState] = useState(() => new Set(selection?.selectedRowIds ?? []));
+    const selectedRowIdsRef = useRef(new Set(selection?.selectedRowIds ?? []));
+    const selectionMode = selection?.mode ?? 'none';
+    const selectionEnabled = selectionMode !== 'none';
+    const selectAllEnabled = selection?.enableSelectAll ?? true;
+    const getSelectionRowId = useCallback((row) => selection?.getRowId?.(row) ?? '', [selection]);
     const lastRowRef = useRef(null);
+    const suppressRowSelectionEventsRef = useRef(false);
     const debouncedSetFilter = useRef(null);
     const setGlobalFilterDebounced = useCallback((value) => {
         const debounceMs = filtering?.debounceMs ?? 300;
@@ -40,60 +60,89 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
             setGlobalFilterState(filtering.filterState);
         }
     }, [filtering?.filterState]);
-    const tableColumns = useMemo(() => columns
-        .filter((col) => !col.hidden)
-        .map((col) => {
-        const headerName = col.headerName || String(col.field);
-        const columnDef = {
-            accessorKey: col.field,
-            accessorFn: col.valueFormatter
-                ? (row) => {
-                    const rawValue = row[col.field];
-                    return col.valueFormatter({
-                        value: rawValue,
-                        row,
-                        field: col.field,
-                    });
-                }
-                : undefined,
-            header: col.renderHeader
-                ? () => col.renderHeader({
-                    headerName,
-                    field: col.field,
-                })
-                : headerName,
-            size: col.width,
-            enableResizing: col.resizable ?? true,
-            enableSorting: sorting ? col.sortable ?? true : false,
-            cell: (context) => {
-                const value = context.getValue();
-                const row = context.row.original;
-                const rowIndex = context.row.index;
-                if (col.renderCell) {
-                    return col.renderCell({
-                        value,
-                        row,
-                        field: col.field,
-                        rowIndex,
-                    });
-                }
-                return value;
-            },
-        };
-        if (col.sortingFn !== undefined) {
-            columnDef.sortingFn = col.sortingFn;
-        }
-        if (col.sortDescFirst !== undefined) {
-            columnDef.sortDescFirst = col.sortDescFirst;
-        }
-        if (col.invertSorting !== undefined) {
-            columnDef.invertSorting = col.invertSorting;
+    if (selectionEnabled && !selection?.getRowId) {
+        throw new Error('NvDatatable selection requires selection.getRowId when selection.mode is not "none".');
+    }
+    useEffect(() => {
+        if (selection?.selectedRowIds) {
+            const controlledIds = new Set(selection.selectedRowIds);
+            if (!areSetsEqual(selectedRowIdsState, controlledIds)) {
+                selectedRowIdsRef.current = controlledIds;
+                setSelectedRowIdsState(controlledIds);
+            }
         }
-        if (col.sortUndefined !== undefined) {
-            columnDef.sortUndefined = col.sortUndefined;
+    }, [selection?.selectedRowIds, selectedRowIdsState, areSetsEqual]);
+    useEffect(() => {
+        selectedRowIdsRef.current = selectedRowIdsState;
+    }, [selectedRowIdsState]);
+    const tableColumns = useMemo(() => {
+        const dataColumns = columns
+            .filter((col) => !col.hidden)
+            .map((col) => {
+            const headerName = col.headerName || String(col.field);
+            const columnDef = {
+                accessorKey: col.field,
+                accessorFn: col.valueFormatter
+                    ? (row) => {
+                        const rawValue = row[col.field];
+                        return col.valueFormatter({
+                            value: rawValue,
+                            row,
+                            field: col.field,
+                        });
+                    }
+                    : undefined,
+                header: col.renderHeader
+                    ? () => col.renderHeader({
+                        headerName,
+                        field: col.field,
+                    })
+                    : headerName,
+                size: col.width,
+                enableResizing: col.resizable ?? true,
+                enableSorting: sorting ? col.sortable ?? true : false,
+                cell: (context) => {
+                    const value = context.getValue();
+                    const row = context.row.original;
+                    const rowIndex = context.row.index;
+                    if (col.renderCell) {
+                        return col.renderCell({
+                            value,
+                            row,
+                            field: col.field,
+                            rowIndex,
+                        });
+                    }
+                    return value;
+                },
+            };
+            if (col.sortingFn !== undefined) {
+                columnDef.sortingFn = col.sortingFn;
+            }
+            if (col.sortDescFirst !== undefined) {
+                columnDef.sortDescFirst = col.sortDescFirst;
+            }
+            if (col.invertSorting !== undefined) {
+                columnDef.invertSorting = col.invertSorting;
+            }
+            if (col.sortUndefined !== undefined) {
+                columnDef.sortUndefined = col.sortUndefined;
+            }
+            return columnDef;
+        });
+        if (!selectionEnabled) {
+            return dataColumns;
         }
-        return columnDef;
-    }), [columns, sorting]);
+        const selectionColumn = {
+            id: '__selection__',
+            header: '',
+            size: selection?.checkboxColumnWidth ?? 48,
+            enableResizing: false,
+            enableSorting: false,
+            cell: () => null,
+        };
+        return [selectionColumn, ...dataColumns];
+    }, [columns, sorting, selectionEnabled, selection?.checkboxColumnWidth]);
     const tableConfig = useMemo(() => {
         const baseConfig = {
             data: rows,
@@ -187,6 +236,169 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
         mode,
     ]);
     const table = useReactTable(tableConfig);
+    const tableRows = table.getRowModel().rows;
+    const setSelectionState = useCallback((nextSelectedIds) => {
+        const current = new Set(selection?.selectedRowIds ?? selectedRowIdsRef.current);
+        const nextRaw = typeof nextSelectedIds === 'function'
+            ? nextSelectedIds(new Set(current))
+            : nextSelectedIds;
+        const next = new Set(nextRaw);
+        if (areSetsEqual(current, next)) {
+            return;
+        }
+        selectedRowIdsRef.current = next;
+        setSelectedRowIdsState(next);
+        selection?.onSelectionChange?.(new Set(next));
+    }, [selection, selection?.selectedRowIds, areSetsEqual]);
+    const resolveCheckedChange = useCallback((event) => {
+        if (event && typeof event === 'object') {
+            const eventLike = event;
+            const target = eventLike.target;
+            const currentTarget = eventLike.currentTarget;
+            if (typeof eventLike.detail === 'boolean') {
+                return eventLike.detail;
+            }
+            if (typeof target?.checked === 'boolean') {
+                return target.checked;
+            }
+            if (typeof currentTarget?.checked === 'boolean') {
+                return currentTarget.checked;
+            }
+        }
+        return undefined;
+    }, []);
+    const isRowSelected = useCallback((row) => {
+        if (!selectionEnabled) {
+            return false;
+        }
+        const rowId = getSelectionRowId(row);
+        return !!rowId && selectedRowIdsState.has(rowId);
+    }, [selectionEnabled, getSelectionRowId, selectedRowIdsState]);
+    const visibleRowIds = useMemo(() => tableRows
+        .map((row) => getSelectionRowId(row.original))
+        .filter((id) => !!id), [tableRows, getSelectionRowId]);
+    const visibleRowIdsSet = useMemo(() => new Set(visibleRowIds), [visibleRowIds]);
+    const setRowSelection = useCallback((row, isChecked) => {
+        if (!selectionEnabled) {
+            return;
+        }
+        if (suppressRowSelectionEventsRef.current) {
+            return;
+        }
+        const rowId = getSelectionRowId(row);
+        if (!rowId) {
+            return;
+        }
+        if (!visibleRowIdsSet.has(rowId)) {
+            return;
+        }
+        suppressRowSelectionEventsRef.current = true;
+        setSelectionState((current) => {
+            return applyRowSelection({
+                currentSelectedIds: current,
+                rowId,
+                isChecked,
+                selectionMode,
+            });
+        });
+        setTimeout(() => {
+            suppressRowSelectionEventsRef.current = false;
+        }, SELECTION_EVENT_SUPPRESSION_MS);
+    }, [
+        selectionEnabled,
+        getSelectionRowId,
+        visibleRowIdsSet,
+        selectionMode,
+        setSelectionState,
+    ]);
+    const selectAllState = useMemo(() => {
+        if (!selectionEnabled ||
+            selectionMode !== 'multiple' ||
+            !selectAllEnabled ||
+            !visibleRowIds.length) {
+            return 'unchecked';
+        }
+        const selectedCount = visibleRowIds.filter((id) => selectedRowIdsState.has(id)).length;
+        if (selectedCount === 0) {
+            return 'unchecked';
+        }
+        if (selectedCount === visibleRowIds.length) {
+            return 'checked';
+        }
+        return 'indeterminate';
+    }, [
+        selectionEnabled,
+        selectionMode,
+        selectAllEnabled,
+        visibleRowIds,
+        selectedRowIdsState,
+    ]);
+    const handleSelectAllChanged = useCallback((isChecked) => {
+        if (!selectionEnabled ||
+            selectionMode !== 'multiple' ||
+            !selectAllEnabled ||
+            !visibleRowIds.length) {
+            return;
+        }
+        if (shouldIgnoreSelectAllEvent({ isChecked, selectAllState })) {
+            return;
+        }
+        suppressRowSelectionEventsRef.current = true;
+        setSelectionState((current) => {
+            return applySelectAllSelection({
+                currentSelectedIds: current,
+                visibleRowIds,
+                isChecked,
+            });
+        });
+        setTimeout(() => {
+            suppressRowSelectionEventsRef.current = false;
+        }, SELECTION_EVENT_SUPPRESSION_MS);
+    }, [
+        selectionEnabled,
+        selectionMode,
+        selectAllEnabled,
+        visibleRowIds,
+        selectAllState,
+        setSelectionState,
+    ]);
+    useEffect(() => {
+        if (!selectionEnabled || selection?.deselectOnFilter === false) {
+            return;
+        }
+        if (mode !== 'client' || !filtering) {
+            return;
+        }
+        const filterVisibleRows = table
+            .getFilteredRowModel()
+            .rows.map((row) => row.original);
+        const visibleIds = new Set(filterVisibleRows
+            .map((row) => getSelectionRowId(row))
+            .filter((id) => !!id));
+        const currentSelection = selection?.selectedRowIds ?? selectedRowIdsState;
+        const next = new Set();
+        currentSelection.forEach((id) => {
+            if (visibleIds.has(id)) {
+                next.add(id);
+            }
+        });
+        if (!areSetsEqual(currentSelection, next)) {
+            setSelectedRowIdsState(next);
+            selection?.onSelectionChange?.(new Set(next));
+        }
+    }, [
+        areSetsEqual,
+        selectionEnabled,
+        selection?.deselectOnFilter,
+        selection?.onSelectionChange,
+        selection?.selectedRowIds,
+        mode,
+        filtering,
+        globalFilterState,
+        table,
+        selectedRowIdsState,
+        getSelectionRowId,
+    ]);
     useEffect(() => {
         if (mode === 'server' &&
             !pagination?.infinite &&
@@ -253,7 +465,6 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
         mode,
         isInfiniteScroll,
     ]);
-    const tableRows = table.getRowModel().rows;
     const renderDefaultPagination = (api) => {
         const labelProps = {};
         if (pagination?.labels?.page)
@@ -289,20 +500,39 @@ function NvDatatable({ mode = 'client', columns, rows, pagination, sorting, filt
         React.createElement(NvTable, { ...htmlProps },
             React.createElement("table", null,
                 React.createElement("thead", { "data-sticky-top": stickyHeader ? 'true' : undefined }, table.getHeaderGroups().map((headerGroup) => (React.createElement("tr", { key: headerGroup.id }, headerGroup.headers.map((header) => {
+                    const isSelectionHeader = header.id === '__selection__';
                     const canSort = header.column.getCanSort();
                     const sortDirection = header.column.getIsSorted();
-                    return (React.createElement("th", { key: header.id, "data-testid": `datatable-header-${header.id}`, style: {
+                    return (React.createElement("th", { key: header.id, "data-testid": isSelectionHeader
+                            ? 'datatable-header-selection'
+                            : `datatable-header-${header.id}`, style: {
                             width: header.column.columnDef.size + 'px',
-                        }, "data-no-resize": header.column.columnDef.enableResizing ? null : true },
-                        React.createElement(NvTableheader, { sortable: canSort ? true : undefined, sortDirection: sortDirection || (canSort ? 'none' : undefined), onSortDirectionChanged: canSort
-                                ? header.column.getToggleSortingHandler()
-                                : undefined }, header.isPlaceholder
-                            ? null
-                            : flexRender(header.column.columnDef.header, header.getContext()))));
+                        }, "data-no-resize": isSelectionHeader
+                            ? true
+                            : header.column.columnDef.enableResizing
+                                ? null
+                                : true }, isSelectionHeader ? (selectionMode === 'multiple' && selectAllEnabled ? (React.createElement("div", { className: "flex items-center justify-center" },
+                        React.createElement(NvFieldcheckbox, { "data-testid": "datatable-select-all-checkbox", checked: selectAllState === 'checked', indeterminate: selectAllState === 'indeterminate', label: "Select all rows", hideLabel: true, onCheckedChanged: (event) => {
+                                const checked = resolveCheckedChange(event);
+                                if (typeof checked === 'boolean') {
+                                    handleSelectAllChanged(checked);
+                                }
+                            } }))) : null) : (React.createElement(NvTableheader, { sortable: canSort ? true : undefined, sortDirection: sortDirection || (canSort ? 'none' : undefined), onSortDirectionChanged: canSort
+                            ? header.column.getToggleSortingHandler()
+                            : undefined }, header.isPlaceholder
+                        ? null
+                        : flexRender(header.column.columnDef.header, header.getContext())))));
                 }))))),
                 React.createElement("tbody", null, tableRows.map((row, index) => {
                     const isLastRow = isInfiniteScroll && index === tableRows.length - 1;
-                    return (React.createElement("tr", { key: row.id, "data-testid": `datatable-row-${index}`, ref: isLastRow ? lastRowRef : undefined }, row.getVisibleCells().map((cell) => (React.createElement("td", { key: cell.id, "data-testid": `datatable-cell-${cell.column.id}` }, flexRender(cell.column.columnDef.cell, cell.getContext()))))));
+                    return (React.createElement("tr", { key: row.id, "data-testid": `datatable-row-${index}`, ref: isLastRow ? lastRowRef : undefined }, row.getVisibleCells().map((cell) => (React.createElement("td", { key: cell.id, "data-testid": cell.column.id === '__selection__'
+                            ? 'datatable-cell-selection'
+                            : `datatable-cell-${cell.column.id}` }, cell.column.id === '__selection__' ? (React.createElement(NvFieldcheckbox, { "data-testid": `datatable-row-${index}-checkbox`, checked: isRowSelected(row.original), label: `Select row ${index + 1}`, hideLabel: true, onCheckedChanged: (event) => {
+                            const checked = resolveCheckedChange(event);
+                            if (typeof checked === 'boolean') {
+                                setRowSelection(row.original, checked);
+                            }
+                        } })) : (flexRender(cell.column.columnDef.cell, cell.getContext())))))));
                 })))),
         paginationAPI &&
             (renderPagination

package/dist/components/NvDatatable/selectionState.js

@@ -0,0 +1,45 @@
+export function applyRowSelection(params) {
+    const { currentSelectedIds, rowId, isChecked, selectionMode } = params;
+    const next = new Set(currentSelectedIds);
+    const currentlySelected = next.has(rowId);
+    if (selectionMode === 'single') {
+        if (isChecked) {
+            if (!(next.size === 1 && currentlySelected)) {
+                next.clear();
+                next.add(rowId);
+            }
+        }
+        else if (currentlySelected) {
+            next.delete(rowId);
+        }
+        return next;
+    }
+    if (selectionMode === 'multiple') {
+        if (isChecked && !currentlySelected) {
+            next.add(rowId);
+        }
+        else if (!isChecked && currentlySelected) {
+            next.delete(rowId);
+        }
+    }
+    return next;
+}
+export function shouldIgnoreSelectAllEvent(params) {
+    const { isChecked, selectAllState } = params;
+    if ((isChecked && selectAllState === 'checked') ||
+        (!isChecked && selectAllState === 'unchecked')) {
+        return true;
+    }
+    return !isChecked && selectAllState === 'indeterminate';
+}
+export function applySelectAllSelection(params) {
+    const { currentSelectedIds, visibleRowIds, isChecked } = params;
+    const next = new Set(currentSelectedIds);
+    if (isChecked) {
+        visibleRowIds.forEach((id) => next.add(id));
+    }
+    else {
+        visibleRowIds.forEach((id) => next.delete(id));
+    }
+    return next;
+}

package/dist/components/NvDatatable/selectionState.test.js

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest';
+import { applyRowSelection, applySelectAllSelection, shouldIgnoreSelectAllEvent, } from './selectionState';
+describe('selectionState', () => {
+    it('single row selection replaces existing selection', () => {
+        const selected = new Set(['1']);
+        const next = applyRowSelection({
+            currentSelectedIds: selected,
+            rowId: '2',
+            isChecked: true,
+            selectionMode: 'single',
+        });
+        expect(Array.from(next)).toEqual(['2']);
+    });
+    it('single row uncheck removes currently selected row', () => {
+        const selected = new Set(['2']);
+        const next = applyRowSelection({
+            currentSelectedIds: selected,
+            rowId: '2',
+            isChecked: false,
+            selectionMode: 'single',
+        });
+        expect(Array.from(next)).toEqual([]);
+    });
+    it('multiple row selection toggles add/remove correctly', () => {
+        const selected = new Set(['1']);
+        const afterAdd = applyRowSelection({
+            currentSelectedIds: selected,
+            rowId: '2',
+            isChecked: true,
+            selectionMode: 'multiple',
+        });
+        const afterRemove = applyRowSelection({
+            currentSelectedIds: afterAdd,
+            rowId: '1',
+            isChecked: false,
+            selectionMode: 'multiple',
+        });
+        expect(Array.from(afterAdd).sort((a, b) => a.localeCompare(b))).toEqual([
+            '1',
+            '2',
+        ]);
+        expect(Array.from(afterRemove)).toEqual(['2']);
+    });
+    it('ignores synthetic select-all events for checked/unchecked/indeterminate noise', () => {
+        expect(shouldIgnoreSelectAllEvent({
+            isChecked: true,
+            selectAllState: 'checked',
+        })).toBe(true);
+        expect(shouldIgnoreSelectAllEvent({
+            isChecked: false,
+            selectAllState: 'unchecked',
+        })).toBe(true);
+        expect(shouldIgnoreSelectAllEvent({
+            isChecked: false,
+            selectAllState: 'indeterminate',
+        })).toBe(true);
+    });
+    it('select-all then deselect-all clears visible rows', () => {
+        const selected = new Set(['1']);
+        const visibleRowIds = ['1', '2'];
+        const afterSelectAll = applySelectAllSelection({
+            currentSelectedIds: selected,
+            visibleRowIds,
+            isChecked: true,
+        });
+        const afterDeselectAll = applySelectAllSelection({
+            currentSelectedIds: afterSelectAll,
+            visibleRowIds,
+            isChecked: false,
+        });
+        expect(Array.from(afterSelectAll).sort((a, b) => a.localeCompare(b))).toEqual(['1', '2']);
+        expect(Array.from(afterDeselectAll)).toEqual([]);
+    });
+});

package/dist/generated/components.js

@@ -12,6 +12,8 @@ import { NvCalendar as NvCalendarElement, defineCustomElement as defineNvCalenda
 import { NvCol as NvColElement, defineCustomElement as defineNvCol } from "@nova-design-system/nova-webcomponents/dist/components/nv-col.js";
 import { NvDatagrid as NvDatagridElement, defineCustomElement as defineNvDatagrid } from "@nova-design-system/nova-webcomponents/dist/components/nv-datagrid.js";
 import { NvDatagridcolumn as NvDatagridcolumnElement, defineCustomElement as defineNvDatagridcolumn } from "@nova-design-system/nova-webcomponents/dist/components/nv-datagridcolumn.js";
+import { NvDatetest as NvDatetestElement, defineCustomElement as defineNvDatetest } from "@nova-design-system/nova-webcomponents/dist/components/nv-datetest.js";
+import { NvDatetimetest as NvDatetimetestElement, defineCustomElement as defineNvDatetimetest } from "@nova-design-system/nova-webcomponents/dist/components/nv-datetimetest.js";
 import { NvDialog as NvDialogElement, defineCustomElement as defineNvDialog } from "@nova-design-system/nova-webcomponents/dist/components/nv-dialog.js";
 import { NvDialogfooter as NvDialogfooterElement, defineCustomElement as defineNvDialogfooter } from "@nova-design-system/nova-webcomponents/dist/components/nv-dialogfooter.js";
 import { NvDialogheader as NvDialogheaderElement, defineCustomElement as defineNvDialogheader } from "@nova-design-system/nova-webcomponents/dist/components/nv-dialogheader.js";
@@ -58,6 +60,7 @@ import { NvSplit as NvSplitElement, defineCustomElement as defineNvSplit } from
 import { NvStack as NvStackElement, defineCustomElement as defineNvStack } from "@nova-design-system/nova-webcomponents/dist/components/nv-stack.js";
 import { NvTable as NvTableElement, defineCustomElement as defineNvTable } from "@nova-design-system/nova-webcomponents/dist/components/nv-table.js";
 import { NvTableheader as NvTableheaderElement, defineCustomElement as defineNvTableheader } from "@nova-design-system/nova-webcomponents/dist/components/nv-tableheader.js";
+import { NvTimetest as NvTimetestElement, defineCustomElement as defineNvTimetest } from "@nova-design-system/nova-webcomponents/dist/components/nv-timetest.js";
 import { NvToggle as NvToggleElement, defineCustomElement as defineNvToggle } from "@nova-design-system/nova-webcomponents/dist/components/nv-toggle.js";
 import { NvTogglebutton as NvTogglebuttonElement, defineCustomElement as defineNvTogglebutton } from "@nova-design-system/nova-webcomponents/dist/components/nv-togglebutton.js";
 import { NvTogglebuttongroup as NvTogglebuttongroupElement, defineCustomElement as defineNvTogglebuttongroup } from "@nova-design-system/nova-webcomponents/dist/components/nv-togglebuttongroup.js";
@@ -171,6 +174,29 @@ export const NvDatagridcolumn = createComponent({
     events: {},
     defineCustomElement: defineNvDatagridcolumn
 });
+export const NvDatetest = createComponent({
+    tagName: 'nv-datetest',
+    elementClass: NvDatetestElement,
+    react: React,
+    events: {
+        onValueChanged: 'valueChanged',
+        onLastChanged: 'lastChanged',
+        onHistoryChanged: 'historyChanged',
+        onValueDateChanged: 'valueDateChanged'
+    },
+    defineCustomElement: defineNvDatetest
+});
+export const NvDatetimetest = createComponent({
+    tagName: 'nv-datetimetest',
+    elementClass: NvDatetimetestElement,
+    react: React,
+    events: {
+        onValueChanged: 'valueChanged',
+        onLastChanged: 'lastChanged',
+        onHistoryChanged: 'historyChanged'
+    },
+    defineCustomElement: defineNvDatetimetest
+});
 export const NvDialog = createComponent({
     tagName: 'nv-dialog',
     elementClass: NvDialogElement,
@@ -513,6 +539,18 @@ export const NvTableheader = createComponent({
     events: { onSortDirectionChanged: 'sortDirectionChanged' },
     defineCustomElement: defineNvTableheader
 });
+export const NvTimetest = createComponent({
+    tagName: 'nv-timetest',
+    elementClass: NvTimetestElement,
+    react: React,
+    events: {
+        onValueChanged: 'valueChanged',
+        onLastChanged: 'lastChanged',
+        onHistoryChanged: 'historyChanged',
+        onValueDateChanged: 'valueDateChanged'
+    },
+    defineCustomElement: defineNvTimetest
+});
 export const NvToggle = createComponent({
     tagName: 'nv-toggle',
     elementClass: NvToggleElement,