@homebound/beam 2.116.1 → 2.117.2

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

@@ -188,8 +188,10 @@ export declare type GridTableApi<R extends Kinded> = {
     scrollToIndex: (index: number) => void;
     /** Returns the ids of currently-selected rows. */
     getSelectedRowIds(): string[];
+    getSelectedRowIds<K extends R["kind"]>(kind: K): string[];
     /** Returns the currently-selected rows. */
     getSelectedRows(): GridDataRow<R>[];
+    getSelectedRows<K extends R["kind"]>(kind: K): GridDataRow<DiscriminateUnion<R, "kind", K>>[];
     /** Sets the internal state of 'activeRowId' */
     setActiveRowId: (id: string | undefined) => void;
 };

package/dist/components/Table/GridTable.js

@@ -95,12 +95,20 @@ function GridTable(props) {
     const tableRef = (0, react_1.useRef)(null);
     const api = (0, react_1.useRef)({
         scrollToIndex: (index) => virtuosoRef.current && virtuosoRef.current.scrollToIndex(index),
-        getSelectedRowIds: () => rowState.selectedIds,
-        getSelectedRows() {
+        getSelectedRowIds(kind) {
+            if (kind === undefined) {
+                return rowState.selectedIds;
+            }
+            else {
+                return this.getSelectedRows(kind).map((row) => row.id);
+            }
+        },
+        // The any is not great, but getting the overload to handle the optional kind is annoying
+        getSelectedRows(kind) {
             const ids = rowState.selectedIds;
             const selected = [];
             (0, visitor_1.visit)(rows, (row) => {
-                if (ids.includes(row.id)) {
+                if (ids.includes(row.id) && (!kind || row.kind === kind)) {
                     selected.push(row);
                 }
             });
@@ -113,7 +121,7 @@ function GridTable(props) {
     }
     (0, react_1.useEffect)(() => {
         rowState.activeRowId = activeRowId;
-    }, [activeRowId]);
+    }, [rowState, activeRowId]);
     // We track render count at the table level, which seems odd (we should be able to track this
     // internally within each GridRow using a useRef), but we have suspicions that react-virtuoso
     // (or us) is resetting component state more than necessary, so we track render counts from
@@ -209,12 +217,14 @@ function GridTable(props) {
         observeRows,
         columnSizes,
         collapsedIds,
+        getCount,
     ]);
     let tooManyClientSideRows = false;
     if (filterMaxRows && filteredRows.length > filterMaxRows) {
         tooManyClientSideRows = true;
         filteredRows = filteredRows.slice(0, filterMaxRows);
     }
+    rowState.visibleRows.replace(filteredRows.map(([row]) => { var _a; return (_a = row === null || row === void 0 ? void 0 : row.id) !== null && _a !== void 0 ? _a : ""; }));
     // Push back to the caller a way to ask us where a row is.
     const { rowLookup } = props;
     if (rowLookup) {

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

@@ -1,3 +1,4 @@
+import { ObservableSet } from "mobx";
 import React, { MutableRefObject } from "react";
 import { GridDataRow } from "./GridTable";
 export declare type SelectedState = "checked" | "unchecked" | "partial";
@@ -21,6 +22,7 @@ export declare class RowState {
     private persistCollapse;
     private readonly collapsedRows;
     private readonly selectedRows;
+    visibleRows: ObservableSet<string>;
     activeRowId: string | undefined;
     /**
      * Creates the `RowState` for a given `GridTable`.

package/dist/components/Table/RowState.js

@@ -30,6 +30,8 @@ class RowState {
         this.rows = rows;
         this.persistCollapse = persistCollapse;
         this.selectedRows = new mobx_1.ObservableMap();
+        // Set of just row ids. Keeps track of which rows are visible. Used to filter out non-visible rows from `selectedIds`
+        this.visibleRows = new mobx_1.ObservableSet();
         this.collapsedRows = new mobx_1.ObservableSet(persistCollapse ? readLocalCollapseState(persistCollapse) : []);
         this.activeRowId = activeRowId;
         // Make ourselves an observable so that mobx will do caching of .collapseIds so
@@ -38,7 +40,9 @@ class RowState {
     }
     get selectedIds() {
         // Return only ids that are fully checked, i.e. not partial
-        const ids = [...this.selectedRows.entries()].filter(([, v]) => v === "checked").map(([k]) => k);
+        const ids = [...this.selectedRows.entries()]
+            .filter(([id, v]) => this.visibleRows.has(id) && v === "checked")
+            .map(([k]) => k);
         // Hide our header marker
         const headerIndex = ids.indexOf("header");
         if (headerIndex > -1) {

package/dist/hooks/useComputed.js

@@ -6,7 +6,7 @@ const react_1 = require("react");
 /** Evaluates a computed function `fn` to a regular value and triggers a re-render whenever it changes. */
 function useComputed(fn, deps) {
     // We always return the useRef value, and use this just to trigger re-renders
-    const [, setValue] = (0, react_1.useState)(0);
+    const [, setTick] = (0, react_1.useState)(0);
     const ref = (0, react_1.useRef)({
         runner: undefined,
         value: undefined,
@@ -17,25 +17,25 @@ function useComputed(fn, deps) {
     // with `useEffect`, which would only get calc'd after the 1st render has
     // already been done.
     (0, react_1.useMemo)(() => {
-        let tick = 0;
         const { current } = ref;
         // If deps has changed, unhook the previous observer
         if (current.runner) {
             current.runner();
         }
+        // If deps has changed, we're already re-running, so don't trigger a 2nd one
+        current.hasRan = false;
         current.runner = (0, mobx_1.autorun)(() => {
             // Always eval fn() (even on 1st render) to register our observable.
             const newValue = fn();
-            const oldValue = current.value;
+            const { value: oldValue, hasRan: oldHasRun } = current;
             current.value = newValue;
             current.hasRan = true;
             // Only trigger a re-render if this is not the 1st autorun. Note
             // that if deps has changed, we're inherently in a re-render so also
             // don't need to trigger an additional re-render.
-            if (tick > 0 && newValue !== oldValue) {
-                setValue(tick);
+            if (oldHasRun && newValue !== oldValue) {
+                setTick((tick) => tick + 1);
             }
-            tick++;
         });
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, deps);

package/package.json

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