@gtkx/components 1.0.0 → 1.2.0

package/src/internal/collection-index.ts

@@ -1,5 +1,5 @@
 import type { ListItem, ListSection } from "../types.js";
-import { encodePart } from "./keys.js";
+import { decodePartAt, encodePart } from "./keys.js";
 
 type Level = {
     path: string;
@@ -10,83 +10,109 @@ type Level = {
 type CollectionIndex = {
     isTree: boolean;
     groups: Level[];
-    children: Map<string, Level>;
+    childLevel: (level: Level, slot: number) => Level | undefined;
+    levelFor: (levelPath: string) => Level | undefined;
     itemAt: (levelPath: string, slot: number) => ListItem | undefined;
     sectionFor: (levelPath: string) => unknown;
-    expandablePathsFor: (id: string) => string[];
 };
 
 type IndexState = {
     isTree: boolean;
     groups: Level[];
-    children: Map<string, Level>;
     levels: Map<string, Level>;
-    expandablePaths: Map<string, string[]>;
     sectionValues: Map<string, unknown>;
 };
 
-const NO_PATHS: string[] = [];
+type ParentItem = ListItem & { children: ListItem[] };
 
-const hasChildren = (item: ListItem): boolean => item.children !== undefined && item.children.length > 0;
+const emptyLevel = (): Level => ({ path: "", items: [], expandableFlags: [] });
+const hasChildren = (item: ListItem): item is ParentItem => item.children !== undefined && item.children.length > 0;
 
-function pushPath(table: Map<string, string[]>, id: string, path: string): void {
-    const existing = table.get(id);
+function newLevel(state: IndexState, path: string, items: ListItem[]): Level {
+    const expandableFlags = state.isTree ? items.map((item) => hasChildren(item)) : [];
+    const level: Level = { path, items, expandableFlags };
+    state.levels.set(path, level);
 
-    if (existing === undefined) {
-        table.set(id, [path]);
+    return level;
+}
 
-        return;
-    }
+function slotItems(state: IndexState, parent: Level, slot: number): ListItem[] | undefined {
+    const owner = state.levels.get(parent.path) === parent ? parent : levelFor(state, parent.path);
+    const item = owner?.items[slot];
 
-    existing.push(path);
+    return item !== undefined && hasChildren(item) ? item.children : undefined;
 }
 
-function collectChildren(state: IndexState, level: Level, slotPath: string, item: ListItem): void {
-    const canExpand = hasChildren(item);
-    level.expandableFlags.push(canExpand);
+function childLevel(state: IndexState, parent: Level, slot: number): Level | undefined {
+    if (!state.isTree) {
+        return undefined;
+    }
 
-    if (!canExpand) {
-        return;
+    const path = parent.path + encodePart(String(slot));
+    const cached = state.levels.get(path);
+
+    if (cached !== undefined) {
+        return cached;
     }
 
-    pushPath(state.expandablePaths, item.id, slotPath);
-    state.children.set(slotPath, collectLevel(state, slotPath, item.children ?? []));
+    const items = slotItems(state, parent, slot);
+
+    return items === undefined ? undefined : newLevel(state, path, items);
 }
 
-function collectLevel(state: IndexState, path: string, items: ListItem[]): Level {
-    const level: Level = { path, items, expandableFlags: [] };
-    state.levels.set(path, level);
+function descendPath(state: IndexState, levelPath: string, group: string): Level | undefined {
+    let level = state.levels.get(encodePart(group));
+    let offset = encodePart(group).length;
 
-    if (!state.isTree) {
-        return level;
-    }
+    while (level !== undefined && offset < levelPath.length) {
+        const part = decodePartAt(levelPath, offset);
 
-    for (const [slot, item] of items.entries()) {
-        collectChildren(state, level, path + encodePart(String(slot)), item);
+        if (part === null) {
+            return undefined;
+        }
+
+        level = childLevel(state, level, Number(part));
+        offset += encodePart(part).length;
     }
 
     return level;
 }
 
+function levelFor(state: IndexState, levelPath: string): Level | undefined {
+    const cached = state.levels.get(levelPath);
+
+    if (cached !== undefined) {
+        return cached;
+    }
+
+    const group = decodePartAt(levelPath, 0);
+
+    return group === null ? undefined : descendPath(state, levelPath, group);
+}
+
 function buildGroups(state: IndexState, source: ListItem[], sections: ListSection[] | undefined): Level[] {
     if (sections === undefined) {
-        return [collectLevel(state, encodePart("0"), source)];
+        return [newLevel(state, encodePart("0"), source)];
     }
 
     return sections.map((section, group) => {
         const path = encodePart(String(group));
         state.sectionValues.set(path, section.value);
 
-        return collectLevel(state, path, section.data);
+        return newLevel(state, path, section.data);
     });
 }
 
 function isTreeSource(source: ListItem[], sections: ListSection[] | undefined, isFlat: boolean): boolean {
-    if (sections !== undefined || isFlat) {
+    if (isFlat) {
         return false;
     }
 
-    return source.some((item) => hasChildren(item));
+    if (sections === undefined) {
+        return source.some((item) => hasChildren(item));
+    }
+
+    return sections.some((section) => section.data.some((item) => hasChildren(item)));
 }
 
 function createCollectionIndex(
@@ -99,9 +125,7 @@ function createCollectionIndex(
     const state: IndexState = {
         isTree: isTreeSource(source, sections, isFlat),
         groups: [],
-        children: new Map(),
         levels: new Map(),
-        expandablePaths: new Map(),
         sectionValues: new Map(),
     };
 
@@ -110,11 +134,11 @@ function createCollectionIndex(
     return {
         isTree: state.isTree,
         groups: state.groups,
-        children: state.children,
-        itemAt: (levelPath, slot) => state.levels.get(levelPath)?.items[slot],
+        childLevel: (level, slot) => childLevel(state, level, slot),
+        levelFor: (levelPath) => levelFor(state, levelPath),
+        itemAt: (levelPath, slot) => levelFor(state, levelPath)?.items[slot],
         sectionFor: (levelPath) => state.sectionValues.get(levelPath),
-        expandablePathsFor: (id) => state.expandablePaths.get(id) ?? NO_PATHS,
     };
 }
 
-export { createCollectionIndex, type CollectionIndex, type Level };
+export { createCollectionIndex, emptyLevel, type CollectionIndex, type Level };

package/src/internal/collection-model.ts

@@ -4,9 +4,9 @@ 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 } from "./collection-index.js";
+import { createCollectionIndex, emptyLevel } from "./collection-index.js";
 import { encodePart } from "./keys.js";
-import { adoptIndex, createTreeExpansion, pruneSlots, resetExpansion } from "./tree-expansion.js";
+import { adoptIndex, createTreeExpansion, pruneSlots } from "./tree-expansion.js";
 
 type LevelStore = Gio.ListModel & LazyLevelStore;
 
@@ -25,20 +25,26 @@ type SlotRun = {
     length: number;
 };
 
+type LevelSync = {
+    store: LevelStore;
+    level: Level;
+};
+
 type ModelState = {
     root: Gio.ListStore;
     rootModels: GObject.Object[];
     model: Gtk.FlattenListModel;
     groupStores: LevelStore[];
-    tree: Gtk.TreeListModel | null;
-    treeRoot: LevelStore | null;
+    trees: Map<LevelStore, Gtk.TreeListModel>;
+    treeModels: Gtk.TreeListModel[];
     expansion: TreeExpansion;
+    index: CollectionIndex;
 };
 
 type CollectionModel = {
     model: Gtk.FlattenListModel;
     expansion: TreeExpansion;
-    treeModel: () => Gtk.TreeListModel | null;
+    rowAt: (position: number) => Gtk.TreeListRow | null;
     sync: (index: CollectionIndex) => void;
 };
 
@@ -88,55 +94,30 @@ function slotRefFor(value: GObject.Object | null): SlotRef | null {
 }
 
 function slotPathAt(store: LevelStore, slot: number): string {
-    return store.path + encodePart(String(slot));
-}
-
-function newLevelStore(path: string): LevelStore {
-    const store = new (registeredStoreClass())() as LevelStore;
-    store.path = path;
-
-    return store;
+    return store.level.path + encodePart(String(slot));
 }
 
-function buildChildStore(context: SyncContext, path: string): LevelStore | null {
-    const level = context.index.children.get(path);
-
-    if (level === undefined) {
-        return null;
+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);
     }
-
-    const store = newLevelStore(path);
-    growStore(context, store, level);
-
-    return store;
-}
-
-function pushSlot(context: SyncContext, store: LevelStore, level: Level, slot: number): void {
-    const canExpand = level.expandableFlags[slot] ?? false;
-    store.refs.push({ store, slot });
-    store.objects.push(null);
-    store.expandableFlags.push(canExpand);
-    store.childStores.push(canExpand ? buildChildStore(context, slotPathAt(store, slot)) : null);
 }
 
-function growStore(context: SyncContext, store: LevelStore, level: Level): void {
-    for (let slot = store.refs.length; slot < level.items.length; slot++) {
-        pushSlot(context, store, level, slot);
-    }
-}
+function newLevelStore(level: Level): LevelStore {
+    const store = new (registeredStoreClass())() as LevelStore;
+    store.level = level;
+    growStore(store);
 
-function flipSlot(context: SyncContext, store: LevelStore, slot: number): void {
-    const canExpand = !(store.expandableFlags[slot] ?? false);
-    store.expandableFlags[slot] = canExpand;
-    store.childStores[slot] = canExpand ? buildChildStore(context, slotPathAt(store, slot)) : null;
+    return store;
 }
 
-function collectFlips(store: LevelStore, level: Level): Set<number> {
-    const overlap = Math.min(store.refs.length, level.items.length);
+function collectFlips(previous: Level, next: Level, overlap: number): Set<number> {
     const flipped: Set<number> = new Set();
 
     for (let slot = 0; slot < overlap; slot++) {
-        if ((store.expandableFlags[slot] ?? false) !== (level.expandableFlags[slot] ?? false)) {
+        if ((previous.expandableFlags[slot] ?? false) !== (next.expandableFlags[slot] ?? false)) {
             flipped.add(slot);
         }
     }
@@ -144,20 +125,16 @@ function collectFlips(store: LevelStore, level: Level): Set<number> {
     return flipped;
 }
 
-function syncOverlap(context: SyncContext, store: LevelStore, level: Level): Set<number> {
-    const flipped = collectFlips(store, level);
-
+function pruneFlips(context: SyncContext, store: LevelStore, flipped: Set<number>): void {
     if (flipped.size === 0) {
-        return flipped;
+        return;
     }
 
-    pruneSlots(context.expansion, store.path, (slot) => flipped.has(slot));
+    pruneSlots(context.expansion, store.level.path, (slot) => flipped.has(slot));
 
     for (const slot of flipped) {
-        flipSlot(context, store, slot);
+        store.childStores[slot] = null;
     }
-
-    return flipped;
 }
 
 function detachRefs(store: LevelStore, nextLength: number): void {
@@ -176,11 +153,10 @@ function shrinkStore(context: SyncContext, store: LevelStore, nextLength: number
     }
 
     detachRefs(store, nextLength);
-    pruneSlots(context.expansion, store.path, (slot) => slot >= nextLength);
+    pruneSlots(context.expansion, store.level.path, (slot) => slot >= nextLength);
     store.refs.length = nextLength;
     store.objects.length = nextLength;
     store.childStores.length = nextLength;
-    store.expandableFlags.length = nextLength;
 }
 
 function emitTailSplice(store: LevelStore, previousLength: number, nextLength: number): void {
@@ -223,61 +199,150 @@ function emitFlips(store: LevelStore, flipped: Set<number>): void {
     }
 }
 
-function stepChildStore(context: SyncContext, store: LevelStore, slot: number, flipped: Set<number>): void {
-    const child = store.childStores[slot];
+function childSync(
+    context: SyncContext,
+    store: LevelStore,
+    slot: number,
+    flipped: Set<number>,
+): LevelSync | undefined {
+    const child = store.childStores[slot] ?? null;
 
-    if (child == null || flipped.has(slot)) {
-        return;
+    if (child === null || flipped.has(slot)) {
+        return undefined;
     }
 
-    const level = context.index.children.get(slotPathAt(store, slot));
+    const level = context.index.childLevel(store.level, slot);
+
+    return level === undefined ? undefined : { store: child, level };
+}
+
+function childSyncs(context: SyncContext, store: LevelStore, overlap: number, flipped: Set<number>): LevelSync[] {
+    const syncs: LevelSync[] = [];
 
-    if (level !== undefined) {
-        syncLevel(context, child, level);
+    for (let slot = 0; slot < overlap; slot++) {
+        const sync = childSync(context, store, slot, flipped);
+
+        if (sync !== undefined) {
+            syncs.push(sync);
+        }
     }
+
+    return syncs;
 }
 
-function syncLevel(context: SyncContext, store: LevelStore, level: Level): void {
+function syncEntry(context: SyncContext, entry: LevelSync): LevelSync[] {
+    const { store, level } = entry;
     const previousLength = store.refs.length;
     const overlap = Math.min(previousLength, level.items.length);
-    const flipped = syncOverlap(context, store, level);
+    const flipped = collectFlips(store.level, level, overlap);
+    store.level = level;
+    pruneFlips(context, store, flipped);
     shrinkStore(context, store, level.items.length);
-    growStore(context, store, level);
+    growStore(store);
     emitTailSplice(store, previousLength, level.items.length);
     emitFlips(store, flipped);
 
-    for (let slot = 0; slot < overlap; slot++) {
-        stepChildStore(context, store, slot, flipped);
+    return childSyncs(context, store, overlap, flipped);
+}
+
+function pushSyncs(pending: LevelSync[], syncs: LevelSync[]): void {
+    for (const sync of syncs) {
+        pending.push(sync);
     }
 }
 
-function childStoreFor(object: GObject.Object): Gio.ListModel | null {
+function syncLevel(context: SyncContext, store: LevelStore, level: Level): void {
+    const pending: LevelSync[] = [{ store, level }];
+
+    while (pending.length > 0) {
+        const entry = pending.pop();
+
+        if (entry !== undefined) {
+            pushSyncs(pending, syncEntry(context, entry).toReversed());
+        }
+    }
+}
+
+function ensureChildStore(index: CollectionIndex, store: LevelStore, slot: number): LevelStore | null {
+    const existing = store.childStores[slot] ?? null;
+
+    if (existing !== null || !(store.level.expandableFlags[slot] ?? false)) {
+        return existing;
+    }
+
+    const level = index.childLevel(store.level, slot);
+
+    if (level === undefined) {
+        return null;
+    }
+
+    const created = newLevelStore(level);
+    store.childStores[slot] = created;
+
+    return created;
+}
+
+function childStoreFor(state: ModelState, object: GObject.Object): Gio.ListModel | null {
     const ref = slotRefFor(object);
 
     if (ref === null) {
         return null;
     }
 
-    return ref.store.childStores[ref.slot] ?? null;
+    return ensureChildStore(state.index, ref.store, ref.slot);
 }
 
-function ensureTree(state: ModelState, first: LevelStore): Gtk.TreeListModel {
-    if (state.tree === null || state.treeRoot !== first) {
-        state.tree = Gtk.TreeListModel.new(first, false, false, (object) => childStoreFor(object));
-        state.treeRoot = first;
+function treeFor(state: ModelState, store: LevelStore): Gtk.TreeListModel {
+    return (
+        state.trees.get(store) ?? Gtk.TreeListModel.new(store, false, false, (object) => childStoreFor(state, object))
+    );
+}
+
+function nextTrees(state: ModelState, index: CollectionIndex): Map<LevelStore, Gtk.TreeListModel> {
+    if (!index.isTree) {
+        return new Map();
     }
 
-    return state.tree;
+    return new Map(state.groupStores.map((store) => [store, treeFor(state, store)]));
+}
+
+function pruneRebuiltLevels(state: ModelState, next: Map<LevelStore, Gtk.TreeListModel>): void {
+    const stores: Set<LevelStore> = new Set([...state.trees.keys(), ...next.keys()]);
+
+    for (const store of stores) {
+        if (state.trees.get(store) !== next.get(store)) {
+            pruneSlots(state.expansion, store.level.path, () => true);
+        }
+    }
+}
+
+function adoptTrees(state: ModelState, index: CollectionIndex): void {
+    const next = nextTrees(state, index);
+    pruneRebuiltLevels(state, next);
+    state.trees = next;
+    state.treeModels = next.values().toArray();
 }
 
 function desiredRootModels(state: ModelState, index: CollectionIndex): GObject.Object[] {
-    const [first] = state.groupStores;
+    adoptTrees(state, index);
+
+    return index.isTree ? [...state.treeModels] : [...state.groupStores];
+}
+
+function rowAt(state: ModelState, position: number): Gtk.TreeListRow | null {
+    let offset = position;
+
+    for (const tree of state.treeModels) {
+        const count = tree.getNItems();
+
+        if (offset < count) {
+            return tree.getRow(offset);
+        }
 
-    if (first !== undefined && index.isTree) {
-        return [ensureTree(state, first)];
+        offset -= count;
     }
 
-    return [...state.groupStores];
+    return null;
 }
 
 function hasSameModels(previous: GObject.Object[], next: GObject.Object[]): boolean {
@@ -293,7 +358,6 @@ function syncRoot(state: ModelState, index: CollectionIndex): void {
 
     state.root.splice(0, state.rootModels.length, next);
     state.rootModels = next;
-    resetExpansion(state.expansion);
 }
 
 function adjustGroupStores(state: ModelState, context: SyncContext): void {
@@ -301,9 +365,7 @@ function adjustGroupStores(state: ModelState, context: SyncContext): void {
     state.groupStores.length = Math.min(state.groupStores.length, groups.length);
 
     for (const level of groups.slice(state.groupStores.length)) {
-        const store = newLevelStore(level.path);
-        growStore(context, store, level);
-        state.groupStores.push(store);
+        state.groupStores.push(newLevelStore(level));
     }
 }
 
@@ -320,6 +382,7 @@ function stepGroupStores(state: ModelState, context: SyncContext, surviving: num
 function syncModel(state: ModelState, index: CollectionIndex): void {
     const context: SyncContext = { index, expansion: state.expansion };
     const surviving = Math.min(state.groupStores.length, index.groups.length);
+    state.index = index;
     state.expansion.isSyncing = true;
 
     try {
@@ -342,15 +405,16 @@ function createCollectionModel(): CollectionModel {
         rootModels: [],
         model: Gtk.FlattenListModel.new(root),
         groupStores: [],
-        tree: null,
-        treeRoot: null,
+        trees: new Map(),
+        treeModels: [],
         expansion: createTreeExpansion(EMPTY_INDEX),
+        index: EMPTY_INDEX,
     };
 
     return {
         model: state.model,
         expansion: state.expansion,
-        treeModel: () => state.tree,
+        rowAt: (position) => rowAt(state, position),
         sync: (index) => {
             syncModel(state, index);
         },
@@ -359,11 +423,10 @@ function createCollectionModel(): CollectionModel {
 
 class LazyLevelStore extends GObject.Object implements Gio.ListModelImpl {
     declare itemsChanged: Gio.ListModel["itemsChanged"];
-    path = "";
+    level: Level = emptyLevel();
     refs: SlotRef[] = [];
     objects: (Gtk.StringObject | null)[] = [];
     childStores: (LevelStore | null)[] = [];
-    expandableFlags: boolean[] = [];
 
     private createItem(position: number, ref: SlotRef): Gtk.StringObject {
         const created = Gtk.StringObject.new("");

package/src/internal/collection.ts

@@ -4,7 +4,8 @@ import type { CollectionModel, SlotRef } from "./collection-model.js";
 import { slotPathAt, slotRefFor } from "./collection-model.js";
 import { findPositions } from "./tree-order.js";
 
-type Collection = Pick<CollectionModel, "model" | "expansion" | "treeModel"> & {
+type Collection = Pick<CollectionModel, "model" | "expansion" | "rowAt"> & {
+    isTree: boolean;
     itemAt: (ref: SlotRef) => ListItem | undefined;
     sectionFor: (levelPath: string) => unknown;
     idAt: (position: number) => string | null;
@@ -39,14 +40,14 @@ function refAt(collectionModel: CollectionModel, position: number): SlotRef | nu
     return slotRefFor(collectionModel.model.getItem(position));
 }
 
+function itemAt(index: CollectionIndex, ref: SlotRef): ListItem | undefined {
+    return index.itemAt(ref.store.level.path, ref.slot);
+}
+
 function idAt(collectionModel: CollectionModel, index: CollectionIndex, position: number): string | null {
     const ref = refAt(collectionModel, position);
 
-    if (ref === null) {
-        return null;
-    }
-
-    return index.itemAt(ref.store.path, ref.slot)?.id ?? null;
+    return ref === null ? null : (itemAt(index, ref)?.id ?? null);
 }
 
 function pathAt(collectionModel: CollectionModel, position: number): string | null {
@@ -69,8 +70,9 @@ function createCollection(collectionModel: CollectionModel, index: CollectionInd
     return {
         model: collectionModel.model,
         expansion: collectionModel.expansion,
-        treeModel: () => (index.isTree ? collectionModel.treeModel() : null),
-        itemAt: (ref) => index.itemAt(ref.store.path, ref.slot),
+        isTree: index.isTree,
+        rowAt: collectionModel.rowAt,
+        itemAt: (ref) => itemAt(index, ref),
         sectionFor: index.sectionFor,
         idAt: (position) => idAt(collectionModel, index, position),
         pathAt: (position) => pathAt(collectionModel, position),