@gtkx/components 1.6.0 → 2.0.0-beta.10

package/src/internal/cells.tsx

@@ -3,8 +3,8 @@ import type { ReactElement, ReactNode } from "react";
 import * as Gtk from "@gtkx/gi/gtk";
 import { GtkSignalListItemFactory, GtkTreeExpander } from "@gtkx/jsx/gtk";
 import { createPortal, useProperty } from "@gtkx/react";
-import { setObjectProperty, t } from "@gtkx/runtime";
-import { memo, useLayoutEffect, useState, useSyncExternalStore } from "react";
+import { setProperty, t } from "@gtkx/runtime";
+import { memo, useInsertionEffect, useLayoutEffect, useRef, useState, useSyncExternalStore } from "react";
 import type {
     ExpanderDescriptions,
     ListItem,
@@ -34,6 +34,7 @@ type CellHost = FactoryHost & {
 type CellEntry<H extends FactoryHost> = {
     key: string;
     host: H;
+    identity: ItemIdentityStore;
 };
 
 type FactoryHandlers = {
@@ -88,14 +89,34 @@ type ItemSlot = {
     args: ListItemRenderArgs<unknown>;
 };
 
+type CollectionState = {
+    collection: Collection;
+    expandedIds: string[] | null | undefined;
+};
+
+type CollectionStateStore = {
+    read: () => CollectionState;
+    write: (state: CollectionState) => void;
+};
+
+type ItemIdentity = {
+    item: ListItem | undefined;
+    position: number;
+    isExpanded: boolean;
+};
+
+type ItemIdentityStore = {
+    read: () => ItemIdentity | null;
+    write: (identity: ItemIdentity) => void;
+};
+
 type ItemCellProps = {
     entry: CellEntry<Gtk.ListItem>;
     render: ListItemRenderer<never>;
-    collection: Collection;
+    state: CollectionStateStore;
     hasExpander: boolean;
-    expandedIds: string[] | null | undefined;
     expanderDescriptions: ExpanderDescriptions | null | undefined;
-};
+} & ItemIdentity;
 
 type ItemPortalsProps = {
     registry: CellRegistry<Gtk.ListItem>;
@@ -109,9 +130,8 @@ type ItemPortalsProps = {
 type ItemRowProps = {
     entry: CellEntry<Gtk.ColumnViewRow>;
     rowProps: ListRowPropsResolver<never>;
-    collection: Collection;
-    expandedIds: string[] | null | undefined;
-};
+    state: CollectionStateStore;
+} & ItemIdentity;
 
 type RowPortalsProps = {
     registry: CellRegistry<Gtk.ColumnViewRow>;
@@ -142,8 +162,8 @@ type RowSlot = {
     portals: ReactNode;
 };
 
-const ItemCell = memo(ItemCellImpl);
-const ItemRow = memo(ItemRowImpl);
+const ItemCell = memo(ItemCellImpl, isSameItemCell);
+const ItemRow = memo(ItemRowImpl, isSameItemRow);
 const HeaderCell = memo(HeaderCellImpl);
 const CELL_OPTIONS: CellRegistryOptions<Gtk.ListItem> = { isHost: isListItem, prepare: prepareCell };
 const HEADER_OPTIONS: CellRegistryOptions<Gtk.ListHeader> = { isHost: isListHeader, prepare: prepareCell };
@@ -184,7 +204,7 @@ function notifyRegistry<H extends FactoryHost>(state: CellRegistryState<H>): voi
 function createEntry<H extends FactoryHost>(state: CellRegistryState<H>, host: H): CellEntry<H> {
     state.serial += 1;
 
-    return { key: `gtkx-cell-${String(state.serial)}`, host };
+    return { key: `gtkx-cell-${String(state.serial)}`, host, identity: createItemIdentityStore() };
 }
 
 function setupHost<H extends FactoryHost>(state: CellRegistryState<H>, host: H): void {
@@ -283,9 +303,13 @@ function isRowWanted(options: ItemSlotOptions, item: ListItem): boolean {
     return options.expandedIds?.includes(item.id) ?? false;
 }
 
-function itemArgs(item: ListItem, options: ItemSlotOptions): ListItemRenderArgs<unknown> {
-    const args: ListItemRenderArgs<unknown> = { item: item.value, index: options.position ?? 0 };
-    const row = options.row;
+function itemArgs(
+    item: ListItem,
+    position: number | undefined,
+    row: Gtk.TreeListRow | null,
+    isExpanded: boolean,
+): ListItemRenderArgs<unknown> {
+    const args: ListItemRenderArgs<unknown> = { item: item.value, index: position ?? 0 };
 
     if (row === null) {
         return args;
@@ -294,7 +318,7 @@ function itemArgs(item: ListItem, options: ItemSlotOptions): ListItemRenderArgs<
     args.depth = row.getDepth();
 
     if (row.isExpandable()) {
-        args.isExpanded = isRowWanted(options, item);
+        args.isExpanded = isExpanded;
     }
 
     return args;
@@ -308,21 +332,127 @@ function slotFor(options: ItemSlotOptions): ItemSlot | null {
         return null;
     }
 
-    return { item, row: options.row, args: itemArgs(item, options) };
+    return {
+        item,
+        row: options.row,
+        args: itemArgs(item, options.position, options.row, isRowWanted(options, item)),
+    };
 }
 
 function useItemSlot(
     entry: CellEntry<PositionedHost>,
-    collection: Collection,
-    expandedIds: string[] | null | undefined,
+    state: CollectionStateStore,
+    identity: ItemIdentity,
 ): ItemSlot | null {
     const position = useProperty(entry.host, "position");
     const item = useProperty(entry.host, "item") ?? null;
     const row = item instanceof Gtk.TreeListRow ? item : null;
 
+    if (position === identity.position) {
+        return identity.item === undefined
+            ? null
+            : {
+                    item: identity.item,
+                    row,
+                    args: itemArgs(identity.item, position, row, identity.isExpanded),
+                };
+    }
+
+    const { collection, expandedIds } = state.read();
+
     return slotFor({ item, position, row, collection, expandedIds });
 }
 
+function itemIdentity(
+    entry: CellEntry<PositionedHost>,
+    collection: Collection,
+    expandedIds: string[] | null | undefined,
+): ItemIdentity {
+    const ref = slotRefFor(entry.host.getItem());
+    const item = ref === null ? undefined : collection.itemAt(ref);
+
+    return {
+        item,
+        position: entry.host.getPosition(),
+        isExpanded: item === undefined ? false : (expandedIds?.includes(item.id) ?? false),
+    };
+}
+
+function isSameItemIdentity(previous: ItemIdentity, next: ItemIdentity): boolean {
+    return (
+        previous.item === next.item &&
+        previous.position === next.position &&
+        previous.isExpanded === next.isExpanded
+    );
+}
+
+function isSameItemCell(previous: ItemCellProps, next: ItemCellProps): boolean {
+    const identity = previous.entry.identity.read() ?? previous;
+
+    return (
+        previous.entry === next.entry &&
+        previous.render === next.render &&
+        previous.hasExpander === next.hasExpander &&
+        previous.expanderDescriptions === next.expanderDescriptions &&
+        isSameItemIdentity(identity, next)
+    );
+}
+
+function isSameItemRow(previous: ItemRowProps, next: ItemRowProps): boolean {
+    const identity = previous.entry.identity.read() ?? previous;
+
+    return previous.entry === next.entry && previous.rowProps === next.rowProps && isSameItemIdentity(identity, next);
+}
+
+function createItemIdentityStore(): ItemIdentityStore {
+    let current: ItemIdentity | null = null;
+
+    return {
+        read: () => current,
+        write: (identity) => {
+            current = identity;
+        },
+    };
+}
+
+function renderedIdentity(entry: CellEntry<PositionedHost>, slot: ItemSlot | null): ItemIdentity {
+    return {
+        item: slot?.item,
+        position: slot?.args.index ?? entry.host.getPosition(),
+        isExpanded: slot?.args.isExpanded ?? false,
+    };
+}
+
+function useRememberIdentity(entry: CellEntry<PositionedHost>, slot: ItemSlot | null): void {
+    useLayoutEffect(() => {
+        entry.identity.write(renderedIdentity(entry, slot));
+    });
+}
+
+function createCollectionStateStore(initial: CollectionState): CollectionStateStore {
+    let current = initial;
+
+    return {
+        read: () => current,
+        write: (state) => {
+            current = state;
+        },
+    };
+}
+
+function useCollectionState(
+    collection: Collection,
+    expandedIds: string[] | null | undefined,
+): CollectionStateStore {
+    const [state] = useState(() => createCollectionStateStore({ collection, expandedIds }));
+
+    useInsertionEffect(() => {
+        state.write({ collection, expandedIds });
+    }, [state, collection, expandedIds]);
+
+    return state;
+}
+
 function expanderDescriptionFor(
     slot: ItemSlot,
     descriptions: ExpanderDescriptions | null | undefined,
@@ -402,38 +532,60 @@ function rowPropsFor(slot: ItemSlot | null, rowProps: ListRowPropsResolver<never
 }
 
 function setRowText(host: Gtk.ColumnViewRow, name: string, value: string | null): void {
-    setObjectProperty(host, name, ROW_TEXT_DESCRIPTOR, value);
+    setProperty(host, name, ROW_TEXT_DESCRIPTOR, value);
 }
 
-function applyRowProps(host: Gtk.ColumnViewRow, props: ResolvedRowProps): void {
-    setRowText(host, "accessible-label", props.accessibleLabel);
-    setRowText(host, "accessible-description", props.accessibleDescription);
-    host.setActivatable(props.isActivatable);
-    host.setFocusable(props.isFocusable);
-    host.setSelectable(props.isSelectable);
+function applyRowProps(
+    host: Gtk.ColumnViewRow,
+    props: ResolvedRowProps,
+    previous: ResolvedRowProps | null,
+): void {
+    if (previous?.accessibleLabel !== props.accessibleLabel) {
+        setRowText(host, "accessible-label", props.accessibleLabel);
+    }
+
+    if (previous?.accessibleDescription !== props.accessibleDescription) {
+        setRowText(host, "accessible-description", props.accessibleDescription);
+    }
+
+    if (previous?.isActivatable !== props.isActivatable) {
+        host.setActivatable(props.isActivatable);
+    }
+
+    if (previous?.isFocusable !== props.isFocusable) {
+        host.setFocusable(props.isFocusable);
+    }
+
+    if (previous?.isSelectable !== props.isSelectable) {
+        host.setSelectable(props.isSelectable);
+    }
 }
 
 function ItemCellImpl({
     entry,
     render,
-    collection,
+    state,
     hasExpander,
-    expandedIds,
     expanderDescriptions,
+    ...identity
 }: ItemCellProps): ReactNode {
-    const slot = useItemSlot(entry, collection, expandedIds);
+    const slot = useItemSlot(entry, state, identity);
+    useRememberIdentity(entry, slot);
     const body = itemBody(slot, render, hasExpander, expanderDescriptions);
 
     return createPortal(body, entry.host, entry.key);
 }
 
-function ItemRowImpl({ entry, rowProps, collection, expandedIds }: ItemRowProps): ReactNode {
-    const slot = useItemSlot(entry, collection, expandedIds);
+function ItemRowImpl({ entry, rowProps, state, ...identity }: ItemRowProps): ReactNode {
+    const slot = useItemSlot(entry, state, identity);
+    useRememberIdentity(entry, slot);
     const props = rowPropsFor(slot, rowProps);
+    const previous = useRef<ResolvedRowProps | null>(null);
 
     useLayoutEffect(() => {
-        applyRowProps(entry.host, props);
-    });
+        applyRowProps(entry.host, props, previous.current);
+        previous.current = props;
+    }, [entry.host, props]);
 
     return null;
 }
@@ -458,29 +610,37 @@ const ItemPortals = ({
     hasExpander,
     expandedIds,
     expanderDescriptions,
-}: ItemPortalsProps): ReactNode =>
-    usePortalEntries(registry).map((entry) => (
+}: ItemPortalsProps): ReactNode => {
+    const entries = usePortalEntries(registry);
+    const state = useCollectionState(collection, expandedIds);
+
+    return entries.map((entry) => (
         <ItemCell
             key={entry.key}
             entry={entry}
             render={render}
-            collection={collection}
+            state={state}
             hasExpander={hasExpander ?? true}
-            expandedIds={expandedIds}
             expanderDescriptions={expanderDescriptions}
+            {...itemIdentity(entry, collection, expandedIds)}
         />
     ));
+};
 
-const RowPortals = ({ registry, rowProps, collection, expandedIds }: RowPortalsProps): ReactNode =>
-    usePortalEntries(registry).map((entry) => (
+const RowPortals = ({ registry, rowProps, collection, expandedIds }: RowPortalsProps): ReactNode => {
+    const entries = usePortalEntries(registry);
+    const state = useCollectionState(collection, expandedIds);
+
+    return entries.map((entry) => (
         <ItemRow
             key={entry.key}
             entry={entry}
             rowProps={rowProps}
-            collection={collection}
-            expandedIds={expandedIds}
+            state={state}
+            {...itemIdentity(entry, collection, expandedIds)}
         />
     ));
+};
 
 const HeaderPortals = ({ registry, render, collection }: HeaderPortalsProps): ReactNode =>
     usePortalEntries(registry).map((entry) => (

package/src/internal/collection-index.ts

@@ -25,7 +25,6 @@ type IndexState = {
 
 type ParentItem = ListItem & { children: ListItem[] };
 
-const emptyLevel = (): Level => ({ path: "", items: [], expandableFlags: [] });
 const hasChildren = (item: ListItem): item is ParentItem => item.children !== undefined && item.children.length > 0;
 
 function newLevel(state: IndexState, path: string, items: ListItem[]): Level {
@@ -141,4 +140,4 @@ function createCollectionIndex(
     };
 }
 
-export { createCollectionIndex, emptyLevel, type CollectionIndex, type Level };
+export { createCollectionIndex, type CollectionIndex, type Level };

package/src/internal/collection-model.ts

@@ -4,14 +4,14 @@ import * as Gtk from "@gtkx/gi/gtk";
 import { registerClass } from "@gtkx/runtime";
 import type { CollectionIndex, Level } from "./collection-index.js";
 import type { TreeExpansion } from "./tree-expansion.js";
-import { createCollectionIndex, emptyLevel } from "./collection-index.js";
+import { createCollectionIndex } from "./collection-index.js";
 import { encodePart } from "./keys.js";
 import { adoptIndex, createTreeExpansion, pruneSlots } from "./tree-expansion.js";
 
 type LevelStore = Gio.ListModel & LazyLevelStore;
 
 type SlotRef = {
-    store: LevelStore;
+    store: LazyLevelStore;
     slot: number;
 };
 
@@ -93,22 +93,13 @@ function slotRefFor(value: GObject.Object | null): SlotRef | null {
     return ref === undefined || ref.slot === -1 ? null : ref;
 }
 
-function slotPathAt(store: LevelStore, slot: number): string {
+function slotPathAt(store: LazyLevelStore, slot: number): string {
     return store.level.path + encodePart(String(slot));
 }
 
-function growStore(store: LevelStore): void {
-    for (let slot = store.refs.length; slot < store.level.items.length; slot++) {
-        store.refs.push({ store, slot });
-        store.objects.push(null);
-        store.childStores.push(null);
-    }
-}
-
 function newLevelStore(level: Level): LevelStore {
     const store = new (registeredStoreClass())() as LevelStore;
     store.level = level;
-    growStore(store);
 
     return store;
 }
@@ -116,6 +107,10 @@ function newLevelStore(level: Level): LevelStore {
 function collectFlips(previous: Level, next: Level, overlap: number): Set<number> {
     const flipped: Set<number> = new Set();
 
+    if (previous.expandableFlags.length === 0 && next.expandableFlags.length === 0) {
+        return flipped;
+    }
+
     for (let slot = 0; slot < overlap; slot++) {
         if ((previous.expandableFlags[slot] ?? false) !== (next.expandableFlags[slot] ?? false)) {
             flipped.add(slot);
@@ -133,30 +128,30 @@ function pruneFlips(context: SyncContext, store: LevelStore, flipped: Set<number
     pruneSlots(context.expansion, store.level.path, (slot) => flipped.has(slot));
 
     for (const slot of flipped) {
-        store.childStores[slot] = null;
+        store.childStores.delete(slot);
     }
 }
 
 function detachRefs(store: LevelStore, nextLength: number): void {
-    for (let slot = nextLength; slot < store.refs.length; slot++) {
-        const ref = store.refs[slot];
-
-        if (ref !== undefined) {
-            ref.slot = -1;
+    for (const [slot, ref] of store.refs) {
+        if (slot < nextLength) {
+            continue;
         }
+
+        ref.slot = -1;
+        store.refs.delete(slot);
+        store.objects.delete(slot);
+        store.childStores.delete(slot);
     }
 }
 
-function shrinkStore(context: SyncContext, store: LevelStore, nextLength: number): void {
-    if (store.refs.length <= nextLength) {
+function shrinkStore(context: SyncContext, store: LevelStore, previousLength: number, nextLength: number): void {
+    if (previousLength <= nextLength) {
         return;
     }
 
     detachRefs(store, nextLength);
     pruneSlots(context.expansion, store.level.path, (slot) => slot >= nextLength);
-    store.refs.length = nextLength;
-    store.objects.length = nextLength;
-    store.childStores.length = nextLength;
 }
 
 function emitTailSplice(store: LevelStore, previousLength: number, nextLength: number): void {
@@ -205,7 +200,7 @@ function childSync(
     slot: number,
     flipped: Set<number>,
 ): LevelSync | undefined {
-    const child = store.childStores[slot] ?? null;
+    const child = store.childStores.get(slot) ?? null;
 
     if (child === null || flipped.has(slot)) {
         return undefined;
@@ -218,8 +213,13 @@ function childSync(
 
 function childSyncs(context: SyncContext, store: LevelStore, overlap: number, flipped: Set<number>): LevelSync[] {
     const syncs: LevelSync[] = [];
+    const slots = store.childStores.keys().toArray().toSorted((left, right) => left - right);
+
+    for (const slot of slots) {
+        if (slot >= overlap) {
+            continue;
+        }
 
-    for (let slot = 0; slot < overlap; slot++) {
         const sync = childSync(context, store, slot, flipped);
 
         if (sync !== undefined) {
@@ -232,25 +232,19 @@ function childSyncs(context: SyncContext, store: LevelStore, overlap: number, fl
 
 function syncEntry(context: SyncContext, entry: LevelSync): LevelSync[] {
     const { store, level } = entry;
-    const previousLength = store.refs.length;
+    const previous = store.level;
+    const previousLength = previous.items.length;
     const overlap = Math.min(previousLength, level.items.length);
-    const flipped = collectFlips(store.level, level, overlap);
+    const flipped = collectFlips(previous, level, overlap);
     store.level = level;
     pruneFlips(context, store, flipped);
-    shrinkStore(context, store, level.items.length);
-    growStore(store);
+    shrinkStore(context, store, previousLength, level.items.length);
     emitTailSplice(store, previousLength, level.items.length);
     emitFlips(store, flipped);
 
     return childSyncs(context, store, overlap, flipped);
 }
 
-function pushSyncs(pending: LevelSync[], syncs: LevelSync[]): void {
-    for (const sync of syncs) {
-        pending.push(sync);
-    }
-}
-
 function syncLevel(context: SyncContext, store: LevelStore, level: Level): void {
     const pending: LevelSync[] = [{ store, level }];
 
@@ -258,13 +252,13 @@ function syncLevel(context: SyncContext, store: LevelStore, level: Level): void
         const entry = pending.pop();
 
         if (entry !== undefined) {
-            pushSyncs(pending, syncEntry(context, entry).toReversed());
+            pending.push(...syncEntry(context, entry).toReversed());
         }
     }
 }
 
-function ensureChildStore(index: CollectionIndex, store: LevelStore, slot: number): LevelStore | null {
-    const existing = store.childStores[slot] ?? null;
+function ensureChildStore(index: CollectionIndex, store: LazyLevelStore, slot: number): LevelStore | null {
+    const existing = store.childStores.get(slot) ?? null;
 
     if (existing !== null || !(store.level.expandableFlags[slot] ?? false)) {
         return existing;
@@ -277,7 +271,7 @@ function ensureChildStore(index: CollectionIndex, store: LevelStore, slot: numbe
     }
 
     const created = newLevelStore(level);
-    store.childStores[slot] = created;
+    store.childStores.set(slot, created);
 
     return created;
 }
@@ -423,14 +417,16 @@ function createCollectionModel(): CollectionModel {
 
 class LazyLevelStore extends GObject.Object implements Gio.ListModelImpl {
     declare itemsChanged: Gio.ListModel["itemsChanged"];
-    level: Level = emptyLevel();
-    refs: SlotRef[] = [];
-    objects: (Gtk.StringObject | null)[] = [];
-    childStores: (LevelStore | null)[] = [];
+    level: Level = { path: "", items: [], expandableFlags: [] };
+    refs: Map<number, SlotRef> = new Map();
+    objects: Map<number, Gtk.StringObject> = new Map();
+    childStores: Map<number, LevelStore> = new Map();
 
-    private createItem(position: number, ref: SlotRef): Gtk.StringObject {
+    private createItem(position: number): Gtk.StringObject {
+        const ref = { store: this, slot: position };
         const created = Gtk.StringObject.new("");
-        this.objects[position] = created;
+        this.refs.set(position, ref);
+        this.objects.set(position, created);
         SLOTS.set(created, ref);
 
         return created;
@@ -441,17 +437,15 @@ class LazyLevelStore extends GObject.Object implements Gio.ListModelImpl {
     }
 
     vfuncGetNItems(): number {
-        return this.refs.length;
+        return this.level.items.length;
     }
 
     vfuncGetItem(position: number): GObject.Object | null {
-        const ref = this.refs[position];
-
-        if (ref === undefined) {
+        if (position < 0 || position >= this.level.items.length) {
             return null;
         }
 
-        return this.objects[position] ?? this.createItem(position, ref);
+        return this.objects.get(position) ?? this.createItem(position);
     }
 }
 

package/src/internal/expansion.ts

@@ -30,10 +30,6 @@ type ExpansionContext = {
     onExpandedChange?: ((ids: string[]) => void) | null | undefined;
 };
 
-function newLastExpansion(): LastExpansion {
-    return { key: "" };
-}
-
 function hasSameExpansion(expanded: Set<string>, wanted: Set<string>): boolean {
     return expanded.size === wanted.size && wanted.isSubsetOf(expanded);
 }
@@ -95,10 +91,6 @@ function applyControlledExpansion(context: ExpansionContext, expandedIds: string
     reportExpansion(context);
 }
 
-function isExpansionIdle(collection: Collection): boolean {
-    return collection.isTree && isCollectionIdle(collection);
-}
-
 function didRowDrift(collection: Collection, change: ItemsChange): boolean {
     const path = collection.pathAt(change.position - 1);
     const isExpanded = change.removed === 0 && change.added > 0;
@@ -114,7 +106,7 @@ function didRowDrift(collection: Collection, change: ItemsChange): boolean {
 }
 
 function observeExpansion(context: ExpansionContext, change: ItemsChange, onDrift: () => void): void {
-    if (!isExpansionIdle(context.collection)) {
+    if (!context.collection.isTree || !isCollectionIdle(context.collection)) {
         return;
     }
 
@@ -128,7 +120,7 @@ function observeExpansion(context: ExpansionContext, change: ItemsChange, onDrif
 
 function useExpansion(options: ExpansionOptions): ItemsChangeHandler {
     const { collection, expandedIds, onExpandedChange } = options;
-    const [last] = useState<LastExpansion>(newLastExpansion);
+    const [last] = useState<LastExpansion>(() => ({ key: "" }));
     const context: ExpansionContext = { collection, last, onExpandedChange };
 
     const markDrift = useControlledSync({

package/src/internal/slots.ts

@@ -43,15 +43,7 @@ function trackPath(slots: SlotMap, path: string): void {
         return;
     }
 
-    const level = slots.get(key.levelPath);
-
-    if (level === undefined) {
-        slots.set(key.levelPath, new Set([key.slot]));
-
-        return;
-    }
-
-    level.add(key.slot);
+    slots.getOrInsertComputed(key.levelPath, () => new Set()).add(key.slot);
 }
 
 function trackPaths(paths: Iterable<string>): SlotMap {

package/src/internal/tree-expansion.ts

@@ -3,7 +3,7 @@ import type { SlotMap } from "./slots.js";
 import type { VisibleOrder } from "./tree-order.js";
 import { encodePart } from "./keys.js";
 import { getSlotKey, trackPath, trackPaths } from "./slots.js";
-import { buildVisibleOrder } from "./tree-order.js";
+import { walkVisible } from "./tree-order.js";
 
 type TreeExpansion = {
     index: CollectionIndex;
@@ -46,7 +46,7 @@ function createTreeExpansion(index: CollectionIndex): TreeExpansion {
 }
 
 function orderFor(expansion: TreeExpansion): VisibleOrder {
-    expansion.order ??= buildVisibleOrder(expansion.index, expansion.slots);
+    expansion.order ??= walkVisible({ index: expansion.index, slots: expansion.slots });
 
     return expansion.order;
 }

package/src/internal/tree-order.ts

@@ -183,10 +183,6 @@ function expandedPathsFor(index: CollectionIndex, ids: Set<string>): Set<string>
     return paths;
 }
 
-function buildVisibleOrder(index: CollectionIndex, slots: SlotMap): VisibleOrder {
-    return walkVisible({ index, slots });
-}
-
 function findRows(index: CollectionIndex, slots: SlotMap, ids: Set<string>): MatchedRows {
     const positions: number[] = [];
     const found: string[] = [];
@@ -226,7 +222,6 @@ function findIds(index: CollectionIndex, slots: SlotMap, positions: Set<number>)
 }
 
 export {
-    buildVisibleOrder,
     expandedPathsFor,
     findIds,
     findRows,