@gtkx/components 1.0.0-rc.4 → 1.1.0

package/src/internal/collection-model.ts

@@ -1,178 +1,348 @@
 import * as Gio from "@gtkx/gi/gio";
 import * as GObject from "@gtkx/gi/gobject";
 import * as Gtk from "@gtkx/gi/gtk";
+import { registerClass } from "@gtkx/runtime";
 import type { CollectionIndex, Level } from "./collection-index.js";
-import { childLevelKey, ROOT_LEVEL_KEY } from "./collection-index.js";
+import type { TreeExpansion } from "./tree-expansion.js";
+import { createCollectionIndex, emptyLevel } from "./collection-index.js";
+import { encodePart } from "./keys.js";
+import { adoptIndex, createTreeExpansion, pruneSlots } from "./tree-expansion.js";
 
-type LevelState = {
-    store: Gio.ListStore;
-    ids: string[];
-    canExpand: Map<string, boolean>;
+type LevelStore = Gio.ListModel & LazyLevelStore;
+
+type SlotRef = {
+    store: LevelStore;
+    slot: number;
+};
+
+type SyncContext = {
+    index: CollectionIndex;
+    expansion: TreeExpansion;
 };
 
-type SpliceRange = {
+type SlotRun = {
     start: number;
-    removed: number;
-    added: string[];
+    length: number;
+};
+
+type LevelSync = {
+    store: LevelStore;
+    level: Level;
 };
 
 type ModelState = {
     root: Gio.ListStore;
     rootModels: GObject.Object[];
     model: Gtk.FlattenListModel;
-    objects: Map<string, Gtk.StringObject>;
-    levels: Map<string, LevelState>;
-    tree: Gtk.TreeListModel | null;
+    groupStores: LevelStore[];
+    trees: Map<LevelStore, Gtk.TreeListModel>;
+    treeModels: Gtk.TreeListModel[];
+    expansion: TreeExpansion;
+    index: CollectionIndex;
 };
 
 type CollectionModel = {
     model: Gtk.FlattenListModel;
-    treeModel: () => Gtk.TreeListModel | null;
+    expansion: TreeExpansion;
+    rowAt: (position: number) => Gtk.TreeListRow | null;
     sync: (index: CollectionIndex) => void;
 };
 
-const OBJECT_CACHE_MAX = 1 << 20;
+const STORE_CLASS_KEY = Symbol.for("gtkx.components.lazy-level-store");
+const SLOTS_KEY = Symbol.for("gtkx.components.lazy-level-store.slots");
+const EMPTY_INDEX = createCollectionIndex(undefined, undefined, true);
+const SLOTS = sharedSlots();
 
-const newStore = (): Gio.ListStore => new Gio.ListStore({ itemType: GObject.TYPE_OBJECT });
+const newRootStore = (): Gio.ListStore => new Gio.ListStore({ itemType: GObject.TYPE_OBJECT });
 
-function getId(value: GObject.Object | null): string | null {
-    const item = value instanceof Gtk.TreeListRow ? value.getItem() : value;
+function sharedSlots(): WeakMap<GObject.Object, SlotRef> {
+    const cached: unknown = Reflect.get(globalThis, SLOTS_KEY);
+
+    if (cached instanceof WeakMap) {
+        return cached as WeakMap<GObject.Object, SlotRef>;
+    }
+
+    const created: WeakMap<GObject.Object, SlotRef> = new WeakMap();
+    Reflect.set(globalThis, SLOTS_KEY, created);
 
-    return item instanceof Gtk.StringObject ? item.getString() : null;
+    return created;
 }
 
-function objectFor(state: ModelState, id: string): Gtk.StringObject {
-    const existing = state.objects.get(id);
+function registeredStoreClass(): typeof LazyLevelStore {
+    const cached: unknown = Reflect.get(globalThis, STORE_CLASS_KEY);
 
-    if (existing !== undefined) {
-        return existing;
+    if (typeof cached === "function") {
+        return cached as typeof LazyLevelStore;
     }
 
-    const created = Gtk.StringObject.new(id);
-    state.objects.set(id, created);
+    registerClass(LazyLevelStore, { typeName: "GtkxLazyLevelStore", implements: [Gio.ListModel] });
+    Reflect.set(globalThis, STORE_CLASS_KEY, LazyLevelStore);
 
-    return created;
+    return LazyLevelStore;
 }
 
-function commonPrefix(previous: string[], next: string[], max: number): number {
-    let count = 0;
+function slotRefFor(value: GObject.Object | null): SlotRef | null {
+    const item = value instanceof Gtk.TreeListRow ? value.getItem() : value;
 
-    while (count < max && previous[count] === next[count]) {
-        count += 1;
+    if (item === null) {
+        return null;
     }
 
-    return count;
+    const ref = SLOTS.get(item);
+
+    return ref === undefined || ref.slot === -1 ? null : ref;
 }
 
-function commonSuffix(previous: string[], next: string[], max: number): number {
-    let count = 0;
+function slotPathAt(store: LevelStore, slot: number): string {
+    return store.level.path + encodePart(String(slot));
+}
 
-    while (count < max && previous[previous.length - 1 - count] === next[next.length - 1 - count]) {
-        count += 1;
+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 count;
+    return store;
 }
 
-function spliceRange(previous: string[], next: string[]): SpliceRange | null {
-    const shared = Math.min(previous.length, next.length);
-    const start = commonPrefix(previous, next, shared);
+function collectFlips(previous: Level, next: Level, overlap: number): Set<number> {
+    const flipped: Set<number> = new Set();
 
-    if (start === previous.length && start === next.length) {
-        return null;
+    for (let slot = 0; slot < overlap; slot++) {
+        if ((previous.expandableFlags[slot] ?? false) !== (next.expandableFlags[slot] ?? false)) {
+            flipped.add(slot);
+        }
+    }
+
+    return flipped;
+}
+
+function pruneFlips(context: SyncContext, store: LevelStore, flipped: Set<number>): void {
+    if (flipped.size === 0) {
+        return;
     }
 
-    const tail = commonSuffix(previous, next, shared - start);
+    pruneSlots(context.expansion, store.level.path, (slot) => flipped.has(slot));
 
-    return { start, removed: previous.length - start - tail, added: next.slice(start, next.length - tail) };
+    for (const slot of flipped) {
+        store.childStores[slot] = null;
+    }
 }
 
-function levelFor(state: ModelState, key: string): LevelState {
-    const existing = state.levels.get(key);
+function detachRefs(store: LevelStore, nextLength: number): void {
+    for (let slot = nextLength; slot < store.refs.length; slot++) {
+        const ref = store.refs[slot];
 
-    if (existing !== undefined) {
-        return existing;
+        if (ref !== undefined) {
+            ref.slot = -1;
+        }
     }
+}
 
-    const created: LevelState = { store: newStore(), ids: [], canExpand: new Map() };
-    state.levels.set(key, created);
+function shrinkStore(context: SyncContext, store: LevelStore, nextLength: number): void {
+    if (store.refs.length <= nextLength) {
+        return;
+    }
 
-    return created;
+    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 refreshExpandable(current: LevelState, level: Level): void {
-    const next: Map<string, boolean> = new Map();
+function emitTailSplice(store: LevelStore, previousLength: number, nextLength: number): void {
+    if (nextLength < previousLength) {
+        store.itemsChanged(nextLength, previousLength - nextLength, 0);
 
-    for (const [index, id] of level.ids.entries()) {
-        const isWanted = level.expandableFlags[index] ?? false;
-        const previous = current.canExpand.get(id);
-        next.set(id, isWanted);
+        return;
+    }
 
-        if (previous !== undefined && previous !== isWanted) {
-            current.store.itemsChanged(index, 1, 1);
-        }
+    if (nextLength > previousLength) {
+        store.itemsChanged(previousLength, 0, nextLength - previousLength);
+    }
+}
+
+function extendRuns(runs: SlotRun[], slot: number): void {
+    const last = runs.at(-1);
+
+    if (last !== undefined && last.start + last.length === slot) {
+        last.length += 1;
+
+        return;
+    }
+
+    runs.push({ start: slot, length: 1 });
+}
+
+function collectFlipRuns(flipped: Set<number>): SlotRun[] {
+    const runs: SlotRun[] = [];
+
+    for (const slot of flipped) {
+        extendRuns(runs, slot);
     }
 
-    current.canExpand = next;
+    return runs;
+}
+
+function emitFlips(store: LevelStore, flipped: Set<number>): void {
+    for (const run of collectFlipRuns(flipped)) {
+        store.itemsChanged(run.start, run.length, run.length);
+    }
 }
 
-function didSpliceLevel(state: ModelState, level: Level): boolean {
-    const current = levelFor(state, level.key);
-    const range = spliceRange(current.ids, level.ids);
+function childSync(
+    context: SyncContext,
+    store: LevelStore,
+    slot: number,
+    flipped: Set<number>,
+): LevelSync | undefined {
+    const child = store.childStores[slot] ?? null;
 
-    if (range === null) {
-        return false;
+    if (child === null || flipped.has(slot)) {
+        return undefined;
     }
 
-    current.store.splice(range.start, range.removed, range.added.map((id) => objectFor(state, id)));
-    current.ids = [...level.ids];
+    const level = context.index.childLevel(store.level, slot);
 
-    return true;
+    return level === undefined ? undefined : { store: child, level };
 }
 
-function dropUnvisited(state: ModelState, visited: Set<string>): void {
-    for (const key of state.levels.keys()) {
-        if (!visited.has(key)) {
-            state.levels.delete(key);
+function childSyncs(context: SyncContext, store: LevelStore, overlap: number, flipped: Set<number>): LevelSync[] {
+    const syncs: LevelSync[] = [];
+
+    for (let slot = 0; slot < overlap; slot++) {
+        const sync = childSync(context, store, slot, flipped);
+
+        if (sync !== undefined) {
+            syncs.push(sync);
         }
     }
+
+    return syncs;
 }
 
-function pruneObjects(state: ModelState, index: CollectionIndex): void {
-    if (state.objects.size <= OBJECT_CACHE_MAX) {
-        return;
+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 = collectFlips(store.level, level, overlap);
+    store.level = level;
+    pruneFlips(context, store, flipped);
+    shrinkStore(context, store, level.items.length);
+    growStore(store);
+    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);
     }
+}
 
-    for (const id of state.objects.keys()) {
-        if (!index.hasId(id)) {
-            state.objects.delete(id);
+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 childStoreFor(state: ModelState, object: GObject.Object): Gio.ListStore | null {
-    const id = getId(object);
+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 (id === null) {
+    if (ref === null) {
         return null;
     }
 
-    return state.levels.get(childLevelKey(id))?.store ?? null;
+    return ensureChildStore(state.index, ref.store, ref.slot);
 }
 
-function ensureTree(state: ModelState): Gtk.TreeListModel {
-    state.tree ??= Gtk.TreeListModel.new(levelFor(state, ROOT_LEVEL_KEY).store, false, false, (object) =>
-        childStoreFor(state, object));
+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 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()]);
 
-    return state.tree;
+    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[] {
-    if (index.isTree) {
-        return [ensureTree(state)];
+    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);
+        }
+
+        offset -= count;
     }
 
-    return index.groups.map((level) => levelFor(state, level.key).store);
+    return null;
 }
 
 function hasSameModels(previous: GObject.Object[], next: GObject.Object[]): boolean {
@@ -190,54 +360,99 @@ function syncRoot(state: ModelState, index: CollectionIndex): void {
     state.rootModels = next;
 }
 
-function syncModel(state: ModelState, index: CollectionIndex): void {
-    const levels = [...index.groups, ...index.children.values()];
-    const visited: Set<string> = new Set();
-    let didChange = false;
+function adjustGroupStores(state: ModelState, context: SyncContext): void {
+    const { groups } = context.index;
+    state.groupStores.length = Math.min(state.groupStores.length, groups.length);
 
-    for (const level of levels) {
-        didChange = didSpliceLevel(state, level) || didChange;
-        visited.add(level.key);
+    for (const level of groups.slice(state.groupStores.length)) {
+        state.groupStores.push(newLevelStore(level));
     }
+}
 
-    if (didChange || visited.size !== state.levels.size) {
-        dropUnvisited(state, visited);
-        pruneObjects(state, index);
-    }
+function stepGroupStores(state: ModelState, context: SyncContext, surviving: number): void {
+    for (const [group, level] of context.index.groups.entries()) {
+        const store = state.groupStores[group];
 
-    syncRoot(state, index);
-    refreshExpandableLevels(state, index, levels);
+        if (store !== undefined && group < surviving) {
+            syncLevel(context, store, level);
+        }
+    }
 }
 
-function refreshExpandableLevels(state: ModelState, index: CollectionIndex, levels: Level[]): void {
-    if (!index.isTree) {
-        return;
+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 {
+        adjustGroupStores(state, context);
+        syncRoot(state, index);
+        stepGroupStores(state, context, surviving);
+    } finally {
+        state.expansion.isSyncing = false;
     }
 
-    for (const level of levels) {
-        refreshExpandable(levelFor(state, level.key), level);
-    }
+    adoptIndex(state.expansion, index);
 }
 
 function createCollectionModel(): CollectionModel {
-    const root = newStore();
+    registeredStoreClass();
+    const root = newRootStore();
 
     const state: ModelState = {
         root,
         rootModels: [],
         model: Gtk.FlattenListModel.new(root),
-        objects: new Map(),
-        levels: new Map(),
-        tree: null,
+        groupStores: [],
+        trees: new Map(),
+        treeModels: [],
+        expansion: createTreeExpansion(EMPTY_INDEX),
+        index: EMPTY_INDEX,
     };
 
     return {
         model: state.model,
-        treeModel: () => state.tree,
+        expansion: state.expansion,
+        rowAt: (position) => rowAt(state, position),
         sync: (index) => {
             syncModel(state, index);
         },
     };
 }
 
-export { createCollectionModel, getId, type 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)[] = [];
+
+    private createItem(position: number, ref: SlotRef): Gtk.StringObject {
+        const created = Gtk.StringObject.new("");
+        this.objects[position] = created;
+        SLOTS.set(created, ref);
+
+        return created;
+    }
+
+    vfuncGetItemType(): bigint {
+        return GObject.TYPE_OBJECT;
+    }
+
+    vfuncGetNItems(): number {
+        return this.refs.length;
+    }
+
+    vfuncGetItem(position: number): GObject.Object | null {
+        const ref = this.refs[position];
+
+        if (ref === undefined) {
+            return null;
+        }
+
+        return this.objects[position] ?? this.createItem(position, ref);
+    }
+}
+
+export { createCollectionModel, slotPathAt, slotRefFor, type CollectionModel, type SlotRef };