nexus-shared 3.2.0 → 4.0.0

package/dist/Helpers/TreeStore.js

@@ -36,6 +36,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")
@@ -697,7 +903,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++,