@homebound/beam 2.301.0 → 2.302.1

package/dist/components/PresentationContext.js

@@ -11,7 +11,9 @@ function PresentationProvider(props) {
     const context = (0, react_1.useMemo)(() => {
         const fieldProps = { ...existingContext.fieldProps, ...presentationProps.fieldProps };
         return { ...existingContext, ...presentationProps, fieldProps };
-    }, [presentationProps, existingContext]);
+    }, 
+    // Isn't this `presentationProps` always a new instance due to the `...` above?
+    [presentationProps, existingContext]);
     return (0, jsx_runtime_1.jsx)(exports.PresentationContext.Provider, { value: context, children: children });
 }
 exports.PresentationProvider = PresentationProvider;

package/dist/components/Table/GridTable.d.ts

@@ -145,4 +145,4 @@ export declare function GridTable<R extends Kinded, X extends Only<GridTableXss,
  *
  * We return a copy of `[Parent, [Child]]` tuples so that we don't modify the `GridDataRow.children`.
  */
-export declare function filterRows<R extends Kinded>(api: GridTableApi<R>, columns: GridColumnWithId<R>[], rows: GridDataRow<R>[], filter: string | undefined): ParentChildrenTuple<R>[];
+export declare function filterRows<R extends Kinded>(api: GridTableApi<R>, columns: GridColumnWithId<R>[], rows: GridDataRow<R>[], filter: string | undefined): [string[], ParentChildrenTuple<R>[]];

package/dist/components/Table/GridTable.js

@@ -140,92 +140,75 @@ function GridTable(props) {
         }
         return rows;
     }, [columns, rows, sortOn, sortState, caseSensitive]);
-    const keptSelectedDataRows = (0, hooks_1.useComputed)(() => tableState.keptSelectedRows, [tableState]);
+    const [keptGroupRow, keptDataRows] = (0, hooks_1.useComputed)(() => [tableState.keptRowGroup, tableState.keptRows], [tableState]);
     // Sort the `keptSelectedDataRows` separately because the current sorting logic sorts within groups and these "kept" rows are now displayed in a flat list.
     // It could also be the case that some of these rows are no longer in the `props.rows` list, and so wouldn't be sorted by the `maybeSorted` logic above.
     const sortedKeptSelections = (0, react_1.useMemo)(() => {
-        if (sortOn === "client" && sortState && keptSelectedDataRows.length > 0) {
-            return (0, sortRows_1.sortRows)(columns, keptSelectedDataRows, sortState, caseSensitive);
+        if (sortOn === "client" && sortState && keptDataRows.length > 0) {
+            return (0, sortRows_1.sortRows)(columns, keptDataRows, sortState, caseSensitive);
         }
-        return keptSelectedDataRows;
-    }, [columns, sortOn, sortState, caseSensitive, keptSelectedDataRows]);
-    // Flatten + component-ize the sorted rows.
+        return keptDataRows;
+    }, [columns, sortOn, sortState, caseSensitive, keptDataRows]);
+    // Flatten, hide-if-filtered, hide-if-collapsed, and component-ize the sorted rows.
     let [headerRows, visibleDataRows, totalsRows, expandableHeaderRows, keptSelectedRows, filteredRowIds] = (0, react_1.useMemo)(() => {
-        function makeRowComponent(row, level, isKeptSelectedRow = false, isLastKeptSelectionRow = false) {
-            return ((0, jsx_runtime_1.jsx)(Row_1.Row, { ...{
-                    as,
-                    columns,
-                    row,
-                    style,
-                    rowStyles,
-                    columnSizes,
-                    level,
-                    getCount,
-                    api,
-                    cellHighlight: "cellHighlight" in maybeStyle && maybeStyle.cellHighlight === true,
-                    omitRowHover: "rowHover" in maybeStyle && maybeStyle.rowHover === false,
-                    sortOn,
-                    hasExpandableHeader,
-                    isKeptSelectedRow,
-                    isLastKeptSelectionRow,
-                } }, `${row.kind}-${row.id}`));
-        }
+        const hasExpandableHeader = maybeSorted.some((row) => row.id === utils_1.EXPANDABLE_HEADER);
+        const makeRowComponent = (row, level, isKeptSelectedRow = false, isLastKeptSelectionRow = false) => ((0, jsx_runtime_1.jsx)(Row_1.Row, { ...{
+                as,
+                columns,
+                row,
+                style,
+                rowStyles,
+                columnSizes,
+                level,
+                getCount,
+                api,
+                cellHighlight: "cellHighlight" in maybeStyle && maybeStyle.cellHighlight === true,
+                omitRowHover: "rowHover" in maybeStyle && maybeStyle.rowHover === false,
+                hasExpandableHeader,
+                isKeptSelectedRow,
+                isLastKeptSelectionRow,
+            } }, `${row.kind}-${row.id}`));
         // Split out the header rows from the data rows so that we can put an `infoMessage` in between them (if needed).
         const headerRows = [];
         const expandableHeaderRows = [];
         const totalsRows = [];
         const visibleDataRows = [];
         const keptSelectedRows = [];
-        const filteredRowIds = [];
-        const hasExpandableHeader = rows.some((row) => row.id === utils_1.EXPANDABLE_HEADER);
-        function visit([row, children], level, visible) {
-            visible && visibleDataRows.push([row, makeRowComponent(row, level)]);
-            // This row may be invisible (because it's parent is collapsed), but we still want
-            // to consider it matched if it or it's parent matched a filter.
-            filteredRowIds.push(row.id);
-            if (children.length) {
-                // Consider "isCollapsed" as true if the parent wasn't visible.
-                const isCollapsed = !visible || collapsedIds.includes(row.id);
-                visitRows(children, level + 1, !isCollapsed);
-            }
-        }
-        function visitRows(rows, level, visible) {
-            rows.forEach((row, i) => {
-                if (row[0].kind === "header") {
-                    headerRows.push([row[0], makeRowComponent(row[0], level)]);
-                    return;
+        // Flatten the tuple tree into lists of rows
+        function visitRows(tuples, level) {
+            tuples.forEach(([row, children]) => {
+                if (row.kind === "header") {
+                    headerRows.push([row, makeRowComponent(row, level)]);
                 }
-                if (row[0].kind === "totals") {
-                    totalsRows.push([row[0], makeRowComponent(row[0], level)]);
-                    return;
+                else if (row.kind === "totals") {
+                    totalsRows.push([row, makeRowComponent(row, level)]);
                 }
-                if (row[0].kind === "expandableHeader") {
-                    expandableHeaderRows.push([row[0], makeRowComponent(row[0], level)]);
-                    return;
+                else if (row.kind === "expandableHeader") {
+                    expandableHeaderRows.push([row, makeRowComponent(row, level)]);
+                }
+                else {
+                    visibleDataRows.push([row, makeRowComponent(row, level)]);
+                    // tuples has already been client-side filtered, so just check collapsed
+                    if (children.length && !collapsedIds.includes(row.id)) {
+                        visitRows(children, level + 1);
+                    }
                 }
-                visit(row, level, visible);
             });
         }
-        // Call `visitRows` with our a pre-filtered set list
-        const filteredRows = filterRows(api, columns, maybeSorted, filter);
-        visitRows(filteredRows, 0, true);
-        // Check for any selected rows that are not displayed in the table because they don't match the current filter, or are no longer part of the `rows` prop.
-        // We persist these selected rows and hoist them to the top of the table.
+        // Call `visitRows` with our post-filtered list
+        const [filteredRowIds, filteredRows] = filterRows(api, columns, maybeSorted, filter);
+        visitRows(filteredRows, 0);
+        // Check for any selected rows that are not displayed in the table because they don't
+        // match the current filter, or are no longer part of the `rows` prop. We persist these
+        // selected rows and hoist them to the top of the table.
         if (sortedKeptSelections.length) {
-            // The "group row" for selected rows that are hidden by filters and add the children
-            const keptSelectionGroupRow = {
-                id: utils_1.KEPT_GROUP,
-                kind: utils_1.KEPT_GROUP,
-                children: sortedKeptSelections,
-                initCollapsed: true,
-                data: undefined,
-            };
-            keptSelectedRows.push([keptSelectionGroupRow, makeRowComponent(keptSelectionGroupRow, 1)], ...(collapsedIds.includes(utils_1.KEPT_GROUP)
-                ? []
-                : (sortedKeptSelections.map((row, idx) => [
-                    row,
-                    makeRowComponent(row, 1, true, idx === sortedKeptSelections.length - 1),
-                ]))));
+            keptSelectedRows.push([keptGroupRow, makeRowComponent(keptGroupRow, 1)]);
+            if (!collapsedIds.includes(utils_1.KEPT_GROUP)) {
+                keptSelectedRows.push(...sortedKeptSelections.map((row, idx) => {
+                    const isLast = idx === sortedKeptSelections.length - 1;
+                    return [row, makeRowComponent(row, 1, true, isLast)];
+                }));
+            }
         }
         return [headerRows, visibleDataRows, totalsRows, expandableHeaderRows, keptSelectedRows, filteredRowIds];
     }, [
@@ -236,17 +219,17 @@ function GridTable(props) {
         columns,
         style,
         rowStyles,
-        sortOn,
+        maybeStyle,
         columnSizes,
         collapsedIds,
         getCount,
+        keptGroupRow,
         sortedKeptSelections,
     ]);
     // Once our header rows are created we can organize them in expected order.
     const tableHeadRows = expandableHeaderRows.concat(headerRows).concat(totalsRows);
-    let tooManyClientSideRows = false;
-    if (filterMaxRows && visibleDataRows.length > filterMaxRows) {
-        tooManyClientSideRows = true;
+    const tooManyClientSideRows = filterMaxRows && visibleDataRows.length > filterMaxRows;
+    if (tooManyClientSideRows) {
         visibleDataRows = visibleDataRows.slice(0, filterMaxRows + keptSelectedRows.length);
     }
     tableState.setMatchedRows(filteredRowIds);
@@ -256,6 +239,7 @@ function GridTable(props) {
         // Refs are cheap to assign to, so we don't bother doing this in a useEffect
         rowLookup.current = (0, GridRowLookup_1.createRowLookup)(columns, visibleDataRows, virtuosoRef);
     }
+    // TODO: Replace setRowCount with clients observing TableState via the API
     (0, react_1.useEffect)(() => {
         setRowCount && (visibleDataRows === null || visibleDataRows === void 0 ? void 0 : visibleDataRows.length) !== undefined && setRowCount(visibleDataRows.length);
     }, [visibleDataRows === null || visibleDataRows === void 0 ? void 0 : visibleDataRows.length, setRowCount]);
@@ -434,26 +418,33 @@ const VirtualRoot = (0, memoize_one_1.default)((gs, _columns, id, xss) => {
  * We return a copy of `[Parent, [Child]]` tuples so that we don't modify the `GridDataRow.children`.
  */
 function filterRows(api, columns, rows, filter) {
+    // Make a flat list of ids, in addition to the tuple tree
+    const filteredRowIds = [];
+    // Break up "foo bar" into `[foo, bar]` and a row must match both `foo` and `bar`
+    const filters = (filter && filter.split(/ +/)) || [];
     // Make a functions to do recursion
     function acceptAll(acc, row) {
         var _a, _b;
+        filteredRowIds.push(row.id);
         return acc.concat([[row, (_b = (_a = row.children) === null || _a === void 0 ? void 0 : _a.reduce(acceptAll, [])) !== null && _b !== void 0 ? _b : []]]);
     }
     function filterFn(acc, row) {
         var _a, _b, _c, _d;
-        // Break up "foo bar" into `[foo, bar]` and a row must match both `foo` and `bar`
-        const filters = (filter && filter.split(/ +/)) || [];
         const matches = utils_1.reservedRowKinds.includes(row.kind) ||
             filters.length === 0 ||
             filters.every((f) => columns.map((c) => (0, utils_1.applyRowFn)(c, row, api, 0, false)).some((maybeContent) => (0, utils_1.matchesFilter)(maybeContent, f)));
         if (matches) {
+            filteredRowIds.push(row.id);
+            // A matched parent means show all it's children
             return acc.concat([[row, (_b = (_a = row.children) === null || _a === void 0 ? void 0 : _a.reduce(acceptAll, [])) !== null && _b !== void 0 ? _b : []]]);
         }
         else {
+            // An unmatched parent but with matched children means show the parent
             const matchedChildren = (_d = (_c = row.children) === null || _c === void 0 ? void 0 : _c.reduce(filterFn, [])) !== null && _d !== void 0 ? _d : [];
             if (matchedChildren.length > 0 ||
                 typeof row.pin === "string" ||
                 (row.pin !== undefined && row.pin.filter !== true)) {
+                filteredRowIds.push(row.id);
                 return acc.concat([[row, matchedChildren]]);
             }
             else {
@@ -461,6 +452,6 @@ function filterRows(api, columns, rows, filter) {
             }
         }
     }
-    return rows.reduce(filterFn, []);
+    return [filteredRowIds, rows.reduce(filterFn, [])];
 }
 exports.filterRows = filterRows;

package/dist/components/Table/GridTableApi.js

@@ -32,7 +32,6 @@ class GridTableApiImpl {
     /** Called once by the GridTable when it takes ownership of this api instance. */
     init(persistCollapse, virtuosoRef, rows) {
         this.tableState.loadCollapse(persistCollapse, rows);
-        this.tableState.loadSelected(rows);
         this.virtuosoRef = virtuosoRef;
     }
     scrollToIndex(index) {

package/dist/components/Table/components/KeptGroupRow.js

@@ -12,7 +12,7 @@ function KeptGroupRow(props) {
     const { as, columnSizes, style, row, colSpan } = props;
     const CellTag = as === "table" ? "td" : "div";
     const { tableState } = (0, react_1.useContext)(Table_1.TableStateContext);
-    const numHiddenSelectedRows = (0, hooks_1.useComputed)(() => tableState.keptSelectedRows.length, [tableState]);
+    const numHiddenSelectedRows = (0, hooks_1.useComputed)(() => tableState.keptRows.length, [tableState]);
     return ((0, jsx_runtime_1.jsx)(CellTag, { css: {
             ...style.cellCss,
             ...style.keptGroupRowCss,

package/dist/components/Table/components/Row.d.ts

@@ -2,7 +2,6 @@ import { ReactElement } from "react";
 import { GridTableApi } from "../GridTableApi";
 import { GridStyle, RowStyles } from "../TableStyles";
 import { DiscriminateUnion, GridColumnWithId, IfAny, Kinded, Pin, RenderAs } from "../types";
-import { SortOn } from "../utils/TableState";
 import { AnyObject } from "../../../types";
 interface RowProps<R extends Kinded> {
     as: RenderAs;
@@ -10,7 +9,6 @@ interface RowProps<R extends Kinded> {
     row: GridDataRow<R>;
     style: GridStyle;
     rowStyles: RowStyles<R> | undefined;
-    sortOn: SortOn;
     columnSizes: string[];
     level: number;
     getCount: (id: string) => object;
@@ -55,11 +53,13 @@ export type GridDataRow<R extends Kinded> = {
     id: string;
     /** A list of parent/grand-parent ids for collapsing parent/child rows. */
     children?: GridDataRow<R>[];
-    /** * Whether to pin this sort to the first/last of its parent's children.
+    /**
+     * Whether to pin this sort to the first/last of its parent's children.
      *
      * By default, pinned rows are always shown/not filtered out, however providing
      * the pin `filter: true` property will allow pinned rows to be hidden
-     * while filtering.*/
+     * while filtering.
+     */
     pin?: "first" | "last" | Pin;
     data: unknown;
     /** Whether to have the row collapsed (children not visible) on initial load. This will be ignore in subsequent re-renders of the table */

package/dist/components/Table/components/Row.js

@@ -38,9 +38,10 @@ const utils_2 = require("../../../utils");
 const shallowEqual_1 = require("../../../utils/shallowEqual");
 // We extract Row to its own mini-component primarily so we can React.memo'ize it.
 function RowImpl(props) {
-    var _a;
-    const { as, columns, row, style, rowStyles, sortOn, columnSizes, level, getCount, api, cellHighlight, omitRowHover, hasExpandableHeader, isKeptSelectedRow, isLastKeptSelectionRow, ...others } = props;
+    var _a, _b;
+    const { as, columns, row, style, rowStyles, columnSizes, level, getCount, api, cellHighlight, omitRowHover, hasExpandableHeader, isKeptSelectedRow, isLastKeptSelectionRow, ...others } = props;
     const { tableState } = (0, react_1.useContext)(TableState_1.TableStateContext);
+    const sortOn = (_a = tableState.sortConfig) === null || _a === void 0 ? void 0 : _a.on;
     const rowId = `${row.kind}_${row.id}`;
     const isActive = (0, hooks_1.useComputed)(() => tableState.activeRowId === rowId, [rowId, tableState]);
     // We treat the "header" and "totals" kind as special for "good defaults" styling
@@ -57,7 +58,7 @@ function RowImpl(props) {
         // Optionally include the row hover styles, by default they should be turned on.
         ...(showRowHoverColor && {
             // Even though backgroundColor is set on the cellCss, the hover target is the row.
-            "&:hover > *": Css_1.Css.bgColor((_a = style.rowHoverColor) !== null && _a !== void 0 ? _a : Css_1.Palette.LightBlue100).$,
+            "&:hover > *": Css_1.Css.bgColor((_b = style.rowHoverColor) !== null && _b !== void 0 ? _b : Css_1.Palette.LightBlue100).$,
         }),
         // For virtual tables use `display: flex` to keep all cells on the same row. For each cell in the row use `flexNone` to ensure they stay their defined widths
         ...(as === "table" ? {} : Css_1.Css.relative.df.fg1.fs1.addIn("&>*", Css_1.Css.flexNone.$).$),

package/dist/components/Table/utils/RowState.d.ts

@@ -0,0 +1,63 @@
+import { GridDataRow, SelectedState } from "../../..";
+/**
+ * A reactive/observable state of each GridDataRow's current behavior.
+ *
+ * We set up the RowStates in a tree, just like GridDataRow, to make business logic
+ * that uses parent/children easier to write, i.e. selected-ness and collapsed-ness.
+ */
+export declare class RowState {
+    /** Our row, only ref observed, so we don't crawl into GraphQL fragments. */
+    row: GridDataRow<any>;
+    /** Our parent RowState, or the `header` RowState if we're a top-level row. */
+    parent: RowState | undefined;
+    /** Our children row states, as of the latest `props.rows`, without any filtering applied. */
+    children: RowState[] | undefined;
+    /** Whether we match a client-side filter; true if no filter is in place. */
+    isMatched: boolean;
+    /** Whether we are *directly* selected. */
+    selected: boolean;
+    /** Whether our `row` had been in `props.rows`, but was removed, i.e. probably by server-side filters. */
+    wasRemoved: boolean;
+    constructor(parent: RowState | undefined, row: GridDataRow<any>);
+    /**
+     * Whether we are currently selected, for `GridTableApi.getSelectedRows`.
+     *
+     * Note that we don't use "I'm selected || my parent is selected" logic here, because whether a child is selected
+     * is actually based on whether it was _visible at the time the parent was selected_. So, we can't just assume
+     * "a parent being selected means the child is also selected", and instead parents have to push selected-ness down
+     * to their visible children explicitly.
+     */
+    get isSelected(): boolean;
+    /** The UI state for checked/unchecked + "partially checked" for parents. */
+    get selectedState(): SelectedState;
+    /**
+     * A special SelectedState that "sees through"/ignores inferSelectedState, so the header works.
+     *
+     * I.e. a row might have `inferSelectedState: false`, so is showing unchecked, but the header
+     * wants to show partial-ness whenever any given child is selected.
+     */
+    get selectedStateForHeader(): SelectedState;
+    /**
+     * Called to explicitly select/unselect this row.
+     *
+     * This could be either because the user clicked directly on us, or because we're a visible
+     * child of a selected parent row.
+     */
+    select(selected: boolean): void;
+    /** Whether this is a selected-but-filtered-out row that we should hoist to the top. */
+    get isKept(): boolean;
+    private get inferSelectedState();
+    private get visibleChildren();
+    /**
+     * Returns whether this row should act like a parent.
+     *
+     * This means "has children" and "does not have inferSelectedState: false"
+     * set. I.e. `inferSelectedState: false` allows a parent with children to
+     * still act as its own selectable identity.
+     *
+     * We also check `children.length > 0`, because sometimes pages will calc a
+     * row's children as `children = someList.map(...)`, and if the list is empty,
+     * they want the row to be selectable.
+     */
+    private get isParent();
+}

package/dist/components/Table/utils/RowState.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowState = void 0;
+const mobx_1 = require("mobx");
+const src_1 = require("../../..");
+/**
+ * A reactive/observable state of each GridDataRow's current behavior.
+ *
+ * We set up the RowStates in a tree, just like GridDataRow, to make business logic
+ * that uses parent/children easier to write, i.e. selected-ness and collapsed-ness.
+ */
+class RowState {
+    // ...eventually...
+    // isDirectlyMatched = accept filters in the constructor and do match here
+    // isEffectiveMatched = isDirectlyMatched || hasMatchedChildren
+    constructor(parent, row) {
+        /** Our children row states, as of the latest `props.rows`, without any filtering applied. */
+        this.children = undefined;
+        /** Whether we match a client-side filter; true if no filter is in place. */
+        this.isMatched = true;
+        /** Whether we are *directly* selected. */
+        this.selected = false;
+        /** Whether our `row` had been in `props.rows`, but was removed, i.e. probably by server-side filters. */
+        this.wasRemoved = false;
+        this.parent = parent;
+        this.row = row;
+        this.selected = !!row.initSelected;
+        (0, mobx_1.makeAutoObservable)(this, { row: mobx_1.observable.ref });
+    }
+    /**
+     * Whether we are currently selected, for `GridTableApi.getSelectedRows`.
+     *
+     * Note that we don't use "I'm selected || my parent is selected" logic here, because whether a child is selected
+     * is actually based on whether it was _visible at the time the parent was selected_. So, we can't just assume
+     * "a parent being selected means the child is also selected", and instead parents have to push selected-ness down
+     * to their visible children explicitly.
+     */
+    get isSelected() {
+        // We consider group rows selected if all of their children are selected.
+        if (this.isParent)
+            return this.selectedState === "checked";
+        return this.selected;
+    }
+    /** The UI state for checked/unchecked + "partially checked" for parents. */
+    get selectedState() {
+        // Parent `selectedState` is special b/c it does not directly depend on the parent's own selected-ness,
+        // but instead depends on the current visible children. I.e. a parent might be "selected", but then the
+        // client-side filter changes, a child reappears, and we need to transition to partial-ness.
+        if (this.isParent) {
+            // Use visibleChildren b/c if filters are hiding some of our children, we still want to show fully selected
+            const children = this.visibleChildren;
+            const allChecked = children.every((child) => child.selectedState === "checked");
+            const allUnchecked = children.every((child) => child.selectedState === "unchecked");
+            return children.length === 0 ? "unchecked" : allChecked ? "checked" : allUnchecked ? "unchecked" : "partial";
+        }
+        return this.selected ? "checked" : "unchecked";
+    }
+    /**
+     * A special SelectedState that "sees through"/ignores inferSelectedState, so the header works.
+     *
+     * I.e. a row might have `inferSelectedState: false`, so is showing unchecked, but the header
+     * wants to show partial-ness whenever any given child is selected.
+     */
+    get selectedStateForHeader() {
+        if (this.children) {
+            const children = this.visibleChildren;
+            const allChecked = children.every((child) => child.selectedStateForHeader === "checked");
+            const allUnchecked = children.every((child) => child.selectedStateForHeader === "unchecked");
+            // For the header purposes, if this is a selectable-row (i.e. not inferSelectedState) make sure
+            // both the row itself & all children are "all checked" or "not all checked", otherwise consider
+            // ourselves partially selected.
+            if ((allUnchecked || children.length === 0) && (this.inferSelectedState || !this.selected)) {
+                return "unchecked";
+            }
+            else if (allChecked && (this.inferSelectedState || this.selected)) {
+                return "checked";
+            }
+            else {
+                return "partial";
+            }
+        }
+        return this.selected ? "checked" : "unchecked";
+    }
+    /**
+     * Called to explicitly select/unselect this row.
+     *
+     * This could be either because the user clicked directly on us, or because we're a visible
+     * child of a selected parent row.
+     */
+    select(selected) {
+        if (this.row.selectable === false)
+            return;
+        this.selected = selected;
+        // We don't check inferSelectedState here, b/c even if the parent is considered selectable
+        // on its own, we still push down selected-ness to our visible children.
+        if (this.children) {
+            for (const child of this.visibleChildren) {
+                child.select(selected);
+            }
+        }
+    }
+    /** Whether this is a selected-but-filtered-out row that we should hoist to the top. */
+    get isKept() {
+        // this row is "kept" if it is selected, and:
+        // - it is not matched (hidden by filter) (being hidden by collapse is okay)
+        // - or it has (probably) been server-side filtered
+        return (this.selected &&
+            // Headers, totals, etc., do not need keeping
+            !src_1.reservedRowKinds.includes(this.row.kind) &&
+            !this.isParent &&
+            (!this.isMatched || this.wasRemoved));
+    }
+    get inferSelectedState() {
+        return this.row.inferSelectedState !== false;
+    }
+    get visibleChildren() {
+        var _a, _b, _c;
+        // The keptGroup should treat all of its children as visible, as this makes select/unselect all work.
+        if (this.row.kind === src_1.KEPT_GROUP)
+            return (_a = this.children) !== null && _a !== void 0 ? _a : [];
+        return (_c = (_b = this.children) === null || _b === void 0 ? void 0 : _b.filter((c) => c.isMatched === true)) !== null && _c !== void 0 ? _c : [];
+    }
+    /**
+     * Returns whether this row should act like a parent.
+     *
+     * This means "has children" and "does not have inferSelectedState: false"
+     * set. I.e. `inferSelectedState: false` allows a parent with children to
+     * still act as its own selectable identity.
+     *
+     * We also check `children.length > 0`, because sometimes pages will calc a
+     * row's children as `children = someList.map(...)`, and if the list is empty,
+     * they want the row to be selectable.
+     */
+    get isParent() {
+        return !!this.children && this.children.length > 0 && this.inferSelectedState;
+    }
+    /** Pretty toString. */
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return `RowState ${this.row.kind}-${this.row.id}`;
+    }
+}
+exports.RowState = RowState;

package/dist/components/Table/utils/RowStates.d.ts

@@ -0,0 +1,24 @@
+import { GridDataRow } from "../../..";
+import { RowState } from "./RowState";
+/**
+ * Manages our tree of observable RowStates that manage each GridDataRow's behavior.
+ */
+export declare class RowStates {
+    private map;
+    keptGroupRow: RowState;
+    /** Returns a flat list of all of our RowStates. */
+    get allStates(): RowState[];
+    /** Returns the `RowState` for the given `id`. We should probably require `kind`. */
+    get(id: string): RowState;
+    /**
+     * Merge a new set of `rows` prop into our state.
+     *
+     * Any missing rows are marked as `wasRemoved` so we can consider them "kept" if they're also selected.
+     */
+    setRows(rows: GridDataRow<any>[]): void;
+    /** Fully delete `ids`, so they don't show up in kept rows anymore. */
+    delete(ids: string[]): void;
+    setMatchedRows(ids: string[]): void;
+    /** Returns kept rows, i.e. those that were user-selected but then client-side or server-side filtered. */
+    get keptRows(): RowState[];
+}

package/dist/components/Table/utils/RowStates.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowStates = void 0;
+const mobx_1 = require("mobx");
+const src_1 = require("../../..");
+const RowState_1 = require("./RowState");
+/**
+ * Manages our tree of observable RowStates that manage each GridDataRow's behavior.
+ */
+class RowStates {
+    constructor() {
+        // A flat map of all row id -> RowState
+        this.map = new mobx_1.ObservableMap();
+        // Pre-create our keptGroupRow for if/when we need it.
+        this.keptGroupRow = creatKeptGroupRow();
+    }
+    /** Returns a flat list of all of our RowStates. */
+    get allStates() {
+        return [...this.map.values()];
+    }
+    /** Returns the `RowState` for the given `id`. We should probably require `kind`. */
+    get(id) {
+        const rs = this.map.get(id);
+        if (!rs)
+            throw new Error(`No RowState for ${id}`);
+        return rs;
+    }
+    /**
+     * Merge a new set of `rows` prop into our state.
+     *
+     * Any missing rows are marked as `wasRemoved` so we can consider them "kept" if they're also selected.
+     */
+    setRows(rows) {
+        const existing = new Set(this.map.values());
+        const map = this.map;
+        function addRowAndChildren(parent, row) {
+            var _a;
+            // This should really be kind+id, but a lot of our lookups just use id
+            const key = row.id;
+            let state = map.get(key);
+            if (!state) {
+                state = new RowState_1.RowState(parent, row);
+                map.set(key, state);
+            }
+            else {
+                state.parent = parent;
+                state.row = row;
+                state.wasRemoved = false;
+                existing.delete(state);
+            }
+            state.children = (_a = row.children) === null || _a === void 0 ? void 0 : _a.map((child) => addRowAndChildren(state, child));
+            return state;
+        }
+        // Probe for the header row, so we can create it as a root RowState, even
+        // though we don't require the user to model their GridDataRows that way.
+        const header = rows.find((r) => r.kind === src_1.HEADER);
+        const headerState = header ? addRowAndChildren(undefined, header) : undefined;
+        // Add the top-level rows
+        const children = rows.filter((row) => row !== header).map((row) => addRowAndChildren(headerState, row));
+        // And attach them to the header for select-all/etc. to work
+        if (headerState) {
+            headerState.children = children.filter((rs) => !src_1.reservedRowKinds.includes(rs.row.kind));
+        }
+        // Then mark any remaining as removed
+        for (const state of existing) {
+            state.wasRemoved = true;
+        }
+        const keptRows = this.keptRows;
+        if (keptRows.length > 0) {
+            // Stitch the current keptRows into the placeholder keptGroupRow
+            keptRows.forEach((rs) => (rs.parent = this.keptGroupRow));
+            this.keptGroupRow.children = keptRows;
+            this.keptGroupRow.row.children = keptRows.map((rs) => rs.row);
+            // And then stitch the keptGroupRow itself into the root header, so that the kept rows
+            // are treated as just another child for the header's select/unselect all to work.
+            if (headerState) {
+                this.keptGroupRow.parent = headerState;
+                headerState.children.unshift(this.keptGroupRow);
+            }
+        }
+    }
+    /** Fully delete `ids`, so they don't show up in kept rows anymore. */
+    delete(ids) {
+        var _a;
+        for (const id of ids) {
+            const rs = this.map.get(id);
+            if (rs && rs.parent) {
+                rs.parent.children = (_a = rs.parent.children) === null || _a === void 0 ? void 0 : _a.filter((o) => o !== rs);
+            }
+            this.map.delete(id);
+        }
+    }
+    setMatchedRows(ids) {
+        for (const rs of this.allStates) {
+            rs.isMatched = ids.includes(rs.row.id);
+        }
+    }
+    /** Returns kept rows, i.e. those that were user-selected but then client-side or server-side filtered. */
+    get keptRows() {
+        return this.allStates.filter((rs) => rs.isKept);
+    }
+}
+exports.RowStates = RowStates;
+function creatKeptGroupRow() {
+    // The "group row" for selected rows that are hidden by filters and add the children
+    const keptGroupRow = { id: src_1.KEPT_GROUP, kind: src_1.KEPT_GROUP, initCollapsed: true, data: undefined };
+    return new RowState_1.RowState(undefined, keptGroupRow);
+}

package/dist/components/Table/utils/TableState.d.ts

@@ -1,4 +1,4 @@
-import { ObservableMap, ObservableSet } from "mobx";
+import { ObservableSet } from "mobx";
 import React from "react";
 import { GridDataRow } from "../components/Row";
 import { GridSortConfig } from "../GridTable";
@@ -22,11 +22,8 @@ export type SelectedState = "checked" | "unchecked" | "partial";
 export declare class TableState {
     private readonly collapsedRows;
     private persistCollapse;
-    private readonly rowSelectedState;
-    selectedDataRows: ObservableMap<string, GridDataRow<any>>;
-    private matchedRows;
-    keptSelectedRows: GridDataRow<any>[];
     rows: GridDataRow<any>[];
+    private readonly rowStates;
     activeRowId: string | undefined;
     activeCellId: string | undefined;
     sortConfig: GridSortConfig | undefined;
@@ -43,7 +40,6 @@ export declare class TableState {
      */
     constructor();
     loadCollapse(persistCollapse: string | undefined, rows: GridDataRow<any>[]): void;
-    loadSelected(rows: GridDataRow<any>[]): void;
     initSortState(sortConfig: GridSortConfig | undefined, columns: GridColumnWithId<any>[]): void;
     setSortKey(clickedColumnId: string): void;
     get sortState(): SortState | undefined;
@@ -59,17 +55,20 @@ export declare class TableState {
     get visibleColumnIds(): string[];
     get expandedColumnIds(): string[];
     toggleExpandedColumn(columnId: string): void;
+    /** Called when GridTable has re-calced the rows that pass the client-side filter, or all rows. */
     setMatchedRows(rowIds: string[]): void;
-    /** Returns either all data rows (non-header, non-totals, etc) that are selected where `row.selectable !== false` */
+    /** Returns selected data rows (non-header, non-totals, etc.), ignoring rows that have `row.selectable !== false`. */
     get selectedRows(): GridDataRow<any>[];
+    /** Returns kept group row, with the latest kept children, if any. */
+    get keptRowGroup(): GridDataRow<any>;
+    /** Returns kept rows, i.e. those that were user-selected but then client-side or server-side filtered. */
+    get keptRows(): GridDataRow<any>[];
     getSelected(id: string): SelectedState;
     selectRow(id: string, selected: boolean): void;
     get collapsedIds(): string[];
     isCollapsed(id: string): boolean;
     toggleCollapsed(id: string): void;
     deleteRows(ids: string[]): void;
-    private getMatchedChildrenStates;
-    private setNestedSelectedStates;
 }
 /** Provides a context for rows to access their table's `TableState`. */
 export declare const TableStateContext: React.Context<{
@@ -82,6 +81,7 @@ type ColumnSort = {
 };
 export type SortState = {
     current?: ColumnSort;
+    /** The persistent sort is always applied first, i.e. for schedules, probably. */
     persistent?: ColumnSort;
 };
 export type SortOn = "client" | "server" | undefined;

package/dist/components/Table/utils/TableState.js

@@ -7,8 +7,8 @@ exports.deriveSortState = exports.TableStateContext = exports.TableState = void
 const change_case_1 = require("change-case");
 const mobx_1 = require("mobx");
 const react_1 = __importDefault(require("react"));
+const RowStates_1 = require("./RowStates");
 const utils_1 = require("./utils");
-const visitor_1 = require("./visitor");
 const utils_2 = require("../../../utils");
 const columns_1 = require("./columns");
 /**
@@ -33,24 +33,15 @@ class TableState {
     constructor() {
         // A set of just row ids, i.e. not row.kind+row.id
         this.collapsedRows = new mobx_1.ObservableSet([]);
-        // This will include rows that are selected, are partially selected, or were at once selected but are now unchecked.
-        // Rows within this map may be in `this.rows` or removed from `this.rows`.
-        this.rowSelectedState = new mobx_1.ObservableMap();
-        // Keep a copy of all the selected GridDataRows - Do not include custom row kinds such as `header`, `totals`, etc.
-        // This allows us to keep track of rows that were selected, but may no longer be defined in `GridTable.rows`
-        // This will be used to determine which rows are considered "kept" rows when filtering is applied or `GridTableProp.rows` changes
-        this.selectedDataRows = new mobx_1.ObservableMap();
-        // Set of just row ids. Keeps track of which rows match the filter. Used to filter rows from `selectedIds`
-        this.matchedRows = new mobx_1.ObservableSet();
-        // All fully selected data rows that do not match the applied filter, if any. Will not include group/parent rows unless they `inferSelectedState: false`
-        this.keptSelectedRows = [];
-        // The current list of rows, basically a useRef.current. Not reactive.
+        // The current list of rows, basically a useRef.current. Only shallow reactive.
         this.rows = [];
+        this.rowStates = new RowStates_1.RowStates();
         // Keeps track of the 'active' row, formatted `${row.kind}_${row.id}`
         this.activeRowId = undefined;
         // Keeps track of the 'active' cell, formatted `${row.kind}_${row.id}_${column.name}`
         this.activeCellId = undefined;
-        // Provide some defaults to get the sort state to properly work.
+        // Tracks the active sort column(s), so GridTable or SortHeaders can reactively
+        // re-render (for GridTable, only if client-side sorting)
         this.sort = {};
         // Non-reactive list of our columns
         this.columns = [];
@@ -73,35 +64,12 @@ class TableState {
             // Do not observe columns, expect this to be a non-reactive value for us to base our reactive values off of.
             columns: false,
         });
-        // Whenever our `matchedRows` change (i.e. via filtering) then we need to re-derive header and parent rows' selected state.
-        (0, mobx_1.reaction)(() => [...this.matchedRows.values()].sort(), () => {
-            const newlyKeptRows = [...this.selectedDataRows.values()].filter((row) => keptSelectionsFilter(row, this.matchedRows));
-            // If the kept rows went from empty to not empty, then introduce the SELECTED_GROUP row as collapsed
-            if (newlyKeptRows.length > 0 && this.keptSelectedRows.length === 0) {
+        // If the kept rows went from empty to not empty, then introduce the SELECTED_GROUP row as collapsed
+        (0, mobx_1.reaction)(() => [...this.keptRows.values()], (curr, prev) => {
+            if (prev.length === 0 && curr.length > 0) {
                 this.collapsedRows.add(utils_1.KEPT_GROUP);
             }
-            // When filters are applied, we need to determine if there are any selected rows that are no longer matched.
-            if (!mobx_1.comparer.shallow(newlyKeptRows, this.keptSelectedRows)) {
-                this.keptSelectedRows = newlyKeptRows;
-            }
-            // Re-derive the selected state for both the header and parent rows
-            const map = new Map();
-            map.set("header", deriveParentSelected([...this.rows, ...this.keptSelectedRows].flatMap((row) => this.setNestedSelectedStates(row, map))));
-            // Merge the changes back into the selected rows state
-            this.rowSelectedState.merge(map);
-            // Update the selectedDataRows to include those that are fully selected based on the filter changes
-            [...this.rowSelectedState.entries()].forEach(([id, state]) => {
-                if (this.selectedDataRows.has(id) && state !== "checked") {
-                    this.selectedDataRows.delete(id);
-                }
-                else if (!this.selectedDataRows.has(id) && state === "checked") {
-                    const row = this.rows.find((row) => row.id === id);
-                    if (row) {
-                        this.selectedDataRows.set(id, row);
-                    }
-                }
-            });
-        }, { equals: mobx_1.comparer.shallow });
+        });
     }
     loadCollapse(persistCollapse, rows) {
         this.persistCollapse = persistCollapse;
@@ -117,24 +85,6 @@ class TableState {
             }
         }
     }
-    loadSelected(rows) {
-        const selectedRows = [];
-        (0, visitor_1.visit)(rows, (row) => row.initSelected && selectedRows.push(row));
-        const selectedStateMap = new Map();
-        const selectedRowMap = new Map();
-        selectedRows.forEach((row) => {
-            selectedStateMap.set(row.id, "checked");
-            selectedRowMap.set(row.id, row);
-        });
-        this.rowSelectedState.merge(selectedStateMap);
-        this.selectedDataRows.merge(selectedRowMap);
-        // Determine if we need to initially display the kept selected group
-        const newlyKeptRows = selectedRows.filter((row) => keptSelectionsFilter(row, this.matchedRows));
-        if (!mobx_1.comparer.shallow(newlyKeptRows, this.keptSelectedRows)) {
-            this.collapsedRows.add(utils_1.KEPT_GROUP);
-            this.keptSelectedRows = newlyKeptRows;
-        }
-    }
     initSortState(sortConfig, columns) {
         var _a, _b;
         if (this.sortConfig) {
@@ -191,6 +141,7 @@ class TableState {
     setRows(rows) {
         // If the set of rows are different
         if (rows !== this.rows) {
+            this.rowStates.setRows(rows);
             const currentCollapsedIds = this.collapsedIds;
             // Create a list of the (maybe) new rows that should be initially collapsed
             const maybeNewCollapsedRowIds = flattenRows(rows)
@@ -218,10 +169,6 @@ class TableState {
         }
         // Finally replace our existing list of rows
         this.rows = rows;
-        // Update the selected rows map to include the rows' updated data
-        const selectedRows = new Map();
-        (0, visitor_1.visit)(this.rows, (row) => this.selectedDataRows.has(row.id) && selectedRows.set(row.id, row));
-        this.selectedDataRows.merge(selectedRows);
     }
     setColumns(columns, visibleColumnsStorageKey) {
         const isInitial = !this.columns || this.columns.length === 0;
@@ -331,106 +278,31 @@ class TableState {
             sessionStorage.setItem(getColumnStorageKey(this.persistCollapse), JSON.stringify(this.expandedColumnIds));
         }
     }
+    /** Called when GridTable has re-calced the rows that pass the client-side filter, or all rows. */
     setMatchedRows(rowIds) {
-        // ObservableSet doesn't seem to do a `diff` inside `replace` before firing
-        // observers/reactions that watch it, which can lead to render loops with the
-        // application page is observing `GridTableApi.getSelectedRows`, and merely
-        // the act of rendering GridTable (w/o row changes) causes it's `useComputed`
-        // to be triggered.
-        if (!mobx_1.comparer.shallow(rowIds, [...this.matchedRows.values()])) {
-            this.matchedRows.replace(rowIds);
-        }
+        this.rowStates.setMatchedRows(rowIds);
     }
-    /** Returns either all data rows (non-header, non-totals, etc) that are selected where `row.selectable !== false` */
+    /** Returns selected data rows (non-header, non-totals, etc.), ignoring rows that have `row.selectable !== false`. */
     get selectedRows() {
-        return [...this.selectedDataRows.values()].filter((row) => row.selectable !== false && !utils_1.reservedRowKinds.includes(row.kind));
+        return this.rowStates.allStates
+            .filter((rs) => rs.isSelected && !utils_1.reservedRowKinds.includes(rs.row.kind))
+            .map((rs) => rs.row);
+    }
+    /** Returns kept group row, with the latest kept children, if any. */
+    get keptRowGroup() {
+        return this.rowStates.keptGroupRow.row;
+    }
+    /** Returns kept rows, i.e. those that were user-selected but then client-side or server-side filtered. */
+    get keptRows() {
+        return this.rowStates.keptRows.map((rs) => rs.row);
     }
     // Should be called in an Observer/useComputed to trigger re-renders
     getSelected(id) {
-        var _a;
-        // Return the row's selected state if it's been explicitly set. If it is in the selectedDataRows set, then it's selected. Otherwise, it's unchecked.
-        return (_a = this.rowSelectedState.get(id)) !== null && _a !== void 0 ? _a : (this.selectedDataRows.has(id) ? "checked" : "unchecked");
+        const rs = this.rowStates.get(id);
+        return id === utils_1.HEADER ? rs.selectedStateForHeader : rs.selectedState;
     }
     selectRow(id, selected) {
-        var _a;
-        if (id === "header") {
-            // Select/unselect all has special behavior
-            if (selected) {
-                // Just mash the header + all rows + children as selected
-                const selectedStateMap = new Map();
-                const selectedRowMap = new Map();
-                selectedStateMap.set("header", "checked");
-                (0, visitor_1.visit)(this.rows, (row) => {
-                    if (!utils_1.reservedRowKinds.includes(row.kind) && this.matchedRows.has(row.id)) {
-                        selectedStateMap.set(row.id, "checked");
-                        selectedRowMap.set(row.id, row);
-                    }
-                });
-                this.rowSelectedState.replace(selectedStateMap);
-                // Use `merge` to ensure we don't lose any row that were selected, but no longer in `this.rows` (i.e. due to server-side filtering)
-                this.selectedDataRows.merge(selectedRowMap);
-            }
-            else {
-                // Similarly "unmash" all rows + children.
-                this.rowSelectedState.clear();
-                this.selectedDataRows.clear();
-                this.keptSelectedRows = [];
-            }
-        }
-        else {
-            // This is the regular/non-header behavior to just add/remove the individual row id,
-            // plus percolate the change down-to-child + up-to-parents.
-            // Find the clicked on row
-            const curr = (_a = findRow(this.rows, id)) !== null && _a !== void 0 ? _a : (this.selectedDataRows.has(id) ? { row: this.selectedDataRows.get(id), parents: [] } : undefined);
-            if (!curr) {
-                return;
-            }
-            // Everything here & down is deterministically on/off
-            const selectedStateMap = new Map();
-            (0, visitor_1.visit)([curr.row], (row) => {
-                // The `visit` method walks through the selected row and all of its children, if any.
-                // Depending on whether we are determining the clicked row's state or its children, then we handle updating the selection differently.
-                // We can tell if we are determining a child row's selected state by checking against the row selected `id` and the row we're currently evaluating `row.id`.
-                const isClickedRow = row.id === id;
-                // Only update the selected states if we're updating the clicked row, or if we are checking a child row, then the row must match the filter.
-                // Meaning, rows that are filtered out and displayed in the "selectedGroup" can only change their selection state by interacting with them directly.
-                if (isClickedRow || this.matchedRows.has(row.id)) {
-                    selectedStateMap.set(row.id, selected ? "checked" : "unchecked");
-                    if (selected) {
-                        this.selectedDataRows.set(row.id, row);
-                    }
-                    else {
-                        this.selectedDataRows.delete(row.id);
-                    }
-                }
-            });
-            // Now walk up the parents and see if they are now-all-checked/now-all-unchecked/some-of-each
-            for (const parent of [...curr.parents].reverse()) {
-                // Only derive selected state of the parent row if `inferSelectedState` is not `false`
-                if (parent.children && parent.inferSelectedState !== false) {
-                    const selectedState = deriveParentSelected(this.getMatchedChildrenStates(parent.children, selectedStateMap));
-                    if (selectedState === "checked") {
-                        this.selectedDataRows.set(parent.id, parent);
-                    }
-                    else {
-                        this.selectedDataRows.delete(parent.id);
-                    }
-                    selectedStateMap.set(parent.id, selectedState);
-                }
-            }
-            // And do the header + top-level "children" as a final one-off
-            selectedStateMap.set("header", deriveParentSelected(this.getMatchedChildrenStates([...this.rows, ...this.keptSelectedRows], selectedStateMap)));
-            // And merge the new selected state map into the existing one
-            this.rowSelectedState.merge(selectedStateMap);
-            // Lastly, we need to update the `keptSelectedRows` if the row was deselected.
-            // (If selected === true, then it's not possible for the row to be in `keptSelectedRows` as you can only select rows that match the filter)
-            if (!selected) {
-                const newlyKeptRows = [...this.selectedDataRows.values()].filter((row) => keptSelectionsFilter(row, this.matchedRows));
-                if (!mobx_1.comparer.shallow(newlyKeptRows, this.keptSelectedRows)) {
-                    this.keptSelectedRows = newlyKeptRows;
-                }
-            }
-        }
+        this.rowStates.get(id).select(selected);
     }
     get collapsedIds() {
         return [...this.collapsedRows.values()];
@@ -494,46 +366,13 @@ class TableState {
     }
     deleteRows(ids) {
         this.rows = this.rows.filter((row) => !ids.includes(row.id));
-        this.keptSelectedRows = this.keptSelectedRows.filter((row) => !ids.includes(row.id));
+        this.rowStates.delete(ids);
         ids.forEach((id) => {
-            this.selectedDataRows.delete(id);
-            this.rowSelectedState.delete(id);
             this.collapsedRows.delete(id);
-            this.matchedRows.delete(id);
         });
     }
-    getMatchedChildrenStates(children, map) {
-        const respectedChildren = children.flatMap(getChildrenForDerivingSelectState);
-        // When determining the children selected states to base the parent's state from, then only base this off of rows that match the filter or are in the "hidden selected" group (via the `filter` below)
-        return respectedChildren
-            .filter((row) => row.id !== "header" && (this.matchedRows.has(row.id) || this.selectedDataRows.has(row.id)))
-            .map((row) => map.get(row.id) || this.getSelected(row.id));
-    }
-    // Recursively traverse through rows to determine selected state of parent rows based on children
-    // Returns the selected states for the immediately children (if any) of the row passed in
-    setNestedSelectedStates(row, map) {
-        if (this.matchedRows.has(row.id) || this.selectedDataRows.has(row.id)) {
-            // do not derive selected state if there are no children, or if `inferSelectedState` is set to false
-            if (!row.children || row.inferSelectedState === false) {
-                return [this.getSelected(row.id)];
-            }
-            const childrenSelectedStates = row.children.flatMap((rc) => this.setNestedSelectedStates(rc, map));
-            const parentState = deriveParentSelected(childrenSelectedStates);
-            map.set(row.id, parentState);
-            return [parentState];
-        }
-        return [];
-    }
 }
 exports.TableState = TableState;
-/** Returns the child rows needed for deriving the selected state of a parent/group row */
-function getChildrenForDerivingSelectState(row) {
-    // Only look deeper if the parent row does not infer its selected state
-    if (row.children && row.inferSelectedState === false) {
-        return [row, ...row.children.flatMap(getChildrenForDerivingSelectState)];
-    }
-    return [row];
-}
 /** Provides a context for rows to access their table's `TableState`. */
 exports.TableStateContext = react_1.default.createContext({
     get tableState() {
@@ -559,27 +398,6 @@ function readOrSetLocalVisibleColumnState(columns, storageKey) {
     sessionStorage.setItem(storageKey, JSON.stringify(visibleColumnIds));
     return visibleColumnIds;
 }
-/** Finds a row by id, and returns it + any parents. */
-function findRow(rows, id) {
-    // This is technically an array of "maybe FoundRow"
-    const todo = rows.map((row) => ({ row, parents: [] }));
-    while (todo.length > 0) {
-        const curr = todo.pop();
-        if (curr.row.id === id) {
-            return curr;
-        }
-        else if (curr.row.children) {
-            // Search our children and pass along us as the parent
-            todo.push(...curr.row.children.map((child) => ({ row: child, parents: [...curr.parents, curr.row] })));
-        }
-    }
-    return undefined;
-}
-function deriveParentSelected(children) {
-    const allChecked = children.every((child) => child === "checked");
-    const allUnchecked = children.every((child) => child === "unchecked");
-    return children.length === 0 ? "unchecked" : allChecked ? "checked" : allUnchecked ? "unchecked" : "partial";
-}
 function getCollapsedIdsFromRows(rows) {
     return rows.reduce((acc, r) => {
         if (r.initCollapsed) {
@@ -627,9 +445,3 @@ function deriveSortState(currentSortState, clickedKey, initialSortState) {
     return initialSortState;
 }
 exports.deriveSortState = deriveSortState;
-function keptSelectionsFilter(row, matchedRows) {
-    return (!matchedRows.has(row.id) &&
-        row.selectable !== false &&
-        !utils_1.reservedRowKinds.includes(row.kind) &&
-        (!row.children || row.inferSelectedState === false));
-}

package/dist/components/Table/utils/utils.d.ts

@@ -22,6 +22,7 @@ export declare function maybeApplyFunction<T>(row: T, maybeFn: Properties | ((ro
 export declare function matchesFilter(maybeContent: ReactNode | GridCellContent, filter: string): boolean;
 export declare const HEADER = "header";
 export declare const TOTALS = "totals";
+/** Tables expandable columns get an extra header. */
 export declare const EXPANDABLE_HEADER = "expandableHeader";
 export declare const KEPT_GROUP = "keptGroup";
 export declare const reservedRowKinds: string[];

package/dist/components/Table/utils/utils.js

@@ -156,6 +156,7 @@ function matchesFilter(maybeContent, filter) {
 exports.matchesFilter = matchesFilter;
 exports.HEADER = "header";
 exports.TOTALS = "totals";
+/** Tables expandable columns get an extra header. */
 exports.EXPANDABLE_HEADER = "expandableHeader";
 exports.KEPT_GROUP = "keptGroup";
 exports.reservedRowKinds = [exports.HEADER, exports.TOTALS, exports.EXPANDABLE_HEADER, exports.KEPT_GROUP];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homebound/beam",
-  "version": "2.301.0",
+  "version": "2.302.1",
   "author": "Homebound",
   "license": "MIT",
   "main": "dist/index.js",