nexus-shared 3.2.0 → 4.0.0

package/dist/Helpers/TableHelpers.js

@@ -72,9 +72,10 @@ function toNumber(value) {
 }
 /**
  * A value as the cell writes it, in the column's format: "1,250.00", "Rs. 4,500.00", "12.5%", the date and time in the
- * user's settings, "Yes" or "No", an option's label. Empty values give "".
+ * user's settings, "Yes" or "No", an option's label. Empty values give "". `row` is the record, for a currency the
+ * column reads from it (`currency: row => row.currencyText`).
  */
-export function formatCellText(column, value, options = {}) {
+export function formatCellText(column, value, options = {}, row) {
     const option = columnOption(column, value);
     if (option)
         return option.label;
@@ -90,7 +91,8 @@ export function formatCellText(column, value, options = {}) {
                 return String(value);
             const decimals = column.decimals ?? (column.format === "money" ? 2 : undefined);
             const text = formatNumber(number, { decimals, fixedDecimals: column.format === "money" || column.decimals !== undefined, grouping: true, locale: options.locale });
-            return `${prefix}${text}${column.format === "percent" && !suffix ? "%" : suffix}`;
+            const currency = column.format === "money" ? columnCurrency(column, options, row) : "";
+            return `${currency ? currency + " " : ""}${prefix}${text}${column.format === "percent" && !suffix ? "%" : suffix}`;
         }
         case "date":
             return formatDate(value, options.preferences) || String(value);
@@ -104,6 +106,11 @@ export function formatCellText(column, value, options = {}) {
             return `${prefix}${typeof value === "object" ? JSON.stringify(value) : String(value)}${suffix}`;
     }
 }
+/** A money column's currency: its own (a text, or read from the row), else the table's; "" for none. */
+export function columnCurrency(column, options = {}, row) {
+    const own = typeof column.currency === "function" ? (row ? column.currency(row) : undefined) : column.currency;
+    return (own ?? options.currency ?? "").trim();
+}
 /** Text the search looks in: the column's `text`, an option's label, or the value as text (dates as ISO text). */
 export function searchTextOf(column, row) {
     if (column.text)
@@ -256,18 +263,52 @@ export function moveColumnKey(keys, key, beforeKey) {
     rest.splice(at, 0, key);
     return rest;
 }
+/**
+ * The most of a table's width on screen that the columns staying in place may take: the numbers, the checkboxes and the
+ * actions, which always stay, and the pinned columns. Past it the pinned ones give way (`releasedPins`), so a phone
+ * keeps at least 40% of the table for the columns that scroll.
+ */
+export const PINNED_SHARE = 0.6;
+/**
+ * Which pinned columns scroll for now, the table being narrow: the pinned ones stay from the outer edge in - the left
+ * side first - while they and the columns that always stay (`frame`: the numbers and checkboxes, the actions; their
+ * width in pixels) take at most `share` of `view`, the width on screen; every one past that scrolls with the rest,
+ * and so do the ones inside it on the same side. `left` and `right`: each side's pinned columns with their widths,
+ * from the outer edge in. A table not laid out (`view` 0, in a closed tab) releases none.
+ */
+export function releasedPins(view, frame, left, right, share = PINNED_SHARE) {
+    const released = new Set();
+    if (!(view > 0))
+        return released;
+    const room = view * share;
+    let used = frame;
+    for (const side of [left, right]) {
+        let open = true;
+        for (const [key, width] of side) {
+            if (open && used + width <= room + 0.5)
+                used += width;
+            else {
+                open = false;
+                released.add(key);
+            }
+        }
+    }
+    return released;
+}
 /**
  * The columns as the table draws them: in the user's order, with the pinned ones moved to their side (keeping their
  * order among themselves), each with its width, its distance from that edge, and what the user may do with it.
  */
 export function viewColumns(columns, options = {}) {
-    const { order, pinned = {}, widths = {}, offsets = {}, reorderable = true, resizable = true } = options;
+    const { order, pinned = {}, widths = {}, offsets = {}, released, reorderable = true, resizable = true } = options;
     const groups = { left: [], middle: [], right: [] };
     for (const column of orderColumns(columns, order)) {
-        const pin = pinned[column.key] ?? column.pinned ?? null;
-        groups[pin === "left" ? "left" : pin === "right" ? "right" : "middle"].push({
+        const side = pinned[column.key] ?? column.pinned ?? null;
+        groups[side === "left" ? "left" : side === "right" ? "right" : "middle"].push({
             column,
-            pin,
+            // A pinned column the table is too narrow for keeps its side and scrolls with the rest.
+            pin: side && !released?.has(column.key) ? side : null,
+            side,
             offset: offsets[column.key] ?? 0,
             edge: false,
             resizable: resizable && column.resizable !== false,
@@ -275,11 +316,11 @@ export function viewColumns(columns, options = {}) {
             width: widths[column.key],
         });
     }
-    // The shadow that says columns scroll under a pinned side belongs to its last column.
-    const last = groups.left[groups.left.length - 1];
+    // The shadow that says columns scroll under a pinned side belongs to its last column that stays.
+    const last = groups.left.filter(view => view.pin).at(-1);
     if (last)
         last.edge = true;
-    const first = groups.right[0];
+    const first = groups.right.find(view => view.pin);
     if (first)
         first.edge = true;
     return [...groups.left, ...groups.middle, ...groups.right];

package/dist/Helpers/TableJoins.d.ts

@@ -29,6 +29,12 @@ export declare class TableJoins {
      * in - or that it is missing, on its way, or could not be read. A key nobody has asked for yet reads as on its way.
      */
     peek(name: string, key: string): JoinedState;
+    /**
+     * The record kept for `key` while its answer is fresh - within `lifetime`, and not marked old since (`expire`: a save
+     * there, a Reload) - at once and with no call; `undefined` otherwise. What names a value from a form's first draw
+     * without standing in for a record that may have changed since.
+     */
+    peekFresh(name: string, key: string, lifetime?: number): TableJoinedRecord | undefined;
     /**
      * Asks for every key the cache cannot answer fresh. The keys asked for in one moment - by every table and input on
      * the page - go in one call per source, after the moment is over; a key already on its way is not asked again.
@@ -36,6 +42,11 @@ export declare class TableJoins {
     request(source: TableJoinSource, keys: Iterable<string>): void;
     private queue;
     private send;
+    /**
+     * Records the page already holds, kept as if a lookup of `source` had just answered them: a form opened on a record
+     * whose parent the page shows - a tree's row - names that parent with no call.
+     */
+    remember(source: TableJoinSource, records: readonly TableJoinedRecord[]): void;
     /**
      * The records behind these keys, once they are in: what a picker shows for the values a form already holds. The
      * calls and the answers are the ones the tables share, so a form opened from a table costs nothing more.
@@ -45,6 +56,8 @@ export declare class TableJoins {
      * A whole list kept under `name` - a picker's options - loaded once per lifetime; a second ask while it loads waits for
      * the same call. A list that failed is not kept, so the next ask tries again.
      */
+    /** The list kept under `name` while it is fresh, without loading it; `undefined` when there is none yet, or it aged. */
+    peekList(name: string, lifetime?: number): readonly TableJoinedRecord[] | undefined;
     list(name: string, load: (signal: AbortSignal) => Promise<readonly TableJoinedRecord[]>, lifetime?: number): Promise<readonly TableJoinedRecord[]>;
     /**
      * Marks answers as old - a source's, some of its keys, or every one - after the records behind them may have changed:

package/dist/Helpers/TableJoins.js

@@ -65,6 +65,15 @@ export class TableJoins {
             return FAILED;
         return LOADING;
     }
+    /**
+     * The record kept for `key` while its answer is fresh - within `lifetime`, and not marked old since (`expire`: a save
+     * there, a Reload) - at once and with no call; `undefined` otherwise. What names a value from a form's first draw
+     * without standing in for a record that may have changed since.
+     */
+    peekFresh(name, key, lifetime = JOIN_LIFETIME) {
+        const entry = this.sources.get(name)?.entries.get(key);
+        return entry?.record && Date.now() - entry.at < lifetime ? entry.record : undefined;
+    }
     /**
      * Asks for every key the cache cannot answer fresh. The keys asked for in one moment - by every table and input on
      * the page - go in one call per source, after the moment is over; a key already on its way is not asked again.
@@ -136,6 +145,26 @@ export class TableJoins {
             this.notify();
         }
     }
+    /**
+     * Records the page already holds, kept as if a lookup of `source` had just answered them: a form opened on a record
+     * whose parent the page shows - a tree's row - names that parent with no call.
+     */
+    remember(source, records) {
+        const cache = this.cacheOf(source.name);
+        const keyField = source.key ?? "id";
+        const at = Date.now();
+        let changed = false;
+        for (const record of records) {
+            const key = record[keyField];
+            if (key === undefined || key === null || key === "")
+                continue;
+            cache.entries.set(String(key), { record, at });
+            cache.failedAt.delete(String(key));
+            changed = true;
+        }
+        if (changed)
+            this.notify();
+    }
     /**
      * The records behind these keys, once they are in: what a picker shows for the values a form already holds. The
      * calls and the answers are the ones the tables share, so a form opened from a table costs nothing more.
@@ -157,6 +186,11 @@ export class TableJoins {
      * A whole list kept under `name` - a picker's options - loaded once per lifetime; a second ask while it loads waits for
      * the same call. A list that failed is not kept, so the next ask tries again.
      */
+    /** The list kept under `name` while it is fresh, without loading it; `undefined` when there is none yet, or it aged. */
+    peekList(name, lifetime = JOIN_LIFETIME) {
+        const kept = this.lists.get(name);
+        return kept?.rows && Date.now() - kept.at < lifetime ? kept.rows : undefined;
+    }
     list(name, load, lifetime = JOIN_LIFETIME) {
         const kept = this.lists.get(name);
         if (kept?.pending)

package/dist/Helpers/TableStore.d.ts

@@ -10,6 +10,8 @@ export interface TableStoreOptions<TRow extends TableRow = TableRow> {
     paging: TablePaging;
     maxSelection?: number;
     onSelectionChange?: (rows: TRow[]) => void;
+    /** After the picked row changes: another row, its newest copy, or none (`DataTable` `onPick`). */
+    onPickChange?: (row: TRow | null) => void;
     /** The advanced filter's inputs, as the table prepared them (`asFilterInput`). */
     filterInputs?: readonly InputParams[];
 }
@@ -63,7 +65,10 @@ export declare class TableStore<TRow extends TableRow = TableRow> {
     /** Takes the component's props. Tells nobody: the component calls it while rendering. */
     configure(options: TableStoreOptions<TRow>): void;
     private set;
-    /** Puts back what was saved on this device (page size, sort, columns), before the first load. Tells nobody. */
+    /**
+     * Puts back what was saved on this device (page size, sort, columns): before the first load, telling nobody, or, with
+     * `notify`, over a table already shown (another key's settings), its rows shown again in them on the first page.
+     */
     restore(saved: {
         pageSize?: number;
         sort?: TableSort | null;
@@ -71,6 +76,8 @@ export declare class TableStore<TRow extends TableRow = TableRow> {
         order?: readonly string[];
         widths?: Readonly<Record<string, number>>;
         pinned?: Readonly<Record<string, TablePinSide>>;
+    }, options?: {
+        notify?: boolean;
     }): void;
     /** Shows these rows: every row there is. The table searches, sorts, and pages them. */
     setRows(rows: readonly TRow[]): void;
@@ -126,6 +133,19 @@ export declare class TableStore<TRow extends TableRow = TableRow> {
     private refreshSelected;
     /** A client table forgets selected rows that are gone from its rows. */
     private dropMissingSelection;
+    /**
+     * Picks a row (`DataTable` `onPick`), or none: the one row whose own records the page shows beside the table. It
+     * follows the record from then on - its newest copy after an upsert, none once it is removed or gone after a load -
+     * and every change is told to `onPickChange`.
+     */
+    pick(row: TRow | null): void;
+    /**
+     * The picked row as these rows hold it: its newest copy, or none when they are every row there is (`whole`, a client
+     * table) and it is not among them. A server page without it keeps it, since it may be on another page.
+     */
+    private followPicked;
+    /** Tells the page when a change left another copy of the picked row, or none. */
+    private pickedChanged;
     setBusy(keys: readonly TableKey[], on: boolean): void;
     flash(keys: readonly TableKey[]): void;
     setHidden(key: string, hidden: boolean): void;

package/dist/Helpers/TableStore.js

@@ -19,6 +19,7 @@ function initialState(pageSize) {
         matches: 0,
         query: { search: "", sort: null, page: 1, pageSize },
         selected: EMPTY_MAP,
+        picked: null,
         busy: EMPTY_SET,
         flashed: EMPTY_SET,
         hidden: EMPTY_SET,
@@ -103,13 +104,18 @@ export class TableStore {
         if (changes.selected && changes.selected !== previous.selected)
             this.options.onSelectionChange?.(this.getSelected());
     }
-    /** Puts back what was saved on this device (page size, sort, columns), before the first load. Tells nobody. */
-    restore(saved) {
+    /**
+     * Puts back what was saved on this device (page size, sort, columns): before the first load, telling nobody, or, with
+     * `notify`, over a table already shown (another key's settings), its rows shown again in them on the first page.
+     */
+    restore(saved, options = {}) {
         const query = { ...this.state.query };
         if (saved.pageSize && saved.pageSize > 0)
             query.pageSize = saved.pageSize;
         if (saved.sort !== undefined)
             query.sort = saved.sort;
+        if (options.notify)
+            query.page = 1;
         this.state = {
             ...this.state,
             query,
@@ -118,6 +124,8 @@ export class TableStore {
             widths: saved.widths ?? this.state.widths,
             pinned: saved.pinned ?? this.state.pinned,
         };
+        if (options.notify)
+            this.view();
     }
     /* Rows given by the page */
     /** Shows these rows: every row there is. The table searches, sorts, and pages them. */
@@ -127,7 +135,9 @@ export class TableStore {
         this.given = rows;
         this.all = [...rows];
         this.dropMissingSelection();
-        this.view({ status: "ready", error: null, refreshing: false });
+        const picked = this.state.picked;
+        this.view({ status: "ready", error: null, refreshing: false, picked: this.followPicked(this.all, true) });
+        this.pickedChanged(picked);
     }
     /* Loading */
     /**
@@ -151,6 +161,9 @@ export class TableStore {
             this.state = { ...this.state, query: { ...this.state.query, search: "", page: 1 } };
             if (this.state.selected.size)
                 this.set({ selected: EMPTY_MAP });
+            // Another list: the row picked in the one before is not in it.
+            if (this.state.picked)
+                this.pick(null);
         }
         const keepRows = quiet ?? (this.state.status === "ready" && !reset);
         const query = this.state.query;
@@ -197,6 +210,7 @@ export class TableStore {
                 void this.reload({ quiet: true });
                 return;
             }
+            const picked = this.state.picked;
             this.set({
                 status: "ready",
                 refreshing: false,
@@ -207,13 +221,17 @@ export class TableStore {
                 offset: (query.page - 1) * query.pageSize,
                 query,
                 selected: this.refreshSelected(page.rows),
+                picked: this.followPicked(page.rows, false),
             });
+            this.pickedChanged(picked);
             return;
         }
         this.all = page.rows;
         this.given = null;
         this.dropMissingSelection();
-        this.view({ status: "ready", refreshing: false, error: null });
+        const picked = this.state.picked;
+        this.view({ status: "ready", refreshing: false, error: null, picked: this.followPicked(this.all, true) });
+        this.pickedChanged(picked);
     }
     fail(error, seq) {
         if (seq !== this.seq)
@@ -301,6 +319,9 @@ export class TableStore {
      */
     upsert(row, { at = "start", flash = true } = {}) {
         const key = this.keyOf(row);
+        // The picked record's new copy is the one picked now.
+        const before = this.state.picked;
+        const picked = before && key && this.keyOf(before) === key ? row : before;
         if (this.options.paging === "server") {
             const index = this.state.rows.findIndex(candidate => this.keyOf(candidate) === key);
             const rows = [...this.state.rows];
@@ -315,7 +336,7 @@ export class TableStore {
                 total++;
                 matches++;
             }
-            this.set({ rows, total, matches, selected: this.replaceSelected(key, row), status: "ready" });
+            this.set({ rows, total, matches, selected: this.replaceSelected(key, row), picked, status: "ready" });
         }
         else {
             const index = this.all.findIndex(candidate => this.keyOf(candidate) === key);
@@ -326,8 +347,9 @@ export class TableStore {
             else
                 this.all.push(row);
             this.all = [...this.all];
-            this.view({ selected: this.replaceSelected(key, row), status: "ready" });
+            this.view({ selected: this.replaceSelected(key, row), picked, status: "ready" });
         }
+        this.pickedChanged(before);
         if (flash && key)
             this.flash([key]);
     }
@@ -355,6 +377,9 @@ export class TableStore {
         for (const key of gone)
             selected.delete(key);
         const busy = new Set([...this.state.busy].filter(key => !gone.has(key)));
+        // A picked record that left the list is no longer picked.
+        const before = this.state.picked;
+        const picked = before && gone.has(this.keyOf(before)) ? null : before;
         if (this.options.paging === "server") {
             const rows = this.state.rows.filter(row => !gone.has(this.keyOf(row)));
             const removed = this.state.rows.length - rows.length;
@@ -363,15 +388,18 @@ export class TableStore {
                 total: Math.max(0, this.state.total - removed),
                 matches: Math.max(0, this.state.matches - removed),
                 selected: selected.size === this.state.selected.size ? this.state.selected : selected,
+                picked,
                 busy,
             });
+            this.pickedChanged(before);
             // A short wait lets several removals (a mass action's rows) share one load.
             clearTimeout(this.reloadTimer);
             this.reloadTimer = setTimeout(() => void this.reload({ quiet: true }), 60);
             return;
         }
         this.all = this.all.filter(row => !gone.has(this.keyOf(row)));
-        this.view({ selected: selected.size === this.state.selected.size ? this.state.selected : selected, busy });
+        this.view({ selected: selected.size === this.state.selected.size ? this.state.selected : selected, picked, busy });
+        this.pickedChanged(before);
     }
     /* Selection */
     /** Selects or unselects rows, up to `maxSelection`. Returns how many rows it could not select. */
@@ -440,6 +468,35 @@ export class TableStore {
         this.state = { ...this.state, selected: selected.size ? selected : EMPTY_MAP };
         this.options.onSelectionChange?.(this.getSelected());
     }
+    /* The picked row */
+    /**
+     * Picks a row (`DataTable` `onPick`), or none: the one row whose own records the page shows beside the table. It
+     * follows the record from then on - its newest copy after an upsert, none once it is removed or gone after a load -
+     * and every change is told to `onPickChange`.
+     */
+    pick(row) {
+        const next = row !== null && this.keyOf(row) !== "" ? row : null;
+        if (next === this.state.picked)
+            return;
+        this.set({ picked: next });
+        this.options.onPickChange?.(next);
+    }
+    /**
+     * The picked row as these rows hold it: its newest copy, or none when they are every row there is (`whole`, a client
+     * table) and it is not among them. A server page without it keeps it, since it may be on another page.
+     */
+    followPicked(rows, whole) {
+        const picked = this.state.picked;
+        if (!picked)
+            return null;
+        const key = this.keyOf(picked);
+        return rows.find(row => this.keyOf(row) === key) ?? (whole ? null : picked);
+    }
+    /** Tells the page when a change left another copy of the picked row, or none. */
+    pickedChanged(before) {
+        if (this.state.picked !== before)
+            this.options.onPickChange?.(this.state.picked);
+    }
     /* Rows with an action running, and rows to highlight */
     setBusy(keys, on) {
         const busy = new Set(this.state.busy);

package/dist/Helpers/TreeStore.d.ts

@@ -78,6 +78,40 @@ export interface TreeChildrenPage<TItem extends TreeItem = TreeItem> {
     /** Whether another page follows. Default: `total` says so, or the page was full. */
     hasMore?: boolean;
 }
+/**
+ * A change to one item of a tree's source made somewhere else - a form saved, a record moved to the trash - written into
+ * the pages kept for the tree (`writeTreeChanges`) and into every tree on screen that shows them, so nothing is read
+ * from the server again for it.
+ */
+export type TreeItemChange<TItem extends TreeItem = TreeItem> = {
+    /** Added, changed, or moved: the item as it is now, under the item whose value is `parent` (`null`: the top level). */
+    type: "put";
+    item: TItem;
+    parent: TreeValue | null;
+    /**
+     * Where it was: its parent's value (`null`: the top level), or `false` when it was not in the tree at all - just
+     * added, or back from the trash. Left out when not known: a tree that holds the item knows, and the kept pages are
+     * searched; an item found nowhere then changes no count.
+     */
+    before?: TreeValue | null | false;
+} | {
+    /** Out of the tree - moved to the trash, deleted: the item's value, and its parent's when known. */
+    type: "remove";
+    value: TreeValue;
+    parent?: TreeValue | null;
+};
+/** How a tree reads its items, for changes written from outside it: the same keys the tree is given. */
+export interface TreeChangeRules<TItem extends TreeItem = TreeItem> {
+    /** The item field that holds its value: the tree's `valueKey`. Default `id`. */
+    valueKey?: string;
+    /** The tree's `hasChildrenKey`: a parent's count there goes up and down with its children, and its chevron with it. */
+    hasChildrenKey?: string;
+    /**
+     * The order of siblings, as the server sorts them, so an item added or changed goes where a fresh read would put it.
+     * Without it an added item goes after the children loaded, and a changed one stays where it was.
+     */
+    compare?: (a: TItem, b: TItem) => number;
+}
 /** Children's pages kept for every lazy tree on the page that names a `cacheKey`, for 5 minutes: see `RequestCache`. */
 export declare const treePages: RequestCache<TreeChildrenPage<object>>;
 /** The start of every key a tree keeps its pages under, or one parent's pages (`null`: the top level). */
@@ -90,6 +124,24 @@ export declare function treePageKey(cacheKey: string, parent: TreeValue | null,
  * its `refresh()` loads that again.
  */
 export declare function expireTreePages(cacheKey: string, parent?: TreeValue | null | readonly (TreeValue | null)[]): number;
+/**
+ * Writes changes made elsewhere into the pages kept for a tree's source, and into every tree on screen that keeps its
+ * pages under `cacheKey` - so a record saved in a form, moved, or sent to the trash shows in the tree at once, and
+ * leaving the page and coming back reads nothing again for it. Items go where the parent's children are known (see
+ * `TreeStore.placeItem`); a parent whose children were never loaded only counts one more or one fewer, and its first page
+ * comes from the server when it is opened, as it would have anyway.
+ */
+export declare function writeTreeChanges<TItem extends TreeItem>(cacheKey: string, changes: readonly TreeItemChange<TItem>[], rules?: TreeChangeRules<TItem>): void;
+type TreeChangeListener = (changes: readonly TreeItemChange[], rules: TreeChangeRules) => void;
+/** Hears the changes written for `cacheKey`: what a tree on screen does to write them into itself. Returns the way out. */
+export declare function subscribeTreeChanges(cacheKey: string, listener: TreeChangeListener): () => void;
+/**
+ * The kept pages under `cacheKey` with the changes written in (what `writeTreeChanges` does to `treePages`). A parent's
+ * pages are read as one list from its first child, the changes applied to it, and the list written back in pages of the
+ * same size, each with the parent's total - so a tree reading them again, page by page, asks the server for exactly the
+ * children it does not have. A page still on its way for a changed parent is dropped: its answer may predate the change.
+ */
+export declare function patchTreePages<TItem extends TreeItem>(cache: RequestCache<TreeChildrenPage>, cacheKey: string, changes: readonly TreeItemChange<TItem>[], rules?: TreeChangeRules<TItem>): void;
 /** A has-children field read as the tree reads it: a boolean, or a count above 0; `undefined` when it says nothing. */
 export declare function treeHasChildren(value: unknown): boolean | undefined;
 /** The key of the status row under a parent (`null`: the top level), as `TreeNode.key` holds it. */
@@ -342,6 +394,34 @@ export declare class TreeStore<TItem extends TreeItem = TreeItem> {
     }): void;
     /** Removes a node and everything under it. Returns the removed nodes in tree order. */
     remove(node: TreeNode<TItem>): TreeNode<TItem>[];
+    /**
+     * Writes an item where a change made elsewhere left it (see `TreeItemChange`): in place under the same parent (moved
+     * among its siblings by `compare`), under its new parent when it moved - with what is loaded under it - and in for the
+     * first time when it is new or back. Only where the parent's children are known: given, loaded, or known to be none.
+     * Under a parent never opened it waits for that parent's first page, and one that sorts after the loaded children while
+     * more are to come waits for its page. A lazy parent's `loaded` and `total` follow, so its next page skips the right
+     * number, and so does the count in `hasChildrenKey` on the parent's own item, which its chevron goes by. Returns the
+     * item's node where it is now, or `undefined` when this tree does not show it.
+     */
+    placeItem(item: TItem, parentValue: TreeValue | null, options?: {
+        before?: TreeValue | null | false;
+        compare?: (a: TItem, b: TItem) => number;
+    }): TreeNode<TItem> | undefined;
+    /**
+     * Takes out an item a change made elsewhere took out of the tree - moved to the trash, deleted - with everything under
+     * it. Its parent counts one fewer (its pages' `loaded` and `total`, the count on its item) and loses its chevron when
+     * none are left. An item not loaded here still lowers its parent's counts when `parentValue` names the parent.
+     * Returns the nodes taken out.
+     */
+    removeItem(value: TreeValue, parentValue?: TreeValue | null): TreeNode<TItem>[];
+    /** Whether a parent's children are known here: given in the items, loaded (all or the first pages), or known to be none. */
+    private listsChildren;
+    /**
+     * One child more or fewer under a parent (`null`: the top level): its pages' total, and the count its own item
+     * carries in `hasChildrenKey` - a new copy of the item. A parent never opened reads its children from the new count,
+     * so one that has none left loses its chevron; one whose children were loaded knows already.
+     */
+    private countChild;
     private createNode;
     /** A lazy node's pages before anything is asked: none to ask for when its item says it has no children. */
     private newPages;
@@ -400,3 +480,4 @@ export declare class TreeStore<TItem extends TreeItem = TreeItem> {
 }
 /** Nodes in tree order: each node, then its children. No recursion, so even a chain 100,000 levels deep works. */
 export declare function preOrder<TItem extends TreeItem>(nodes: readonly TreeNode<TItem>[]): TreeNode<TItem>[];
+export {};