@homebound/beam 2.378.1 → 2.379.1

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

@@ -1,34 +0,0 @@
-import { MutableRefObject } from "react";
-import { ListRange, VirtuosoHandle } from "react-virtuoso";
-import { GridDataRow } from "../components/Row";
-import { GridTableApiImpl } from "../GridTableApi";
-import { DiscriminateUnion, GridColumnWithId, Kinded } from "../types";
-/**
- * Allows a caller to ask for the currently shown rows, given the current sorting/filtering.
- *
- * We will probably end up generalizing this into a GridTableApi that exposes more
- * actions i.e. scrolling to a row and selection state.
- */
-export interface GridRowLookup<R extends Kinded> {
-    /** Returns both the immediate next/prev rows, as well as `[kind].next/prev` values, ignoring headers. */
-    lookup(row: GridDataRow<R>, additionalFilter?: (row: GridDataRow<R>) => boolean): NextPrev<R> & {
-        [P in R["kind"]]: NextPrev<DiscriminateUnion<R, "kind", P>>;
-    };
-    /** Returns the list of currently filtered/sorted rows, without headers. */
-    currentList(): readonly GridDataRow<R>[];
-    /**
-     * Scroll's to the row with the given kind + id. Requires using `as=virtual`.
-     * Will skip re-scrolling to a row if it's already visible.
-     */
-    scrollTo(kind: R["kind"], id: string): void;
-}
-interface NextPrev<R extends Kinded> {
-    next: GridDataRow<R> | undefined;
-    prev: GridDataRow<R> | undefined;
-}
-export declare function createRowLookup<R extends Kinded>(api: GridTableApiImpl<R>, virtuosoRef: MutableRefObject<VirtuosoHandle | null>, virtuosoRangeRef: MutableRefObject<ListRange | null>): GridRowLookup<R>;
-export declare function getKinds<R extends Kinded>(columns: GridColumnWithId<R>[]): R[];
-/** Optionally takes into consideration if a row is already in view before attempting to scroll to it. */
-export declare function shouldSkipScrollTo(index: number, virtuosoRangeRef: MutableRefObject<ListRange | null>): boolean;
-export {};
-//# sourceMappingURL=GridRowLookup.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"GridRowLookup.d.ts","sourceRoot":"","sources":["../../../../src/components/Table/utils/GridRowLookup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,0BAA4C;AAClE,OAAO,EAAE,gBAAgB,EAAE,wBAA0C;AACrE,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,EAAyB,iBAAmC;AAEhH;;;;;GAKG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM;IAC7C,yGAAyG;IACzG,MAAM,CACJ,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,EACnB,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,OAAO,GAClD,QAAQ,CAAC,CAAC,CAAC,GAAG;SACd,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;KAC5D,CAAC;IAEF,2EAA2E;IAC3E,WAAW,IAAI,SAAS,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;IAEzC;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7C;AAED,UAAU,QAAQ,CAAC,CAAC,SAAS,MAAM;IACjC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACjC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;CAClC;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAC9C,GAAG,EAAE,gBAAgB,CAAC,CAAC,CAAC,EACxB,WAAW,EAAE,gBAAgB,CAAC,cAAc,GAAG,IAAI,CAAC,EACpD,gBAAgB,EAAE,gBAAgB,CAAC,SAAS,GAAG,IAAI,CAAC,GACnD,aAAa,CAAC,CAAC,CAAC,CA8ClB;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAI9E;AAED,yGAAyG;AACzG,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB,CAAC,SAAS,GAAG,IAAI,CAAC,WAUrG"}

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

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRowLookup = createRowLookup;
-exports.getKinds = getKinds;
-exports.shouldSkipScrollTo = shouldSkipScrollTo;
-const types_1 = require("../types");
-function createRowLookup(api, virtuosoRef, virtuosoRangeRef) {
-    return {
-        scrollTo(kind, id) {
-            if (virtuosoRef.current === null) {
-                // In theory we could support as=div and as=table by finding the DOM
-                // element and calling .scrollIntoView, just not doing that yet.
-                throw new Error("scrollTo is only supported for as=virtual");
-            }
-            const index = api.tableState.visibleRows.findIndex((r) => r && r.kind === kind && r.row.id === id);
-            if (shouldSkipScrollTo(index, virtuosoRangeRef))
-                return;
-            virtuosoRef.current.scrollToIndex({ index, behavior: "smooth" });
-        },
-        currentList() {
-            return api.tableState.visibleRows.map((rs) => rs.row);
-        },
-        lookup(row, additionalFilter = () => true) {
-            const rows = this.currentList().filter(additionalFilter);
-            const columns = api.tableState.visibleColumns;
-            // Ensure we have `result.kind = {}` for each kind
-            const result = Object.fromEntries(getKinds(columns).map((kind) => [kind, {}]));
-            // This is an admittedly cute/fancy scan, instead of just `rows.findIndex`, but
-            // we do it this way so that we can do kind-aware prev/next detection.
-            let key = "prev";
-            for (let i = 0; i < rows.length; i++) {
-                const each = rows[i];
-                // Flip from prev to next when we find it
-                if (each.kind === row.kind && each.id === row.id) {
-                    key = "next";
-                }
-                else {
-                    if (key === "prev") {
-                        // prev always overwrites what was there before
-                        result[key] = each;
-                        result[each.kind][key] = each;
-                    }
-                    else {
-                        // next only writes first seen
-                        result[key] ??= each;
-                        result[each.kind][key] ??= each;
-                    }
-                }
-            }
-            return result;
-        },
-    };
-}
-function getKinds(columns) {
-    return Object.keys(columns.find((c) => !c.isAction) || {}).filter((key) => !types_1.nonKindGridColumnKeys.includes(key));
-}
-/** Optionally takes into consideration if a row is already in view before attempting to scroll to it. */
-function shouldSkipScrollTo(index, virtuosoRangeRef) {
-    if (!virtuosoRangeRef.current)
-        return false;
-    const isAlreadyInView = 
-    // Add 1 on each end to account for "overscan" where the next out of view row is usually already rendered. This isn't a perfect solution,
-    // but our current "overscan" is only set to 50px, so it should be close enough and the library recommended alternative of adding an
-    // intersection observer to each row seems like a not worth it performance hit (https://github.com/petyosi/react-virtuoso/issues/118)
-    index >= virtuosoRangeRef.current.startIndex - 1 && index <= virtuosoRangeRef.current.endIndex + 1;
-    return isAlreadyInView;
-}

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

@@ -1,128 +0,0 @@
-import { Kinded } from "../../..";
-import { GridDataRow } from "../components/Row";
-import { GridRowApi } from "../GridTableApi";
-import { RowStates } from "./RowStates";
-import { SelectedState } from "./TableState";
-export declare enum DraggedOver {
-    None = 0,
-    Above = 1,// In this case this means higher on the screen which means a lower y value and a lower row index
-    Below = 2
-}
-/**
- * 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<R extends Kinded> {
-    private states;
-    parent: RowState<R> | undefined;
-    /** Our row, not actually observed, b/c each `createRows` calc creates unstable rows. */
-    private _row;
-    /** Our data, only ref observed, so we don't crawl into GraphQL fragments. */
-    private _data;
-    /** Our children row states, as of the latest `props.rows`, without any filtering applied. */
-    children: RowState<R>[] | undefined;
-    /** Whether we are *directly* selected. */
-    selected: boolean;
-    /** Whether we are collapsed. */
-    collapsed: boolean;
-    /** Whether we are dragged over. */
-    isDraggedOver: DraggedOver;
-    /**
-     * Whether our `row` had been in `props.rows`, but then removed _while being
-     * selected_, i.e. potentially by server-side filters.
-     *
-     * We have had a large foot-gun where users "select a row", change the filters,
-     * the row disappears (filtered out), and the user clicks "Go!", but the table
-     * thinks their previously-selected row is gone (b/c it's not in view), and
-     * then the row is inappropriately deleted/unassociated/etc. (b/c in the user's
-     * head, it is "still selected").
-     *
-     * To avoid this, we by default keep selected rows, as "kept rows", to make
-     * extra sure the user wants them to go away.
-     *
-     * Soft-deleted rows are rows that were removed from `props.rows` (i.e. we
-     * suspect are just hidden by a changed server-side-filter), and hard-deleted
-     * rows are rows the page called `api.deleteRow` and confirmed it should be
-     * actively removed.
-     */
-    removed: false | "soft" | "hard";
-    private isCalculatingDirectMatch;
-    constructor(states: RowStates<R>, parent: RowState<R> | undefined, row: GridDataRow<R>);
-    /** Returns a stable-ish row identity that will only change if our `data` changes. */
-    get row(): GridDataRow<R>;
-    /** Accepts a new unstable row, i.e. each `createRows` creates a new row literal. */
-    set row(row: GridDataRow<R>);
-    /**
-     * Whether we match a client-side filter; true if no filter is in place.
-     *
-     * We should try and keep this based solely on "does/does not match the filter",
-     * and do any overrides for things like pinning/kept rows/etc. elsewhere.
-     */
-    get isMatched(): boolean;
-    /**
-     * Whether we are effectively 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;
-    /** Marks the row as removed from `props.rows`, to potentially become kept. */
-    markRemoved(): void;
-    toggleCollapsed(): void;
-    /** Whether this is a selected-but-filtered-out row that we should hoist to the top. */
-    get isKept(): boolean;
-    get isLastKeptRow(): boolean;
-    get key(): string;
-    get kind(): string;
-    get isActive(): boolean;
-    get level(): number;
-    private get inferSelectedState();
-    /** Returns this row and, if we're not collapsed, our children. */
-    get selfAndMaybeChildren(): RowState<R>[];
-    private get visibleChildren();
-    private get visibleDirectlyMatchedChildren();
-    /** The `visibleChildren`, but with the current sort config applied. */
-    private get visibleSortedChildren();
-    private get hasSelectableChildren();
-    /**
-     * 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();
-    private get isPinned();
-    get api(): GridRowApi<R>;
-    get isReservedKind(): boolean;
-    /** A dedicated method to "looking down" recursively, to avoid loops in `isMatched`. */
-    private get hasDirectlyMatchedChildren();
-    /** A dedicated method to "looking up" recursively, to avoid loops in `isMatched`. */
-    private get hasDirectlyMatchedParent();
-    private get isDirectlyMatched();
-}
-//# sourceMappingURL=RowState.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"RowState.d.ts","sourceRoot":"","sources":["../../../../src/components/Table/utils/RowState.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,iBAAY;AAC7B,OAAO,EAAE,WAAW,EAAE,0BAA4C;AAClE,OAAO,EAAE,UAAU,EAAE,wBAA0C;AAC/D,OAAO,EAAE,SAAS,EAAE,oBAA6C;AACjE,OAAO,EAAE,aAAa,EAAE,qBAA8C;AAGtE,oBAAY,WAAW;IACrB,IAAI,IAAA;IACJ,KAAK,IAAA,CAAE,iGAAiG;IACxG,KAAK,IAAA;CACN;AAED;;;;;GAKG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,MAAM;IAmClC,OAAO,CAAC,MAAM;IACP,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS;IAnCxC,wFAAwF;IACxF,OAAO,CAAC,IAAI,CAAkB;IAC9B,6EAA6E;IAC7E,OAAO,CAAC,KAAK,CAAU;IACvB,6FAA6F;IAC7F,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAa;IAChD,0CAA0C;IAC1C,QAAQ,UAAS;IACjB,gCAAgC;IAChC,SAAS,UAAS;IAClB,mCAAmC;IACnC,aAAa,EAAE,WAAW,CAAoB;IAC9C;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAAS;IACzC,OAAO,CAAC,wBAAwB,CAAS;gBAG/B,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EACrB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,EACtC,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC;IA4BrB,qFAAqF;IACrF,IAAI,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,CAGxB;IAED,oFAAoF;IACpF,IAAI,GAAG,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,EAM1B;IAED;;;;;OAKG;IACH,IAAI,SAAS,IAAI,OAAO,CAQvB;IAED;;;;;;;OAOG;IACH,IAAI,UAAU,IAAI,OAAO,CAIxB;IAED,4EAA4E;IAC5E,IAAI,aAAa,IAAI,aAAa,CAajC;IAED;;;;;OAKG;IACH,IAAI,sBAAsB,IAAI,aAAa,CAkB1C;IAED;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI;IAY/B,8EAA8E;IAC9E,WAAW,IAAI,IAAI;IAMnB,eAAe,IAAI,IAAI;IAIvB,uFAAuF;IACvF,IAAI,MAAM,IAAI,OAAO,CAWpB;IAED,IAAI,aAAa,IAAI,OAAO,CAI3B;IAED,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,IAAI,KAAK,IAAI,MAAM,CAGlB;IAED,OAAO,KAAK,kBAAkB,GAE7B;IAED,kEAAkE;IAClE,IAAI,oBAAoB,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAOxC;IAED,OAAO,KAAK,eAAe,GAY1B;IAeD,OAAO,KAAK,8BAA8B,GAWzC;IAED,uEAAuE;IACvE,OAAO,KAAK,qBAAqB,GAOhC;IAED,OAAO,KAAK,qBAAqB,GAEhC;IAED;;;;;;;;;;OAUG;IACH,OAAO,KAAK,QAAQ,GAGnB;IAED,OAAO,KAAK,QAAQ,GAEnB;IAGD,IAAW,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAmB9B;IAED,IAAW,cAAc,IAAI,OAAO,CAEnC;IAED,uFAAuF;IACvF,OAAO,KAAK,0BAA0B,GAIrC;IAED,qFAAqF;IACrF,OAAO,KAAK,wBAAwB,GAEnC;IAED,OAAO,KAAK,iBAAiB,GAqB5B;CAMF"}

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

@@ -1,351 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RowState = exports.DraggedOver = void 0;
-const mobx_1 = require("mobx");
-const utils_1 = require("./utils");
-var DraggedOver;
-(function (DraggedOver) {
-    DraggedOver[DraggedOver["None"] = 0] = "None";
-    DraggedOver[DraggedOver["Above"] = 1] = "Above";
-    DraggedOver[DraggedOver["Below"] = 2] = "Below";
-})(DraggedOver || (exports.DraggedOver = DraggedOver = {}));
-/**
- * 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 {
-    states;
-    parent;
-    /** Our row, not actually observed, b/c each `createRows` calc creates unstable rows. */
-    _row;
-    /** Our data, only ref observed, so we don't crawl into GraphQL fragments. */
-    _data;
-    /** Our children row states, as of the latest `props.rows`, without any filtering applied. */
-    children = undefined;
-    /** Whether we are *directly* selected. */
-    selected = false;
-    /** Whether we are collapsed. */
-    collapsed = false;
-    /** Whether we are dragged over. */
-    isDraggedOver = DraggedOver.None;
-    /**
-     * Whether our `row` had been in `props.rows`, but then removed _while being
-     * selected_, i.e. potentially by server-side filters.
-     *
-     * We have had a large foot-gun where users "select a row", change the filters,
-     * the row disappears (filtered out), and the user clicks "Go!", but the table
-     * thinks their previously-selected row is gone (b/c it's not in view), and
-     * then the row is inappropriately deleted/unassociated/etc. (b/c in the user's
-     * head, it is "still selected").
-     *
-     * To avoid this, we by default keep selected rows, as "kept rows", to make
-     * extra sure the user wants them to go away.
-     *
-     * Soft-deleted rows are rows that were removed from `props.rows` (i.e. we
-     * suspect are just hidden by a changed server-side-filter), and hard-deleted
-     * rows are rows the page called `api.deleteRow` and confirmed it should be
-     * actively removed.
-     */
-    removed = false;
-    isCalculatingDirectMatch = false;
-    constructor(states, parent, row) {
-        this.states = states;
-        this.parent = parent;
-        this.row = row;
-        this.selected = !!row.initSelected;
-        this.collapsed = states.storage.wasCollapsed(row.id) ?? !!row.initCollapsed;
-        (0, mobx_1.makeAutoObservable)(this, 
-        // 'as any' because the fields are private so don't show up in the type
-        {
-            _row: false,
-            _data: mobx_1.observable.ref,
-            isCalculatingDirectMatch: false,
-        }, { name: `RowState@${row.id}` });
-        // Ideally we could hook up this reaction conditionally, but for the header RowState,
-        // we're initialized by GridTableApiImpl, before TableState.onRowSelect has a chance
-        // to be set to GridTableProps.onRowSelect, so for now just always hook up this reaction.
-        (0, mobx_1.reaction)(() => this.selectedState, (state) => {
-            const isSelected = state === "checked";
-            const tableFn = states.table.onRowSelect?.[this.row.kind];
-            tableFn && tableFn(this.row.data, isSelected, { row, api: states.table.api });
-        });
-    }
-    /** Returns a stable-ish row identity that will only change if our `data` changes. */
-    get row() {
-        // This is a noop, but makes mobx see `_data` as a dependency
-        return Object.assign(this._row, { data: this._data });
-    }
-    /** Accepts a new unstable row, i.e. each `createRows` creates a new row literal. */
-    set row(row) {
-        // If `_data` is a stable GraphQL fragment, but row is just a new literal around
-        // it, this won't actually cause any reactivity changes. But once _data does change,
-        // then anyone watching `.row` will see the new row instance + new data.
-        this._row = row;
-        this._data = row.data;
-    }
-    /**
-     * Whether we match a client-side filter; true if no filter is in place.
-     *
-     * We should try and keep this based solely on "does/does not match the filter",
-     * and do any overrides for things like pinning/kept rows/etc. elsewhere.
-     */
-    get isMatched() {
-        return (this.isDirectlyMatched ||
-            // A matched parent means show all it's children
-            this.hasDirectlyMatchedParent ||
-            // An unmatched parent but with matched children means show the parent
-            this.hasDirectlyMatchedChildren);
-    }
-    /**
-     * Whether we are effectively 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 there are no selectable children, we should return "checked" if the parent is selected.
-        if (this.isParent && this.hasSelectableChildren) {
-            // Use visibleChildren b/c if filters are hiding some of our children, we still want to show fully selected
-            const children = this.visibleChildren.filter((c) => c.row.selectable !== false);
-            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 there are no selectable children, we should return "checked" if the parent is selected.
-        if (this.children && this.hasSelectableChildren) {
-            const children = this.visibleChildren.filter((c) => c.row.selectable !== false || c.isParent);
-            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) {
-            this.selected = selected;
-        }
-        if (this.inferSelectedState) {
-            for (const child of this.visibleChildren) {
-                child.select(selected);
-            }
-        }
-    }
-    /** Marks the row as removed from `props.rows`, to potentially become kept. */
-    markRemoved() {
-        // The kept group is never in `props.rows`, so ignore asks to delete it
-        if (this.row.kind === utils_1.KEPT_GROUP)
-            return;
-        this.removed = this.selected && this.removed !== "hard" ? "soft" : "hard";
-    }
-    toggleCollapsed() {
-        this.collapsed = !this.collapsed;
-    }
-    /** 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
-            !this.isReservedKind &&
-            !this.isParent &&
-            (!this.isMatched || this.removed === "soft"));
-    }
-    get isLastKeptRow() {
-        if (!this.isKept)
-            return false;
-        const { keptRows } = this.states.table;
-        return keptRows[keptRows.length - 1] === this;
-    }
-    get key() {
-        return `${this.row.kind}-${this.row.id}`;
-    }
-    get kind() {
-        return this.row.kind;
-    }
-    get isActive() {
-        return this.states.table.activeRowId === `${this.row.kind}_${this.row.id}`;
-    }
-    get level() {
-        // Make the header level -1, so the top-level rows are level 0
-        return !this.parent ? -1 : this.parent.level + 1;
-    }
-    get inferSelectedState() {
-        return this.row.inferSelectedState !== false;
-    }
-    /** Returns this row and, if we're not collapsed, our children. */
-    get selfAndMaybeChildren() {
-        // The header always returns all children/top rows, even if collapsed
-        if (this.children && (!this.collapsed || this.row.kind === utils_1.HEADER)) {
-            return [this, ...this.visibleSortedChildren.flatMap((c) => c.selfAndMaybeChildren)];
-        }
-        else {
-            return [this];
-        }
-    }
-    get visibleChildren() {
-        // The keptGroup is special and its children are the dynamically kept rows
-        if (this.row.kind === utils_1.KEPT_GROUP)
-            return this.states.keptRows;
-        return (this.children?.filter((rs) => 
-        // Reserved rows are always visible, even though they're not considered matched.
-        // ...except for the kept group: its `isMatched` will become true whenever it has
-        // any kept row children, as they will cause its hasDirectlyMatchedChildren to be true.
-        (rs.isReservedKind && rs.row.kind !== utils_1.KEPT_GROUP) || rs.isMatched || rs.isPinned) ?? []);
-    }
-    // This is a copy/paste of visibleChildren, but using isDirectlyMatched instead of isMatched
-    // to avoid a cycle, i.e.:
-    //
-    // 1. A parent row evals its own isDirectlyMatched
-    // 2. The parent row has a cell that calculates "sum of visible children"
-    // 3. To know whether the sum cell matches the filter, "1234", we need to render the cell
-    // 4. If rendering the parent cell called `visibleChildren` directly, that method checks
-    //    "is the parent directly matched?" (so that child of matched parents are always shown),
-    //     but now we've looped--deciding the content of the parent cell itself requires knowing
-    //     if the parent cell matched (b/c that controls which children are visible).
-    //
-    // We side-step this by assuming that the `GridRowApi.getVisibleChildren` can use the
-    // slightly-less accurate "my children are visible if they're directly matched".
-    get visibleDirectlyMatchedChildren() {
-        if (this.row.kind === utils_1.KEPT_GROUP)
-            return this.states.keptRows;
-        return (this.children?.filter((rs) => (rs.isReservedKind && rs.row.kind !== utils_1.KEPT_GROUP) ||
-            rs.isDirectlyMatched ||
-            rs.hasDirectlyMatchedChildren ||
-            rs.isPinned) ?? []);
-    }
-    /** The `visibleChildren`, but with the current sort config applied. */
-    get visibleSortedChildren() {
-        let rows = this.visibleChildren;
-        const { sortFn } = this.states.table;
-        // We need to make a copy for mobx to see the sort as a change, and also to not mutate
-        // the original/unsorted array if we need to revert to the original sort order.
-        if (sortFn)
-            rows = [...rows].sort(sortFn);
-        return rows;
-    }
-    get hasSelectableChildren() {
-        return this.visibleChildren.some((c) => c.row.selectable !== false);
-    }
-    /**
-     * 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() {
-        // Check for KEPT_GROUP b/c it has `this.children = []` but we synthesize its children in `visibleChildren`
-        return !!this.children && (this.children.length > 0 || this.row.id === utils_1.KEPT_GROUP) && this.inferSelectedState;
-    }
-    get isPinned() {
-        return typeof this.row.pin === "string" || (!!this.row.pin && this.row.pin.filter !== true);
-    }
-    // mobx will cache this getter for us
-    get api() {
-        const rs = this;
-        // Copy the GridTableApi + the getVisibleChildren GridRowApi method
-        return {
-            ...this.states.table.api,
-            // The caller can invoke this observable without their own useComputed,
-            // b/c we wrap all rows in an observer
-            getVisibleChildren(kind) {
-                // Avoid infinite loop if a cell asks for getVisibleChildren while calculating isMatched
-                const children = rs.isCalculatingDirectMatch
-                    ? rs.visibleDirectlyMatchedChildren.map((cs) => cs.row)
-                    : rs.visibleChildren.map((cs) => cs.row);
-                return !kind ? children : children.filter((r) => r.kind === kind);
-            },
-            getSelectedChildren(kind) {
-                const children = (rs.children ?? []).filter((cs) => cs.isSelected).map((cs) => cs.row);
-                return !kind ? children : children.filter((r) => r.kind === kind);
-            },
-        };
-    }
-    get isReservedKind() {
-        return utils_1.reservedRowKinds.includes(this.row.kind);
-    }
-    /** A dedicated method to "looking down" recursively, to avoid loops in `isMatched`. */
-    get hasDirectlyMatchedChildren() {
-        // The keptGroup is special and its children are the dynamically kept rows
-        if (this.row.kind === utils_1.KEPT_GROUP)
-            return this.states.keptRows.length > 0;
-        return !!this.children && this.children.some((c) => c.isDirectlyMatched || c.hasDirectlyMatchedChildren);
-    }
-    /** A dedicated method to "looking up" recursively, to avoid loops in `isMatched`. */
-    get hasDirectlyMatchedParent() {
-        return !!this.parent && (this.parent.isDirectlyMatched || this.parent.hasDirectlyMatchedParent);
-    }
-    get isDirectlyMatched() {
-        this.isCalculatingDirectMatch = true;
-        try {
-            // Reserved rows like the header can never be directly matched, and treating them
-            // as matched currently throws off the header's select all/etc. behavior
-            if (this.isReservedKind)
-                return false;
-            // Ignore hard-deleted rows, i.e. from `api.deleteRows`; in theory any hard-deleted
-            // rows should be removed from `this.children` anyway, by a change to `props.rows`,
-            // but just in case the user calls _only_ `api.deleteRows`, and expects the row to
-            // go away, go ahead and filter them out here.
-            if (this.removed === "hard")
-                return false;
-            // Reacts to either search state or visibleColumns state changing
-            const { visibleColumns, search } = this.states.table;
-            return search.every((term) => visibleColumns
-                .map((c) => (0, utils_1.applyRowFn)(c, this.row, this.api, 0, false))
-                .some((maybeContent) => (0, utils_1.matchesFilter)(maybeContent, term)));
-        }
-        finally {
-            this.isCalculatingDirectMatch = false;
-        }
-    }
-    /** Used by node when doing `console.log(rs)`. */
-    [Symbol.for("nodejs.util.inspect.custom")]() {
-        return `RowState@${this.row.id}`;
-    }
-}
-exports.RowState = RowState;

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

@@ -1,41 +0,0 @@
-import { Kinded } from "../../..";
-import { GridDataRow } from "../components/Row";
-import { DraggedOver, RowState } from "./RowState";
-import { RowStorage } from "./RowStorage";
-import { TableState } from "./TableState";
-/**
- * Manages our tree of observable RowStates that manage each GridDataRow's behavior.
- */
-export declare class RowStates<R extends Kinded> {
-    private map;
-    readonly table: TableState<R>;
-    readonly storage: RowStorage<R>;
-    private readonly header;
-    private keptGroupRow;
-    /** The first level of rows, i.e. not the header (or kept group), but the totals + top-level children. */
-    private topRows;
-    constructor(table: TableState<R>);
-    /** Returns a flat list of all of our RowStates. */
-    get allStates(): RowState<R>[];
-    /** Returns the `RowState` for the given `id`. We should probably require `kind`. */
-    get(id: string): RowState<R>;
-    /**
-     * 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<R>[]): void;
-    /** Fully delete `ids`, so they don't show up in kept rows anymore. */
-    delete(ids: string[]): void;
-    /** Implements special collapse behavior, which is just the header's collapse/uncollapse. */
-    toggleCollapsed(id: string): void;
-    get visibleRows(): RowState<R>[];
-    /** Returns kept rows, i.e. those that were user-selected but then client-side or server-side filtered. */
-    get keptRows(): RowState<R>[];
-    get collapsedRows(): RowState<R>[];
-    private createHeaderRow;
-    /** Create our synthetic "group row" for kept rows, that users never pass in, but we self-inject as needed. */
-    private createKeptGroupRow;
-    maybeSetRowDraggedOver(id: string, draggedOver: DraggedOver, requireSameParentRow?: GridDataRow<R> | undefined): void;
-}
-//# sourceMappingURL=RowStates.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"RowStates.d.ts","sourceRoot":"","sources":["../../../../src/components/Table/utils/RowStates.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,iBAAY;AAC7B,OAAO,EAAE,WAAW,EAAE,0BAA4C;AAClE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,mBAA4C;AAC5E,OAAO,EAAE,UAAU,EAAE,qBAA8C;AACnE,OAAO,EAAE,UAAU,EAAE,qBAA8C;AAGnE;;GAEG;AACH,qBAAa,SAAS,CAAC,CAAC,SAAS,MAAM;IAErC,OAAO,CAAC,GAAG,CAA4C;IACvD,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IAC9B,QAAQ,CAAC,OAAO,gBAAwB;IAGxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IAErC,OAAO,CAAC,YAAY,CAAc;IAClC,yGAAyG;IACzG,OAAO,CAAC,OAAO,CAAqB;gBAExB,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;IAQhC,mDAAmD;IACnD,IAAI,SAAS,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAE7B;IAED,oFAAoF;IACpF,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC;IAM5B;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI;IAuDrC,sEAAsE;IACtE,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE;IAQpB,4FAA4F;IAC5F,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IA0BjC,IAAI,WAAW,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAM/B;IAED,0GAA0G;IAC1G,IAAI,QAAQ,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAE5B;IAED,IAAI,aAAa,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAEjC;IAED,OAAO,CAAC,eAAe;IAKvB,8GAA8G;IAC9G,OAAO,CAAC,kBAAkB;IAiB1B,sBAAsB,CACpB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,WAAW,EACxB,oBAAoB,GAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAqB,GAC3D,IAAI;CAwBR"}