@gtkx/components 1.0.0-rc.3 → 1.0.0

package/src/internal/collection-model.ts

@@ -1,181 +1,283 @@
 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 } from "./collection-index.js";
+import { encodePart } from "./keys.js";
+import { adoptIndex, createTreeExpansion, pruneSlots, resetExpansion } 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 ModelState = {
     root: Gio.ListStore;
     rootModels: GObject.Object[];
     model: Gtk.FlattenListModel;
-    objects: Map<string, Gtk.StringObject>;
-    levels: Map<string, LevelState>;
+    groupStores: LevelStore[];
     tree: Gtk.TreeListModel | null;
+    treeRoot: LevelStore | null;
+    expansion: TreeExpansion;
 };
 
 type CollectionModel = {
     model: Gtk.FlattenListModel;
+    expansion: TreeExpansion;
     treeModel: () => Gtk.TreeListModel | 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.path + encodePart(String(slot));
+}
 
-    while (count < max && previous[previous.length - 1 - count] === next[next.length - 1 - count]) {
-        count += 1;
-    }
+function newLevelStore(path: string): LevelStore {
+    const store = new (registeredStoreClass())() as LevelStore;
+    store.path = path;
 
-    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 buildChildStore(context: SyncContext, path: string): LevelStore | null {
+    const level = context.index.children.get(path);
 
-    if (start === previous.length && start === next.length) {
+    if (level === undefined) {
         return null;
     }
 
-    const tail = commonSuffix(previous, next, shared - start);
+    const store = newLevelStore(path);
+    growStore(context, store, level);
 
-    return { start, removed: previous.length - start - tail, added: next.slice(start, next.length - tail) };
+    return store;
 }
 
-function levelFor(state: ModelState, key: string): LevelState {
-    const existing = state.levels.get(key);
+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);
+}
 
-    if (existing !== undefined) {
-        return existing;
+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);
     }
+}
 
-    const created: LevelState = { store: newStore(), ids: [], canExpand: new Map() };
-    state.levels.set(key, created);
+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 created;
+function collectFlips(store: LevelStore, level: Level): Set<number> {
+    const overlap = Math.min(store.refs.length, level.items.length);
+    const flipped: Set<number> = new Set();
+
+    for (let slot = 0; slot < overlap; slot++) {
+        if ((store.expandableFlags[slot] ?? false) !== (level.expandableFlags[slot] ?? false)) {
+            flipped.add(slot);
+        }
+    }
+
+    return flipped;
 }
 
-function refreshExpandable(current: LevelState, level: Level): void {
-    const next: Map<string, boolean> = new Map();
+function syncOverlap(context: SyncContext, store: LevelStore, level: Level): Set<number> {
+    const flipped = collectFlips(store, level);
+
+    if (flipped.size === 0) {
+        return flipped;
+    }
+
+    pruneSlots(context.expansion, store.path, (slot) => flipped.has(slot));
 
-    for (const [index, id] of level.ids.entries()) {
-        const isWanted = level.isExpandable[index] ?? false;
-        const previous = current.canExpand.get(id);
-        next.set(id, isWanted);
+    for (const slot of flipped) {
+        flipSlot(context, store, slot);
+    }
+
+    return flipped;
+}
 
-        if (previous !== undefined && previous !== isWanted) {
-            current.store.itemsChanged(index, 1, 1);
+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;
         }
     }
+}
 
-    current.canExpand = next;
+function shrinkStore(context: SyncContext, store: LevelStore, nextLength: number): void {
+    if (store.refs.length <= nextLength) {
+        return;
+    }
+
+    detachRefs(store, nextLength);
+    pruneSlots(context.expansion, store.path, (slot) => slot >= nextLength);
+    store.refs.length = nextLength;
+    store.objects.length = nextLength;
+    store.childStores.length = nextLength;
+    store.expandableFlags.length = nextLength;
 }
 
-function didSpliceLevel(state: ModelState, level: Level): boolean {
-    const current = levelFor(state, level.key);
-    const range = spliceRange(current.ids, level.ids);
+function emitTailSplice(store: LevelStore, previousLength: number, nextLength: number): void {
+    if (nextLength < previousLength) {
+        store.itemsChanged(nextLength, previousLength - nextLength, 0);
 
-    if (range === null) {
-        return false;
+        return;
     }
 
-    current.store.splice(range.start, range.removed, range.added.map((id) => objectFor(state, id)));
-    current.ids = [...level.ids];
+    if (nextLength > previousLength) {
+        store.itemsChanged(previousLength, 0, nextLength - previousLength);
+    }
+}
+
+function extendRuns(runs: SlotRun[], slot: number): void {
+    const last = runs.at(-1);
 
-    return true;
+    if (last !== undefined && last.start + last.length === slot) {
+        last.length += 1;
+
+        return;
+    }
+
+    runs.push({ start: slot, length: 1 });
 }
 
-function dropUnvisited(state: ModelState, visited: Set<string>): void {
-    for (const key of state.levels.keys()) {
-        if (!visited.has(key)) {
-            state.levels.delete(key);
-        }
+function collectFlipRuns(flipped: Set<number>): SlotRun[] {
+    const runs: SlotRun[] = [];
+
+    for (const slot of flipped) {
+        extendRuns(runs, slot);
+    }
+
+    return runs;
+}
+
+function emitFlips(store: LevelStore, flipped: Set<number>): void {
+    for (const run of collectFlipRuns(flipped)) {
+        store.itemsChanged(run.start, run.length, run.length);
     }
 }
 
-// Items keep their identity by id, so a collection that shrinks keeps its objects cached: filtering a long
-// list down and back up reuses them instead of rebuilding one GObject per row. Incremental filters shrink and
-// grow the list many times per keystroke, so the cache is only swept once it passes an absolute bound.
-function pruneObjects(state: ModelState, index: CollectionIndex): void {
-    if (state.objects.size <= OBJECT_CACHE_MAX) {
+function stepChildStore(context: SyncContext, store: LevelStore, slot: number, flipped: Set<number>): void {
+    const child = store.childStores[slot];
+
+    if (child == null || flipped.has(slot)) {
         return;
     }
 
-    for (const id of state.objects.keys()) {
-        if (!index.has(id)) {
-            state.objects.delete(id);
-        }
+    const level = context.index.children.get(slotPathAt(store, slot));
+
+    if (level !== undefined) {
+        syncLevel(context, child, level);
     }
 }
 
-function childStoreFor(state: ModelState, object: GObject.Object): Gio.ListStore | null {
-    const id = getId(object);
+function syncLevel(context: SyncContext, store: LevelStore, level: Level): void {
+    const previousLength = store.refs.length;
+    const overlap = Math.min(previousLength, level.items.length);
+    const flipped = syncOverlap(context, store, level);
+    shrinkStore(context, store, level.items.length);
+    growStore(context, store, level);
+    emitTailSplice(store, previousLength, level.items.length);
+    emitFlips(store, flipped);
+
+    for (let slot = 0; slot < overlap; slot++) {
+        stepChildStore(context, store, slot, flipped);
+    }
+}
 
-    if (id === null) {
+function childStoreFor(object: GObject.Object): Gio.ListModel | null {
+    const ref = slotRefFor(object);
+
+    if (ref === null) {
         return null;
     }
 
-    return state.levels.get(childLevelKey(id))?.store ?? null;
+    return ref.store.childStores[ref.slot] ?? null;
 }
 
-function ensureTree(state: ModelState): Gtk.TreeListModel {
-    state.tree ??= Gtk.TreeListModel.new(levelFor(state, ROOT_LEVEL_KEY).store, false, false, (object) =>
-        childStoreFor(state, object));
+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;
+    }
 
     return state.tree;
 }
 
 function desiredRootModels(state: ModelState, index: CollectionIndex): GObject.Object[] {
-    if (index.isTree) {
-        return [ensureTree(state)];
+    const [first] = state.groupStores;
+
+    if (first !== undefined && index.isTree) {
+        return [ensureTree(state, first)];
     }
 
-    return index.groups.map((level) => levelFor(state, level.key).store);
+    return [...state.groupStores];
 }
 
 function hasSameModels(previous: GObject.Object[], next: GObject.Object[]): boolean {
@@ -191,51 +293,63 @@ function syncRoot(state: ModelState, index: CollectionIndex): void {
 
     state.root.splice(0, state.rootModels.length, next);
     state.rootModels = next;
+    resetExpansion(state.expansion);
 }
 
-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)) {
+        const store = newLevelStore(level.path);
+        growStore(context, store, level);
+        state.groupStores.push(store);
     }
+}
 
-    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.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(),
+        groupStores: [],
         tree: null,
+        treeRoot: null,
+        expansion: createTreeExpansion(EMPTY_INDEX),
     };
 
     return {
         model: state.model,
+        expansion: state.expansion,
         treeModel: () => state.tree,
         sync: (index) => {
             syncModel(state, index);
@@ -243,4 +357,39 @@ function createCollectionModel(): CollectionModel {
     };
 }
 
-export { createCollectionModel, getId, type CollectionModel };
+class LazyLevelStore extends GObject.Object implements Gio.ListModelImpl {
+    declare itemsChanged: Gio.ListModel["itemsChanged"];
+    path = "";
+    refs: SlotRef[] = [];
+    objects: (Gtk.StringObject | null)[] = [];
+    childStores: (LevelStore | null)[] = [];
+    expandableFlags: boolean[] = [];
+
+    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 };

package/src/internal/collection.ts

@@ -1,104 +1,82 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import type * as Gtk from "@gtkx/gi/gtk";
-import type { Item } from "../types.js";
+import type { ListItem } from "../types.js";
 import type { CollectionIndex } from "./collection-index.js";
-import type { CollectionModel } from "./collection-model.js";
-import { getId } from "./collection-model.js";
-
-type Collection = {
-    isTree: boolean;
-    model: Gtk.FlattenListModel;
-    treeModel: () => Gtk.TreeListModel | null;
-    itemFor: (id: string) => Item | undefined;
-    sectionFor: (id: string) => unknown;
+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"> & {
+    itemAt: (ref: SlotRef) => ListItem | undefined;
+    sectionFor: (levelPath: string) => unknown;
     idAt: (position: number) => string | null;
+    pathAt: (position: number) => string | null;
     positionFor: (id: string) => number;
     positionsFor: (ids: string[]) => number[];
 };
 
-const ascending = (a: number, b: number): number => a - b;
-
-function visitRow(
-    tree: Gtk.TreeListModel,
-    position: number,
-    visit: (row: Gtk.TreeListRow, id: string | null) => void,
-): void {
-    const row = tree.getRow(position);
+const NO_POSITIONS: number[] = [];
 
-    if (row === null) {
-        return;
+function positionsFor(collectionModel: CollectionModel, ids: string[]): number[] {
+    if (ids.length === 0) {
+        return NO_POSITIONS;
     }
 
-    visit(row, getId(row.getItem()));
-}
+    const { expansion } = collectionModel;
 
-function eachRow(tree: Gtk.TreeListModel, visit: (row: Gtk.TreeListRow, id: string | null) => void): void {
-    for (let position = 0; position < tree.getNItems(); position++) {
-        visitRow(tree, position, visit);
-    }
+    return findPositions(expansion.index, expansion.slots, new Set(ids));
 }
 
-function collectWanted(item: GObject.Object | null, position: number, wanted: Set<string>, out: number[]): void {
-    const id = getId(item);
+function positionFor(collectionModel: CollectionModel, id: string): number {
+    const [first = -1] = positionsFor(collectionModel, [id]);
 
-    if (id !== null && wanted.has(id)) {
-        out.push(position);
-    }
+    return first;
 }
 
-function scanPositions(tree: Gtk.TreeListModel, ids: string[]): number[] {
-    const wanted = new Set(ids);
-    const positions: number[] = [];
-    const count = tree.getNItems();
-
-    for (let position = 0; position < count; position++) {
-        collectWanted(tree.getItem(position), position, wanted, positions);
+function refAt(collectionModel: CollectionModel, position: number): SlotRef | null {
+    if (position < 0) {
+        return null;
     }
 
-    return positions;
+    return slotRefFor(collectionModel.model.getItem(position));
 }
 
-function indexPositions(index: CollectionIndex, ids: string[]): number[] {
-    const positions: number[] = [];
-
-    for (const id of ids) {
-        const position = index.positionFor(id);
+function idAt(collectionModel: CollectionModel, index: CollectionIndex, position: number): string | null {
+    const ref = refAt(collectionModel, position);
 
-        if (position >= 0) {
-            positions.push(position);
-        }
+    if (ref === null) {
+        return null;
     }
 
-    return positions.toSorted(ascending);
+    return index.itemAt(ref.store.path, ref.slot)?.id ?? null;
 }
 
-function positionsFor(gtk: CollectionModel, index: CollectionIndex, ids: string[]): number[] {
-    if (!index.isTree) {
-        return indexPositions(index, ids);
-    }
+function pathAt(collectionModel: CollectionModel, position: number): string | null {
+    const ref = refAt(collectionModel, position);
 
-    const tree = gtk.treeModel();
+    if (ref === null) {
+        return null;
+    }
 
-    return tree === null ? [] : scanPositions(tree, ids);
+    return slotPathAt(ref.store, ref.slot);
 }
 
-function positionFor(gtk: CollectionModel, index: CollectionIndex, id: string): number {
-    const [first = -1] = positionsFor(gtk, index, [id]);
+function isCollectionIdle(collection: Collection): boolean {
+    const { expansion } = collection;
 
-    return first;
+    return !expansion.isApplying && !expansion.isSyncing;
 }
 
-function createCollection(gtk: CollectionModel, index: CollectionIndex): Collection {
+function createCollection(collectionModel: CollectionModel, index: CollectionIndex): Collection {
     return {
-        isTree: index.isTree,
-        model: gtk.model,
-        treeModel: () => (index.isTree ? gtk.treeModel() : null),
-        itemFor: index.itemFor,
+        model: collectionModel.model,
+        expansion: collectionModel.expansion,
+        treeModel: () => (index.isTree ? collectionModel.treeModel() : null),
+        itemAt: (ref) => index.itemAt(ref.store.path, ref.slot),
         sectionFor: index.sectionFor,
-        idAt: (position) => getId(gtk.model.getItem(position)),
-        positionFor: (id) => positionFor(gtk, index, id),
-        positionsFor: (ids) => positionsFor(gtk, index, ids),
+        idAt: (position) => idAt(collectionModel, index, position),
+        pathAt: (position) => pathAt(collectionModel, position),
+        positionFor: (id) => positionFor(collectionModel, id),
+        positionsFor: (ids) => positionsFor(collectionModel, ids),
     };
 }
 
-export { createCollection, eachRow, type Collection };
+export { createCollection, isCollectionIdle, type Collection };