nexus-shared 3.2.0 → 4.1.0

package/dist/Helpers/TableStore.js

@@ -1,6 +1,6 @@
 import { errorMessage, isAbortError } from "./ApiResponses.js";
 import { activeFilters } from "./TableFilters.js";
-import { DEFAULT_MAX_SELECTION, DEFAULT_PAGE_SIZE, MIN_COLUMN_WIDTH, clampPage, moveColumnKey, nextSort, queryRows, readTablePage, rowKeyText } from "./TableHelpers.js";
+import { DEFAULT_MAX_SELECTION, DEFAULT_PAGE_SIZE, MIN_COLUMN_WIDTH, clampPage, columnPin, moveColumnKey, nextSort, queryRows, readTablePage, rowKeyText } from "./TableHelpers.js";
 /** How long a changed or added row stays highlighted. */
 export const TABLE_FLASH_MS = 1600;
 const EMPTY_MAP = new Map();
@@ -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);
@@ -505,12 +562,17 @@ export class TableStore {
             return;
         this.set({ widths: NO_WIDTHS });
     }
-    /** Keeps a column on the left or the right while the others scroll, or lets it scroll again (`null`). */
+    /**
+     * Keeps a column on the left or the right while the others scroll, or lets it scroll again (`null`). A choice equal
+     * to the column's own `pinned` is no change to remember; unpinning a column its params pin is remembered as `null`,
+     * which wins over them.
+     */
     setPinned(key, side) {
-        if ((this.state.pinned[key] ?? null) === side)
+        const own = this.options.columns.find(column => column.key === key)?.pinned ?? null;
+        if (columnPin({ key, pinned: own ?? undefined }, this.state.pinned) === side)
             return;
         const pinned = { ...this.state.pinned };
-        if (side === null)
+        if (side === own)
             delete pinned[key];
         else
             pinned[key] = side;

package/dist/Helpers/ToolbarFit.d.ts

@@ -0,0 +1,23 @@
+/** The sizes a toolbar is laid out with, in pixels. */
+export interface ToolbarSizes {
+    /** A button's width. */
+    tool: number;
+    /** A divider's width with its margins. */
+    divider: number;
+    /** The gap between two items. */
+    gap: number;
+    /** The "More" button's width. Default `tool`. */
+    more?: number;
+}
+/** What a toolbar of a width shows: its items in order, dividers among them, and the tools left for the menu. */
+export interface ToolbarFit<T extends string> {
+    shown: (T | "|")[];
+    hidden: T[];
+}
+/**
+ * The items of a toolbar that fit `width`, in order, and the rest for its "More" menu. All of them when they fit; else
+ * as many as fit beside the "More" button, with no divider left at the end of the row and none in the menu.
+ *
+ * @example fitToolbar(["bold", "italic", "|", "link"], 70, { tool: 28, divider: 11, gap: 2 }) // { shown: ["bold"], hidden: ["italic", "link"] }
+ */
+export declare function fitToolbar<T extends string>(items: readonly (T | "|")[], width: number, sizes: ToolbarSizes): ToolbarFit<T>;

package/dist/Helpers/ToolbarFit.js

@@ -0,0 +1,30 @@
+/*
+ * A toolbar that keeps to one row: which of its buttons fit the room it has, and which go into its "More" menu. Pure,
+ * so it is checked without a browser; an editor measures its row and its sizes and draws what this answers.
+ */
+/**
+ * The items of a toolbar that fit `width`, in order, and the rest for its "More" menu. All of them when they fit; else
+ * as many as fit beside the "More" button, with no divider left at the end of the row and none in the menu.
+ *
+ * @example fitToolbar(["bold", "italic", "|", "link"], 70, { tool: 28, divider: 11, gap: 2 }) // { shown: ["bold"], hidden: ["italic", "link"] }
+ */
+export function fitToolbar(items, width, sizes) {
+    const size = (item) => (item === "|" ? sizes.divider : sizes.tool);
+    const all = items.reduce((total, item, index) => total + size(item) + (index > 0 ? sizes.gap : 0), 0);
+    if (all <= width)
+        return { shown: [...items], hidden: [] };
+    const room = width - (sizes.more ?? sizes.tool) - sizes.gap;
+    let used = 0;
+    let count = 0;
+    for (const item of items) {
+        const next = size(item) + (count > 0 ? sizes.gap : 0);
+        if (used + next > room)
+            break;
+        used += next;
+        count++;
+    }
+    const shown = items.slice(0, count);
+    while (shown.length > 0 && shown[shown.length - 1] === "|")
+        shown.pop();
+    return { shown, hidden: items.slice(count).filter((item) => item !== "|") };
+}

package/dist/Helpers/TreeStore.d.ts

@@ -38,7 +38,34 @@ export interface TreeStoreOptions<TItem extends TreeItem = TreeItem> {
      * than 0). Without it, or when the field is empty, a node counts as having children until its first page answers.
      */
     hasChildrenKey?: string;
+    /** The leaves shown at the start: see `TreeStore.setFilter`. Default: all. */
+    filter?: TreeFilterMatch<TItem> | null;
 }
+/**
+ * Which leaves a filtered tree shows (`TreeStore.setFilter`): asked of every item without children. A parent shows when it
+ * holds a leaf the filter shows; one whose children are still to load (a lazy tree) shows too, since they may.
+ */
+export type TreeFilterMatch<TItem extends TreeItem = TreeItem> = (item: TItem) => boolean;
+/** One tab of a tree's filters (TreeView `filters`): what it is called, and the leaves it shows. */
+export interface TreeFilter<TItem extends TreeItem = TreeItem> {
+    /** Unique among the filters: what `defaultFilter`, the kept choice and `onFilterChange` name. */
+    id: string;
+    /** The tab's text, e.g. "View only". */
+    label: string;
+    /** The tab's tooltip. */
+    title?: string;
+    /** The leaves it shows, asked of every item without children. Left out: all of them (an "All" tab). */
+    match?: TreeFilterMatch<TItem>;
+}
+/** Where a tree keeps the filter chosen in this browser: per `key` and `viewer`, nothing without a viewer. */
+export declare function treeFilterStorageKey(remember: {
+    key: string;
+    viewer?: string | null;
+} | undefined): string | null;
+/** The filter on: the one chosen, else the default, else the first; `undefined` without filters. An id no filter has is passed over. */
+export declare function shownTreeFilter<TFilter extends {
+    id: string;
+}>(filters: readonly TFilter[] | undefined, chosen: string | null | undefined, defaultId?: string): TFilter | undefined;
 /** A row that is not an item, under a parent of a lazy tree: its page is on its way, failed (Retry), or more can be loaded. */
 export type TreeStatusKind = "loading" | "error" | "more";
 /** Where a lazy parent's children stand: what was asked of the loader, and what it said. */
@@ -78,6 +105,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 +151,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. */
@@ -137,6 +216,21 @@ export interface TreeNode<TItem extends TreeItem = TreeItem> {
      * cannot be checked or unchecked as a whole (see `TreeStore.toggle`), and never shows checked unless the value names it.
      */
     partial: boolean;
+    /**
+     * A row of the filtered tree (`TreeStore.setFilter`): a leaf the filter shows, a parent holding one, a draft, or a lazy
+     * item whose children are still to load. Always true without a filter.
+     */
+    shown: boolean;
+    /** Children that are `shown`: all of them without a filter. */
+    shownChildren: number;
+    /**
+     * `leaves`, `checkedLeaves`, `openLeaves` and `openChecked` over the leaves the filter shows - what a box, a count and a
+     * check of a parent work on while a filter is on. The same numbers without a filter. The value never reads them.
+     */
+    shownLeaves: number;
+    shownChecked: number;
+    shownOpenLeaves: number;
+    shownOpenChecked: number;
     /**
      * Set only on a status row, a row that is not an item: under its `parent` (`null`: the top level) a page is on its
      * way, failed, or more can be loaded. A status row is in `rows` only - never in `children`, the value, or the items -
@@ -200,7 +294,23 @@ export declare class TreeStore<TItem extends TreeItem = TreeItem> {
     private openNodes;
     private openCheckedNodes;
     private indexCache;
+    /** The leaves shown (`setFilter`); `null`: all. */
+    private match;
+    /** Goes up whenever a node's counts are worked out again, so what is kept from them knows it is old. */
+    private counted;
+    private shownRoots;
     constructor(items?: readonly TItem[], options?: TreeStoreOptions<TItem>, value?: readonly TreeValue[]);
+    /** Whether a filter is on (`setFilter`). */
+    get filtered(): boolean;
+    /**
+     * Shows only the leaves `match` takes, and the parents that hold one (`null`: every item). Nothing is checked or
+     * unchecked by it, and the value is the same whatever filter is on. While one is on, a parent's box, its count, and a
+     * check of it - or of "select all" - work on the leaves shown only: checking a parent checks its shown leaves, and a
+     * leaf the filter hides keeps its check exactly as it was. Expanded items stay expanded.
+     */
+    setFilter(match: TreeFilterMatch<TItem> | null): void;
+    /** Children of a parent (`null`: the top level) that are rows of the filtered tree: all of them without a filter. */
+    shownChildCount(parent: TreeNode<TItem> | null): number;
     /** Items in the tree, drafts included. */
     get size(): number;
     /** The node of a value. */
@@ -228,11 +338,19 @@ export declare class TreeStore<TItem extends TreeItem = TreeItem> {
      * unloaded items are not in the value - unless the value names it (`valueMode: "checked"`, where it stands for all).
      */
     state(node: TreeNode<TItem>): TreeCheckState;
-    /** Checked boxes and all boxes: leaves with `cascade`, every item without it. Drafts count. */
+    /** The state of a parent over all of its leaves, whatever the filter shows. */
+    private wholeState;
+    private stateOver;
+    /** Checked boxes and all boxes: leaves with `cascade`, every item without it. Drafts count. The filter does not narrow it. */
     counts(): {
         checked: number;
         total: number;
     };
+    /** `counts` over what the filter shows: the leaves shown with `cascade`, the rows of items without it. */
+    shownCounts(): {
+        checked: number;
+        total: number;
+    };
     /**
      * The checked values, in tree order, following `valueMode`. In a lazy tree, values whose items are not loaded yet
      * (or not settled) follow the others, so a saved value survives until its items come.
@@ -254,16 +372,19 @@ export declare class TreeStore<TItem extends TreeItem = TreeItem> {
      * silently leave the rest out. The items under it whose own items are all loaded can still be checked one by one.
      */
     toggle(node: TreeNode<TItem>): boolean;
-    /** Checks or unchecks a node; with `cascade`, every item under it that is not locked. Returns whether anything changed. */
+    /**
+     * Checks or unchecks a node; with `cascade`, every item under it that is not locked - and, while a filter is on, that
+     * the filter shows: the hidden ones keep their checks. Returns whether anything changed.
+     */
     setChecked(node: TreeNode<TItem>, checked: boolean): boolean;
-    /** The state of a "select all" box, over the items that are not locked; `null` when every item is locked. */
+    /** The state of a "select all" box, over the items that are not locked (and shown); `null` when every one is locked. */
     allState(): TreeCheckState | null;
     /** What a click on a "select all" box does: checks every item that is not locked, or unchecks them all when all are checked. */
     toggleAll(): boolean;
     /**
-     * Checks or unchecks every item that is not locked. Returns whether anything changed. In a lazy tree with `cascade`,
-     * a node whose items are not all loaded is passed over and the loaded parts under it are changed; values whose
-     * items are not loaded stay as they are.
+     * Checks or unchecks every item that is not locked, and that the filter shows. Returns whether anything changed. In a
+     * lazy tree with `cascade`, a node whose items are not all loaded is passed over and the loaded parts under it are
+     * changed; values whose items are not loaded stay as they are.
      */
     checkAll(checked: boolean): boolean;
     /** Whether every parent of the node is expanded, so the node is a row. */
@@ -342,6 +463,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 +549,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 {};