nexus-shared 3.2.0 → 4.1.0

package/dist/Helpers/TreeStore.js

@@ -12,6 +12,17 @@
  * itself: the view asks, and tells the store what came back (`beginLoad`, `receivePage`, `failLoad`).
  */
 import { RequestCache } from "./RequestCache.js";
+/** Where a tree keeps the filter chosen in this browser: per `key` and `viewer`, nothing without a viewer. */
+export function treeFilterStorageKey(remember) {
+    const viewer = remember?.viewer?.trim();
+    return remember?.key && viewer ? `nx-tree-filter:${remember.key}:${viewer}` : 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 function shownTreeFilter(filters, chosen, defaultId) {
+    if (!filters || filters.length === 0)
+        return undefined;
+    return filters.find(filter => filter.id === chosen) ?? filters.find(filter => filter.id === defaultId) ?? filters[0];
+}
 /** Children's pages kept for every lazy tree on the page that names a `cacheKey`, for 5 minutes: see `RequestCache`. */
 export const treePages = new RequestCache();
 /** The start of every key a tree keeps its pages under, or one parent's pages (`null`: the top level). */
@@ -36,6 +47,212 @@ export function expireTreePages(cacheKey, parent) {
     const parents = new Set(parent.map(value => treeKey(value) ?? ""));
     return treePages.drop(key => key.startsWith(base) && parents.has(key.slice(base.length, key.indexOf("\u0000", base.length))));
 }
+/**
+ * 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 function writeTreeChanges(cacheKey, changes, rules = {}) {
+    if (changes.length === 0)
+        return;
+    patchTreePages(treePages, cacheKey, changes, rules);
+    for (const listener of [...(treeListeners.get(cacheKey) ?? [])])
+        listener(changes, rules);
+}
+const treeListeners = new Map();
+/** Hears the changes written for `cacheKey`: what a tree on screen does to write them into itself. Returns the way out. */
+export function subscribeTreeChanges(cacheKey, listener) {
+    let set = treeListeners.get(cacheKey);
+    if (!set)
+        treeListeners.set(cacheKey, (set = new Set()));
+    set.add(listener);
+    return () => {
+        set.delete(listener);
+        if (set.size === 0 && treeListeners.get(cacheKey) === set)
+            treeListeners.delete(cacheKey);
+    };
+}
+/**
+ * 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 function patchTreePages(cache, cacheKey, changes, rules = {}) {
+    const valueKey = rules.valueKey ?? TREE_DEFAULT_KEYS.value;
+    const keyOf = (item) => treeKey(read(item, valueKey));
+    const groups = keptChildren(cache, cacheKey);
+    const of = (parent) => groups.filter(group => group.parent === parent);
+    /** A parent's count, on its own item, wherever that item is kept. */
+    const count = (parent, delta) => {
+        if (parent === "" || rules.hasChildrenKey === undefined)
+            return;
+        const field = rules.hasChildrenKey;
+        const known = of(parent).find(group => group.total !== undefined)?.total;
+        for (const group of groups) {
+            const index = group.items.findIndex(item => keyOf(item) === parent);
+            if (index < 0)
+                continue;
+            const item = group.items[index];
+            const next = countedChildren(read(item, field), delta, known);
+            if (next === undefined)
+                continue;
+            group.items[index] = { ...item, [field]: next };
+            group.changed = true;
+        }
+    };
+    for (const change of changes) {
+        if (change.type === "put") {
+            const key = keyOf(change.item);
+            if (key === null)
+                continue;
+            const parent = treeKey(change.parent) ?? "";
+            let from = change.before === false ? false : change.before === undefined ? undefined : (treeKey(change.before) ?? "");
+            // Out of the list that holds it, remembering where, for an item that stays where it was.
+            const held = new Map();
+            for (const group of groups) {
+                const index = group.items.findIndex(item => keyOf(item) === key);
+                if (index < 0)
+                    continue;
+                from ??= group.parent;
+                group.items.splice(index, 1);
+                group.changed = true;
+                held.set(group, index);
+            }
+            const moved = typeof from === "string" && from !== parent;
+            if (moved) {
+                for (const group of of(from)) {
+                    if (group.total !== undefined)
+                        group.total = Math.max(0, group.total - 1);
+                    group.changed = true;
+                }
+            }
+            for (const group of of(parent)) {
+                if (!group.listed)
+                    continue;
+                const at = rules.compare ? insertionIndex(group.items, change.item, rules.compare) : Math.min(held.get(group) ?? group.items.length, group.items.length);
+                // After the children kept while more are to come: it is in a page not read yet.
+                if (at < group.items.length || !group.hasMore)
+                    group.items.splice(at, 0, change.item);
+                if ((moved || from === false) && group.total !== undefined)
+                    group.total++;
+                group.changed = true;
+            }
+            if (moved)
+                count(from, -1);
+            if (moved || from === false)
+                count(parent, 1);
+        }
+        else {
+            const key = treeKey(change.value);
+            if (key === null)
+                continue;
+            let from = change.parent === undefined ? undefined : (treeKey(change.parent) ?? "");
+            let found = false;
+            for (const group of groups) {
+                const index = group.items.findIndex(item => keyOf(item) === key);
+                if (index < 0)
+                    continue;
+                from ??= group.parent;
+                found = true;
+                group.items.splice(index, 1);
+                if (group.total !== undefined)
+                    group.total = Math.max(0, group.total - 1);
+                group.changed = true;
+            }
+            if (from === undefined)
+                continue;
+            // Not among the children kept: one of those not read yet, which the total still counted.
+            if (!found) {
+                for (const group of of(from)) {
+                    if (group.total !== undefined)
+                        group.total = Math.max(0, group.total - 1);
+                    group.changed = true;
+                }
+            }
+            count(from, -1);
+        }
+    }
+    for (const group of groups) {
+        if (!group.changed)
+            continue;
+        const prefix = treePagesKey(cacheKey, group.parent === "" ? null : group.parent);
+        const kept = new Set(group.keys);
+        cache.drop(key => kept.has(key) || (key.startsWith(prefix) && cache.isLoading(key)));
+        // A list emptied while more are to come has nothing to start from: the next open asks the server.
+        if (!group.listed || (group.items.length === 0 && group.hasMore))
+            continue;
+        const hasMore = group.total !== undefined ? group.items.length < group.total : group.hasMore;
+        const pages = Math.max(1, Math.ceil(group.items.length / group.take));
+        for (let page = 0; page < pages; page++) {
+            const items = group.items.slice(page * group.take, (page + 1) * group.take);
+            const last = page === pages - 1;
+            cache.set(treePageKey(cacheKey, group.parent === "" ? null : group.parent, page * group.take, group.take), { items, total: group.total, hasMore: last ? hasMore : true }, group.at);
+        }
+    }
+}
+/** The kept pages under `cacheKey`, by parent and page size, each read as one list from the parent's first child. */
+function keptChildren(cache, cacheKey) {
+    const base = treePagesKey(cacheKey);
+    const found = new Map();
+    for (const { key, value, at } of cache.entries(base)) {
+        const [parent, skipText, takeText] = key.slice(base.length).split(NUL);
+        const skip = Number(skipText);
+        const take = Number(takeText);
+        if (parent === undefined || !Number.isInteger(skip) || !Number.isInteger(take) || take < 1)
+            continue;
+        const id = `${parent}${NUL}${take}`;
+        let group = found.get(id);
+        if (!group)
+            found.set(id, (group = { parent, take, pages: [] }));
+        group.pages.push({ key, skip, page: value, at });
+    }
+    const groups = [];
+    for (const { parent, take, pages } of found.values()) {
+        pages.sort((a, b) => a.skip - b.skip);
+        const items = [];
+        let total;
+        let hasMore = false;
+        let at = Infinity;
+        for (const { skip, page, at: loadedAt } of pages) {
+            // A page that does not follow the last one cannot be placed: the list ends before it.
+            if (skip !== items.length)
+                break;
+            const pageItems = Array.isArray(page?.items) ? page.items : [];
+            items.push(...pageItems);
+            if (typeof page.total === "number" && Number.isFinite(page.total))
+                total = page.total;
+            hasMore = pageItems.length === 0 ? false : typeof page.hasMore === "boolean" ? page.hasMore : total !== undefined ? items.length < total : pageItems.length >= take;
+            at = Math.min(at, loadedAt);
+            if (!hasMore)
+                break;
+        }
+        const listed = pages[0]?.skip === 0;
+        groups.push({ parent, take, keys: pages.map(page => page.key), listed, items, total, hasMore, at: Number.isFinite(at) ? at : Math.min(...pages.map(page => page.at)), changed: false });
+    }
+    return groups;
+}
+/** Where an item goes among siblings in `compare`'s order: before the first that sorts after it. */
+function insertionIndex(items, item, compare) {
+    const index = items.findIndex(other => compare(item, other) < 0);
+    return index < 0 ? items.length : index;
+}
+/**
+ * A parent's has-children field after it gained (1) or lost (-1) a child: a count moves by one, `true` stays true and
+ * becomes it, and `false` comes only when the parent's total says none are left. `undefined` when nothing changes.
+ */
+function countedChildren(value, delta, total) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return Math.max(0, value + delta);
+    if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value)))
+        return Math.max(0, Number(value) + delta);
+    if (delta > 0)
+        return value === true ? undefined : true;
+    return value === true && total === 0 ? false : undefined;
+}
+const NUL = "\u0000";
 /** A has-children field read as the tree reads it: a boolean, or a count above 0; `undefined` when it says nothing. */
 export function treeHasChildren(value) {
     if (typeof value === "boolean")
@@ -104,6 +321,11 @@ export class TreeStore {
     openNodes = 0;
     openCheckedNodes = 0;
     indexCache = null;
+    /** The leaves shown (`setFilter`); `null`: all. */
+    match = null;
+    /** Goes up whenever a node's counts are worked out again, so what is kept from them knows it is old. */
+    counted = 0;
+    shownRoots = null;
     constructor(items = [], options = {}, value) {
         this.valueKey = options.valueKey ?? TREE_DEFAULT_KEYS.value;
         this.parentKey = options.parentKey ?? TREE_DEFAULT_KEYS.parent;
@@ -116,8 +338,40 @@ export class TreeStore {
         this.isChecked = options.isItemChecked ?? defaultChecked;
         if (this.lazy && options.lazyRoots)
             this.rootPages = idlePages();
+        this.match = options.filter ?? null;
         this.setItems(items, value);
     }
+    /** Whether a filter is on (`setFilter`). */
+    get filtered() {
+        return this.match !== null;
+    }
+    /**
+     * 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) {
+        this.match = match;
+        this.recount(preOrder(this.roots));
+        this.rows = this.visibleRows(this.roots, null);
+    }
+    /** Children of a parent (`null`: the top level) that are rows of the filtered tree: all of them without a filter. */
+    shownChildCount(parent) {
+        if (parent)
+            return parent.shownChildren;
+        if (this.match === null)
+            return this.roots.length;
+        // Counted once per change of counts, not once per row drawn.
+        if (this.shownRoots?.counted !== this.counted) {
+            let count = 0;
+            for (const root of this.roots)
+                if (root.shown)
+                    count++;
+            this.shownRoots = { counted: this.counted, count };
+        }
+        return this.shownRoots.count;
+    }
     /** Items in the tree, drafts included. */
     get size() {
         return this.byKey.size;
@@ -250,15 +504,22 @@ export class TreeStore {
      * unloaded items are not in the value - unless the value names it (`valueMode: "checked"`, where it stands for all).
      */
     state(node) {
+        return this.stateOver(node, node.shownChecked, node.shownLeaves);
+    }
+    /** The state of a parent over all of its leaves, whatever the filter shows. */
+    wholeState(node) {
+        return this.stateOver(node, node.checkedLeaves, node.leaves);
+    }
+    stateOver(node, checked, leaves) {
         if (!this.cascade || node.children.length === 0)
             return node.checked ? "checked" : "unchecked";
         if (node.partial)
-            return this.pending.has(node.key) ? "checked" : node.checkedLeaves > 0 ? "mixed" : "unchecked";
-        if (node.checkedLeaves === 0)
+            return this.pending.has(node.key) ? "checked" : checked > 0 ? "mixed" : "unchecked";
+        if (checked === 0)
             return "unchecked";
-        return node.checkedLeaves === node.leaves ? "checked" : "mixed";
+        return checked === leaves ? "checked" : "mixed";
     }
-    /** Checked boxes and all boxes: leaves with `cascade`, every item without it. Drafts count. */
+    /** Checked boxes and all boxes: leaves with `cascade`, every item without it. Drafts count. The filter does not narrow it. */
     counts() {
         if (!this.cascade)
             return { checked: this.checkedNodes, total: this.byKey.size };
@@ -270,6 +531,29 @@ export class TreeStore {
         }
         return { checked, total };
     }
+    /** `counts` over what the filter shows: the leaves shown with `cascade`, the rows of items without it. */
+    shownCounts() {
+        if (this.match === null)
+            return this.counts();
+        let checked = 0;
+        let total = 0;
+        if (this.cascade) {
+            for (const root of this.roots) {
+                checked += root.shownChecked;
+                total += root.shownLeaves;
+            }
+        }
+        else {
+            for (const node of this.byKey.values()) {
+                if (!node.shown)
+                    continue;
+                total++;
+                if (node.checked)
+                    checked++;
+            }
+        }
+        return { checked, total };
+    }
     /**
      * 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.
@@ -337,9 +621,12 @@ export class TreeStore {
             return false;
         if (!this.cascade)
             return this.setNodeChecked(node, !node.checked);
-        return this.setChecked(node, node.openChecked < node.openLeaves);
+        return this.setChecked(node, node.shownOpenChecked < node.shownOpenLeaves);
     }
-    /** 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, checked) {
         if (node.locked || node.status)
             return false;
@@ -353,7 +640,7 @@ export class TreeStore {
             this.dropClaimsAbove(node);
         return changed;
     }
-    /** 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() {
         let open = this.openNodes;
         let checked = this.openCheckedNodes;
@@ -361,8 +648,19 @@ export class TreeStore {
             open = 0;
             checked = 0;
             for (const root of this.roots) {
-                open += root.openLeaves;
-                checked += root.openChecked;
+                open += root.shownOpenLeaves;
+                checked += root.shownOpenChecked;
+            }
+        }
+        else if (this.match !== null) {
+            open = 0;
+            checked = 0;
+            for (const node of this.byKey.values()) {
+                if (!node.shown || node.locked)
+                    continue;
+                open++;
+                if (node.checked)
+                    checked++;
             }
         }
         if (open === 0)
@@ -375,9 +673,9 @@ export class TreeStore {
         return state !== null && this.checkAll(state !== "checked");
     }
     /**
-     * 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) {
         let changed = false;
@@ -387,7 +685,7 @@ export class TreeStore {
         }
         else {
             for (const node of preOrder(this.roots))
-                changed = (!node.locked && this.setNodeChecked(node, checked)) || changed;
+                changed = (!node.locked && node.shown && this.setNodeChecked(node, checked)) || changed;
         }
         return changed;
     }
@@ -396,6 +694,9 @@ export class TreeStore {
     isVisible(node) {
         if (node.status)
             return this.indexOf(node) >= 0;
+        // A node the filter hides is no row; a shown node's parents are shown too.
+        if (!node.shown)
+            return false;
         for (let parent = node.parent; parent; parent = parent.parent)
             if (!parent.expanded)
                 return false;
@@ -682,7 +983,7 @@ export class TreeStore {
         const removed = preOrder([node]);
         // A parent that loses its last child becomes a leaf, checked when all of its items were.
         if (parent && this.cascade && siblings.length === 1)
-            parent.checked = this.state(parent) === "checked";
+            parent.checked = this.wholeState(parent) === "checked";
         siblings.splice(index, 1);
         if (parent && parent.children.length === 0 && !this.canExpand(parent))
             parent.expanded = false;
@@ -697,7 +998,166 @@ export class TreeStore {
         this.rows = this.visibleRows(this.roots, null);
         return removed;
     }
+    /**
+     * 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, parentValue, options = {}) {
+        const key = treeKey(read(item, this.valueKey));
+        if (key === null)
+            return undefined;
+        const existing = this.byKey.get(key);
+        if (existing?.draft)
+            return undefined;
+        const parentKey = treeKey(parentValue);
+        const parent = parentKey === null ? null : this.byKey.get(parentKey);
+        // Where it was: its node knows, else the change says - or nobody does, and then no count moves.
+        let from;
+        if (existing)
+            from = existing.parent ? existing.parent.key : null;
+        else if (options.before === false)
+            from = false;
+        else if (options.before !== undefined)
+            from = treeKey(options.before);
+        const moved = from !== undefined && from !== false && from !== parentKey;
+        const valueBefore = this.value();
+        const oldParent = existing ? existing.parent : null;
+        let oldIndex = -1;
+        if (existing) {
+            const siblings = oldParent ? oldParent.children : this.roots;
+            oldIndex = siblings.indexOf(existing);
+            siblings.splice(oldIndex, 1);
+            const pages = this.pagesOf(oldParent);
+            if (pages && pages.loaded > 0)
+                pages.loaded--;
+        }
+        let node;
+        if (parent !== undefined && this.listsChildren(parent)) {
+            const siblings = parent ? parent.children : this.roots;
+            const pages = this.pagesOf(parent);
+            const at = options.compare ? insertionIndex(siblings.map(each => each.item), item, options.compare) : existing && !moved ? Math.min(oldIndex, siblings.length) : siblings.length;
+            if (at < siblings.length || !pages?.hasMore) {
+                node = existing ?? this.createNode(item, key);
+                node.parent = parent;
+                siblings.splice(at, 0, node);
+                if (pages)
+                    pages.loaded++;
+                if (!existing) {
+                    node.checked = this.arrivalChecked(node);
+                    this.byKey.set(key, node);
+                }
+            }
+        }
+        if (existing && !node) {
+            // It went where this tree has not loaded: out, with everything under it.
+            for (const each of preOrder([existing])) {
+                this.byKey.delete(each.key);
+                this.statusRows.delete(each.key);
+            }
+            existing.parent = null;
+        }
+        if (node) {
+            node.item = item;
+            node.value = read(item, this.valueKey);
+            node.label = labelOf(item, this.labelKey);
+            node.disabled = this.isDisabled(item);
+            // Nothing loaded under it: what the item says about its children counts.
+            if (this.lazy && node.children.length === 0 && node.pages && node.pages.status !== "loading")
+                node.pages = this.newPages(item);
+            for (const each of preOrder([node]))
+                each.depth = each.parent ? each.parent.depth + 1 : 0;
+        }
+        if (moved)
+            this.countChild(from, -1);
+        if (moved || from === false)
+            this.countChild(parentKey, 1);
+        // A parent left with no children and nothing more to load closes, and loses its chevron.
+        if (oldParent && oldParent.children.length === 0 && !this.canExpand(oldParent))
+            oldParent.expanded = false;
+        this.recount(preOrder(this.roots));
+        // A checked value whose item went out of view waits in the value for it to come back, as after a refresh.
+        const valueAfter = new Set(this.value().map(String));
+        for (const value of valueBefore)
+            if (!valueAfter.has(String(value)))
+                this.pending.set(String(value), value);
+        this.settleAll();
+        this.rows = this.visibleRows(this.roots, null);
+        return node;
+    }
+    /**
+     * 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, parentValue) {
+        const key = treeKey(value);
+        if (key === null)
+            return [];
+        const node = this.byKey.get(key);
+        if (node?.draft)
+            return [];
+        let removed = [];
+        if (node) {
+            const parent = node.parent;
+            const siblings = parent ? parent.children : this.roots;
+            siblings.splice(siblings.indexOf(node), 1);
+            const pages = this.pagesOf(parent);
+            if (pages && pages.loaded > 0)
+                pages.loaded--;
+            removed = preOrder([node]);
+            for (const each of removed) {
+                this.byKey.delete(each.key);
+                this.statusRows.delete(each.key);
+                this.pending.delete(each.key);
+            }
+            node.parent = null;
+            this.countChild(parent ? parent.key : null, -1);
+            if (parent && parent.children.length === 0 && !this.canExpand(parent))
+                parent.expanded = false;
+        }
+        else if (parentValue !== undefined) {
+            this.countChild(treeKey(parentValue), -1);
+        }
+        else {
+            return [];
+        }
+        this.recount(preOrder(this.roots));
+        this.settleAll();
+        this.rows = this.visibleRows(this.roots, null);
+        return removed;
+    }
     // Internals
+    /** Whether a parent's children are known here: given in the items, loaded (all or the first pages), or known to be none. */
+    listsChildren(parent) {
+        const pages = this.pagesOf(parent);
+        return !pages || pages.loaded > 0 || pages.status === "ready";
+    }
+    /**
+     * 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.
+     */
+    countChild(parentKey, delta) {
+        const parent = parentKey === null ? null : this.byKey.get(parentKey);
+        if (parent === undefined)
+            return;
+        const pages = this.pagesOf(parent);
+        if (pages?.total !== undefined)
+            pages.total = Math.max(0, pages.total + delta);
+        if (!parent || this.hasChildrenKey === undefined)
+            return;
+        const next = countedChildren(read(parent.item, this.hasChildrenKey), delta, pages?.total);
+        if (next !== undefined)
+            parent.item = { ...parent.item, [this.hasChildrenKey]: next };
+        if (this.lazy && parent.children.length === 0 && parent.pages?.status === "idle")
+            parent.pages = this.newPages(parent.item);
+    }
     createNode(item, key) {
         return {
             uid: this.nextUid++,
@@ -721,6 +1181,12 @@ export class TreeStore {
             draft: false,
             pages: this.lazy ? this.newPages(item) : undefined,
             partial: false,
+            shown: true,
+            shownChildren: 0,
+            shownLeaves: 1,
+            shownChecked: 0,
+            shownOpenLeaves: 0,
+            shownOpenChecked: 0,
         };
     }
     /** A lazy node's pages before anything is asked: none to ask for when its item says it has no children. */
@@ -769,6 +1235,8 @@ export class TreeStore {
         }
         for (let index = path.length - 1; index >= 0; index--)
             this.aggregate(path[index]);
+        if (this.match !== null && added.length > 0)
+            shownPositions(siblings);
         this.count(path, 1);
         this.count(added, 1);
         return added;
@@ -922,6 +1390,9 @@ export class TreeStore {
             stack.push(nodes[index]);
         while (stack.length > 0) {
             const node = stack.pop();
+            // Hidden by the filter, with everything under it.
+            if (!node.shown)
+                continue;
             list.push(node);
             if (!node.expanded)
                 continue;
@@ -971,6 +1442,12 @@ export class TreeStore {
                 openChecked: 0,
                 draft: false,
                 partial: false,
+                shown: true,
+                shownChildren: 0,
+                shownLeaves: 0,
+                shownChecked: 0,
+                shownOpenLeaves: 0,
+                shownOpenChecked: 0,
             };
             this.statusRows.set(parentKey, row);
         }
@@ -1006,6 +1483,12 @@ export class TreeStore {
         }
         for (let index = ordered.length - 1; index >= 0; index--)
             this.aggregate(ordered[index]);
+        // Under a filter a row's place among its siblings (aria-posinset) counts the shown ones only.
+        if (this.match !== null) {
+            shownPositions(this.roots);
+            for (const node of ordered)
+                shownPositions(node.children);
+        }
         this.checkedNodes = 0;
         this.openNodes = 0;
         this.openCheckedNodes = 0;
@@ -1016,6 +1499,7 @@ export class TreeStore {
      * does for every node, and what a page of children does for each node on its parent's path.
      */
     aggregate(node) {
+        this.counted++;
         const pages = node.pages;
         const own = pages !== undefined && (pages.status !== "ready" || pages.hasMore);
         if (node.children.length === 0) {
@@ -1027,6 +1511,14 @@ export class TreeStore {
             node.checkedLeaves = node.checked ? 1 : 0;
             node.openLeaves = fixed ? 0 : 1;
             node.openChecked = fixed ? 0 : node.checkedLeaves;
+            // A draft being named shows whatever the filter says: its name box must not vanish.
+            const matched = this.match === null || node.draft || this.match(node.item);
+            node.shown = matched || own;
+            node.shownChildren = 0;
+            node.shownLeaves = matched ? 1 : 0;
+            node.shownChecked = matched ? node.checkedLeaves : 0;
+            node.shownOpenLeaves = matched ? node.openLeaves : 0;
+            node.shownOpenChecked = matched ? node.openChecked : 0;
             return;
         }
         let leaves = 0;
@@ -1034,7 +1526,13 @@ export class TreeStore {
         let openLeaves = 0;
         let openChecked = 0;
         let allLocked = true;
+        let shownLocked = true;
         let partial = own;
+        let shownChildren = 0;
+        let shownLeaves = 0;
+        let shownChecked = 0;
+        let shownOpenLeaves = 0;
+        let shownOpenChecked = 0;
         for (const child of node.children) {
             leaves += child.leaves;
             checked += child.checkedLeaves;
@@ -1042,14 +1540,29 @@ export class TreeStore {
             openChecked += child.openChecked;
             allLocked &&= child.locked;
             partial ||= child.partial;
+            if (!child.shown)
+                continue;
+            shownChildren++;
+            shownLeaves += child.shownLeaves;
+            shownChecked += child.shownChecked;
+            shownOpenLeaves += child.shownOpenLeaves;
+            shownOpenChecked += child.shownOpenChecked;
+            shownLocked &&= child.locked;
         }
         node.leaves = leaves;
         node.checkedLeaves = checked;
         node.openLeaves = openLeaves;
         node.openChecked = openChecked;
         node.partial = partial;
-        // A parent's box follows its items only with cascade; without it, a parent stays free.
-        node.locked = node.disabledPath || (this.cascade && allLocked);
+        node.shown = this.match === null || shownChildren > 0 || own;
+        node.shownChildren = shownChildren;
+        node.shownLeaves = shownLeaves;
+        node.shownChecked = shownChecked;
+        node.shownOpenLeaves = shownOpenLeaves;
+        node.shownOpenChecked = shownOpenChecked;
+        // A parent's box follows its items only with cascade; without it, a parent stays free. Under a filter it follows the
+        // items shown: a parent whose shown items are all locked has nothing a check could change.
+        node.locked = node.disabledPath || (this.cascade && (this.match !== null && shownChildren > 0 ? shownLocked : allLocked));
     }
     /** Sets every open leaf under a node (the node itself for a leaf), updating counts up the path of each leaf that changes. */
     setLeaves(node, checked) {
@@ -1057,8 +1570,9 @@ export class TreeStore {
         const stack = [node];
         while (stack.length > 0) {
             const current = stack.pop();
-            // A subtree that is locked, or already all checked or all unchecked, has nothing to change.
-            if (current.locked || current.openChecked === (checked ? current.openLeaves : 0))
+            // A subtree that is locked, or whose shown leaves are already all checked or all unchecked, has nothing to change:
+            // a leaf the filter hides counts in no `shown` number, so it is never reached.
+            if (current.locked || current.shownOpenChecked === (checked ? current.shownOpenLeaves : 0))
                 continue;
             if (current.children.length > 0) {
                 for (const child of current.children)
@@ -1070,6 +1584,8 @@ export class TreeStore {
             for (let path = current; path; path = path.parent) {
                 path.checkedLeaves += step;
                 path.openChecked += step;
+                path.shownChecked += step;
+                path.shownOpenChecked += step;
             }
             changed = true;
         }
@@ -1084,10 +1600,16 @@ export class TreeStore {
         if (!node.locked)
             this.openCheckedNodes += step;
         if (node.children.length === 0) {
+            const shown = node.shownLeaves === 1;
             for (let path = node; path; path = path.parent) {
                 path.checkedLeaves += step;
                 if (!node.locked)
                     path.openChecked += step;
+                if (!shown)
+                    continue;
+                path.shownChecked += step;
+                if (!node.locked)
+                    path.shownOpenChecked += step;
             }
         }
         return true;
@@ -1152,6 +1674,13 @@ function valueMap(values) {
     }
     return map;
 }
+/** Numbers siblings among the shown ones (`position`), as a filtered tree's rows are read out. */
+function shownPositions(siblings) {
+    let position = 0;
+    for (const node of siblings)
+        if (node.shown)
+            node.position = position++;
+}
 /** Nodes in tree order: each node, then its children. No recursion, so even a chain 100,000 levels deep works. */
 export function preOrder(nodes) {
     const list = [];